Engineering Claude skills

Create algorithmic art with p5.js using randomness and interactive parameters.

Build production-grade web components and interfaces with distinctive, polished design.

Apply professional color and font themes to slides, docs, and web pages.

Build complex React artifacts with Tailwind CSS and shadcn/ui components.

Test local web apps with Playwright, verify UI behavior, and capture screenshots.

Create, edit, and format Word documents with tables, images, and tracked changes.

Create original posters and visual art in PNG and PDF formats.

Build, debug, and optimize Claude API applications with caching and model migration support.

Build protocol servers that connect language models to external APIs and services.

Open, edit, and create Excel and CSV files with formulas, formatting, and data cleaning.

Guide structured workflows for writing docs, proposals, and technical specs collaboratively.

Create, edit, and optimize Claude skills with performance testing and benchmarking.

The official Supabase skill: Auth, RLS, Edge Functions, Realtime, Storage, migrations, and the JS/SSR clients — straight from the Supabase team.

Supabase's official Postgres performance playbook: indexing, connection pooling, pagination, locking, and query tuning.

Jesse Vincent's full Claude Code methodology — TDD, brainstorming, git worktrees, all auto-triggering.

Force Claude to ask questions and pressure-test the idea before any code gets written.

Split independent work across parallel subagents and merge the results, like a frontier-model orchestrator.

Execute a written plan in controlled batches with review checkpoints, instead of one giant leap.

Take review feedback rigorously — verify each claim, push back with evidence, fix properly.

Have the model request a real review of its own work before it merges anything.

Replace guess-and-check debugging with a four-phase root-cause investigation.

Enforce strict RED → GREEN → REFACTOR: the failing test comes first, every time.

Never let the model claim 'done', 'fixed', or 'passing' without running the proof first.

Turn any task into a step-by-step implementation plan another engineer — or another model — could execute.

The meta-skill: teach the model to write, test, and improve new skills of its own.

Analyze your codebase to create a trimmed ECC install plan with only the skills you actually need.

Learn REST API best practices for resource naming, versioning, pagination, and error handling.

Debug AI agent failures by diagnosing loops, token waste, and task drift systematically.

Delegate coding tasks to multiple AI models and get the best result.

Configure cross-session user memory and multi-profile isolation for AI agents.

Delegate coding tasks to OpenHands, a model-agnostic agent via terminal.

Query wallet balances, token info, gas prices, and transactions across 8 blockchain networks.

Create animated GIFs optimized for Slack messages and custom emojis.

Build multi-component React artifacts with Tailwind CSS and shadcn/ui components.

Test local web apps with Playwright to verify frontend functionality and capture screenshots.

Create, edit, and optimize skills with performance testing and benchmarking.

Build and optimize Claude API applications with prompt caching and model migration.

Build Model Context Protocol servers to connect AI with external APIs and services.

Delegate code tasks to compressed subagents that save context space.

Review LLM spending, quality metrics, and cost savings from Caveman Cloud analysis.

Compress memory files into shorthand to save tokens while preserving content.

Display real token usage and estimated savings for your current session.

Garry Tan's 23-role Claude Code stack — CEO, designer, eng, QA, security, release, all as slash commands.

Automate web browsing tasks like filling forms, taking screenshots, and extracting data.

Create design tokens, component specs, and branded presentations from a systematic token architecture.

Turn any codebase or document folder into an interactive knowledge graph with community detection.

Add persistent memory to Claude agents across sessions via context injection.

Monitor a pull request until it's ready to merge, tracking comments and CI checks.

Execute multi-phase plans by coordinating specialized subagents.

Generate a summary of open PRs, issues, and releases for your team.

Manage job data and career operations through customizable plugins.

Scan job listings from Apify actors and map results into your career tracking system.

Extract job URLs from Gmail and add them to your career pipeline.

Generate professional architecture and workflow diagrams as HTML files with dark/light themes and image export.

Review code and issues by value, cost, and impact to guide maintenance decisions.

Analyze git diffs and pull requests to understand changes, affected components, and risks.

Visualize your codebase's knowledge graph in an interactive web dashboard.

Ask questions about your codebase using an AI-powered knowledge graph.

Analyze open GitHub issues and PRs, generating evidence-backed reports without modifying anything.

Compare your code to the latest npm version and list what's changed.

Discover a hidden easter egg about the Oh My OpenCode development plugin.

Turn code folders into interactive knowledge graphs with community detection and query tools.

Create intelligent multi-step plans to achieve complex objectives using adaptive reasoning.

Automate website interactions like filling forms, clicking buttons, and extracting data.

Reference CSS classes and HTML patterns for presentation components.

Test and debug web apps in real browsers using Chrome DevTools inspection.

Design stable, well-documented APIs and module boundaries that are hard to misuse.

Set up and configure automated build and deployment pipelines with quality gates.

Review code across correctness, readability, architecture, security, and performance.

Review and rewrite Architecture Decision Records for clarity and reader understanding.

Implement the visitor pattern for type-safe discriminated unions with multiple dispatch sites.

Update Biome package versions and align configuration files across your repository.

Write Markdown with soft wrapping for cleaner diffs and easier editing.

Create GitHub issues for your repository following its template format.

Verify actual demand exists before reviewing code that adds new surface area.

Test Cherry Studio pull requests with automated UI testing and code review.

Build interactive 3D scenes and product configurators for web browsers.

Audit digital products for WCAG compliance and identify accessibility barriers.

Analyze, index, and generate wikis for your codebase via command line.

Trace bugs and errors by mapping code execution flows and finding root causes.

Review pull requests for production readiness using a coordinated multi-reviewer approach.

Create 40+ diagram types as branded HTML, SVG, or PNG files.

Diagnose your AI project and create an optimal technical roadmap in Spanish.

Design, write, and deploy new skills to your repository following Diamond Standard.

Manage Sub2API accounts, codes, proxies, and backend settings via admin API.

Route prompts to Claude, Codex, Gemini, or other AI models and save results.

Remove bloat and repetition from AI-generated code while preserving behavior.

Iteratively improve a single mission until it passes evaluation or hits time limit.

Execute bundled skill commands without loading full skill descriptions.

Organize open GitHub issues into a priority table with recommendations.

Create isolated Herdr sessions for safe testing and debugging without affecting your main session.

Control terminal multiplexer workspaces, tabs, and panes for coding agents.

Set up alerts for Telegram, Discord, or Slack using plain language.

Automate browser tasks like clicking, filling forms, and extracting data from websites.

Systematically test a web app to find bugs, UX issues, and quality problems with detailed evidence.

Automate browser tasks like navigating sites, filling forms, taking screenshots, and scraping data.

Run browser automation on AWS Bedrock's managed cloud browsers.

Run headless Chrome browser automation in Vercel's ephemeral microVMs.

Automate desktop apps like Slack, VS Code, and Discord through their native interfaces.

Writes reliable Playwright and Cypress E2E tests and fixes flaky ones.

Patterns for generics, conditional types, mapped types, and type-safe TypeScript utilities.

Picks the right React state tool and gives typed store and query patterns to copy.

Reference patterns for Next.js 14+ App Router, Server Components, and streaming.

Writes and validates OpenAPI 3.1 specs from code or design-first contracts.

Separates read and write models with CQRS patterns for scalable, event-sourced systems.

Reference for service boundaries, inter-service communication, and resilience patterns.

Scaffolds production FastAPI projects with async patterns, DI, and pytest setup.

Wires Vault, AWS/Azure/GCP secret stores, and rotation into CI/CD pipelines.

Sets up Prometheus scraping, recording rules, and alerting with proven conventions.

Sets up GitOps delivery for Kubernetes with ArgoCD or Flux and auto-sync.

Ready-to-use GitHub Actions workflows for testing, building, and deploying with sane defaults.

Generates production Kubernetes manifests with resource limits, health checks, and security contexts.

Builds reusable Terraform modules for AWS, Azure, GCP, and OCI with tested IaC patterns.

Split complex tasks across multiple focused agents while keeping strategic control in the parent.

Build Feishu and Lark bot automations, documents, sheets, and approval workflows securely.

Design, build, and debug Model Context Protocol servers with stdio and HTTP/SSE transports.

Search live tech job listings across 50+ job boards and multiple countries.

Search live Danish job listings by location, category, and employment type.

Manage LLM provider credentials and integrations in Arize for evaluators.

Create annotation schemas and manage human review workflows in Arize.

Generate customized instruction files for AI coding agents like Copilot and Claude.

Audit your repository's AI-readiness and generate an interactive HTML dashboard.

Access audit logs and usage reports from Google Workspace Admin SDK.

Analyze your codebase and recommend Claude Code automations to optimize your workflow.

A sample skill demonstrating slash command format and frontmatter options.

Create a reference template for building Claude Code plugin skills.

Configure your Discord bot token and review channel access policies.

Audit and improve CLAUDE.md files to optimize Claude's project context.

Develop and deploy MicroPython apps to your Cardputer device without re-flashing.

Flash and set up M5Stack ESP32 devices with UIFlow 2.0 firmware and MicroPython apps.

Determine correct file placement and structure for your project.

Automatically fix GitHub bug issues and submit pull requests.

Auto-fix high-frequency Sentry errors by analyzing stack traces and submitting pull requests.

Reduce Vercel costs and improve performance using verified metrics and framework-specific recommendations.

Build and maintain cross-browser extensions for Chrome, Firefox, and Edge.

Pack codebases into single files optimized for AI analysis and exploration.

Write commits that capture intent, decisions, and constraints alongside code changes.

Generate and iterate high-performing ad copy, headlines, and variations for any platform.

Analyze competitor URLs to generate detailed profiles with market data and insights.

Generate and optimize images for blogs, social media, product mockups, and brand assets.

Design and plan A/B tests to measure which version performs better.

Set up and audit analytics tracking for events, conversions, and marketing measurement.

Plan what content to create and organize topics for your editorial roadmap.

Create automated email campaigns to nurture leads and guide customers through their journey.

Improve form completion rates by reducing friction and optimizing fields.

Optimize your content to be cited and surfaced by AI search engines.

Analyze your app listing against best practices and get a prioritized optimization plan.

Review and polish marketing copy to strengthen messaging and improve readability.

Plan and build free marketing tools to generate leads and attract organic traffic.

Build flexible, maintainable React components using composition techniques.

Optimize React and Next.js code following Vercel's performance best practices.

Build performant React Native apps with optimization and animation guidance.

Animate page and component transitions using React's native View Transition API.

Deploy your app to Vercel with preview or production environments.

Deploy and manage Vercel projects using token-based authentication instead of interactive login.

Review UI code for compliance with web interface best practices and accessibility standards.

Create and edit embedded skills in Crush's binary system.

Create and manage custom shell commands for Crush's embedded shell environment.

Configure Crush settings, providers, servers, and permissions via JSON.

Add and debug hooks to gate, approve, or modify tool calls in Crush.

Open a pull request on pascalorg/editor from your current branch.

Open or update a pull request with a plain-language description of your branch changes.

Keep task plans and progress in markdown files that survive context loss.

Generate Git commit messages following project style guidelines.

Index and reference guide for Agent Memory's MCP tools and parameters.

Let your agent review code using its own intelligence while OCR handles file filtering.

Create animation-rich HTML presentations from scratch or convert PowerPoint files.

Review code changes, pull requests, and commits for bugs and quality issues.

Open websites and interact with pages to extract data and automate tasks.

Customize and manage keyboard shortcut bindings for cmux.

Customize cmux actions, shortcuts, layouts, and terminal preferences.

Run health checks and debug reports for cmux hooks, sessions, and automation issues.

Compress images to WebP or PNG format with automatic tool selection.

Built by Vercel Labs. Claude searches the open skill ecosystem for you — surfaces real, popular skills instead of reinventing them.

Trace and debug code issues using semantic search and execution flow analysis.

Build and maintain a knowledge graph of your codebase for smarter reviews.

Take a quick quiz to find your starting point in an AI engineering curriculum.

Test your understanding of AI Engineering from Scratch course phases.

Build knowledge graphs from documents and search them with natural language queries.

Coordinate GitHub workflows and marketing tasks using parallel subagents for issues, PRs, and releases.

Run live QA and end-to-end tests for provider validation and app configuration.

Check provider usage, limits, credits, and configuration health in JSON format.

Manage macOS app releases with versioning, notarization, and Homebrew updates.

Extract web pages as clean, readable Markdown with clutter removed.

Save conversation insights and decisions to your Obsidian vault.

Convert documentation, repos, PDFs, and videos into AI-ready skills automatically.

Search Slack chat history to find solutions, code snippets, and team decisions.

Install or uninstall memU integration for your agent system.

Build and optimize React and Next.js applications with performance analysis and accessibility.

Build immersive scroll-driven websites with parallax effects, text animations, and interactive depth.

Scan code for accessibility violations and generate WCAG 2.2 compliance reports.

Analyze customer accounts to predict churn risk and identify expansion opportunities.

Analyze sales pipeline health, forecast accuracy, and go-to-market efficiency for SaaS teams.

Analyze RFP requirements, build competitor comparisons, and plan proof-of-concept engagements.

Prepare tough answers and narratives for adversarial board questions.

Identify hidden weaknesses in your plan before they cause failure.

Challenge your business decisions and plans with adversarial questions before they fail.

Navigate difficult choices with no clear right answer using structured analysis.

Challenge your business assumptions by stress-testing revenue, market size, and competitive risks.

Get strategic advice from virtual CEO, CTO, CFO, and other executives for your business.

Get executive guidance on strategy, fundraising, board management, and organizational leadership.

Audit release readiness by comparing commits against changelog and docs.

Organize open GitHub issues into a prioritized table with recommendations.

Manage workspaces, tabs, and panes in herdr from within the terminal environment.

Generate well-formatted Git commit messages following project conventions.

Generate SQL queries from plain English descriptions for BigQuery, PostgreSQL, MySQL, and more.

Find gaps between what code should do and what it actually does.

Build serverless apps, APIs, and infrastructure on Cloudflare's global edge network.

Answer questions about Effect, a TypeScript framework for robust applications.

Build stateful AI agents and workflows on Cloudflare Workers with real-time capabilities.

Launch and debug the AO Electron desktop app with real or isolated data.

Reference for the AO CLI commands to spawn workers, manage sessions, and control agents.

Triage bugs, find duplicates, and file GitHub issues with full context.

Format Linear or Superset tickets with a standardized three-section structure.

Debug browser automation failures on complex websites like LinkedIn and Twitter.

Debug queen sessions, colony forks, and worker spawns without affecting production.

Run integration tests and generate a detailed HTML report with results.

Assemble two AI agents to analyze root causes and plan solutions when stuck.

Cut a beta release and publish to npm with the beta tag.

Cut a stable release or promote a beta version of Paseo to production.

Create and edit Obsidian Canvas boards with nodes, links, and visual layouts.

Run bounded research loops, gather cited sources, and draft documented reports.

Spawn workers, manage sessions, and control the AO daemon from your terminal.

Triage bugs, find duplicates, and file GitHub issues with full context.

Configure git commits and changelogs following Chinese-adapted Conventional Commits standards.

Create beautiful dark-themed presentation decks with animated knowledge graphs and code highlighting.

Create, discover, and run domain-specific skills bound to automated workflows.

Organize multi-platform agent projects with consistent naming, bridging, and structure.

Debug agent tool-calling issues through guided diagnosis and schema repair.

Design production-grade interfaces, components, and visual layouts with modern polish.

Simplify documentation to reduce cognitive load and improve comprehension.

Control Chrome via CDP to automate browser tasks and reuse login sessions.

Interact with OmniRoute A2A server, send tasks, and test the agent-to-agent protocol.

Backup and restore OmniRoute data, manage snapshots, and sync to cloud storage.

Verify code changes won't break the Pierre diff viewer integration.

Draft release notes with contributor credit, bump versions, and publish tagged releases.

Build tools to import, inspect, and migrate DeepChat chat data and configurations.

Control desktop apps and windows through screenshots, accessibility trees, and UI actions.

Read, update, and triage Linear issues directly from your workflow.

Control iOS simulators and interact with emulator streams directly from Orca.

Control Orca worktrees, terminals, repos, and embedded browser from Claude.

Format command-line messages and help text with consistent colors and patterns.

Guide tend CI workflows with worktrunk conventions, codecov polling, and Rust test commands.

Publish a new version to crates.io and GitHub.

Generate an AI design contract and evaluation strategy for system development phases.

Generate unit and E2E tests for completed project phases based on requirements.

Ask clarifying questions before starting work on ambiguous requests.

Control Chrome via CDP protocol to automate browser tasks and reuse login sessions.

Generate and evaluate improvement ideas for your project workflow.

Identify high-value untested behaviors and file QA test ideas.

Run one iteration of automated quality assurance: pick a test task, build tests, and open a PR.

Execute one autonomous development iteration: fix issues, merge PRs, or build a queued idea.

Find the simplest solution that works, questioning if the task is necessary.

Scan your entire codebase to find dead code, over-engineering, and simplification opportunities.

Display a quick-reference guide for Ponytail modes, skills, and commands.

Find over-engineered code, unnecessary dependencies, and complexity to delete.

Generate flowcharts, architecture diagrams, and visual system maps as PNG, SVG, or PDF.

Query a codebase graph to understand code structure and dependencies without reading source files.

Convert markdown workflow specs into compiled GitHub Actions using AI engines.

Automate browser interactions and test web pages with Playwright commands.

Automate tasks in your existing Chrome browser without creating new profiles.

Add redacted agent logs to GitHub PRs and issues for transparency.

Control local Electron apps and run UI tests via Chrome DevTools Protocol.

Review code changes for quality, reuse, and minimal, modern implementation.

Generate product screenshots by automating browser capture with AI verification.

Reverse-engineer design tokens, components, and patterns from live products or screenshots.

Build structured specifications from multi-AI research and consensus.

Generate and maintain a source-grounded wiki documenting your codebase architecture and modules.

Deploy static files to IPFS or full-stack web projects with backend APIs and databases.

Create and upload static HTML share pages for projects, reports, and demos.

Extract text and visual details from images that Claude cannot see natively.

Create cinematic product videos from shot templates, screenshots, and audio assets.

Add a new Roslyn diagnostic rule with metadata, code fix, and tests.

Compress AI context by up to 99% when reading files, searching code, and running commands.

Scan your codebase for dead code, tech debt, and quality issues.

Find and discover NVIDIA-related skills for GPUs, CUDA, Jetson, and other NVIDIA products.

Install, deploy, and validate NVIDIA AI-Q Blueprint infrastructure.

Generate interactive HTML diagrams to visualize relationships, sequences, and structures.

Index, organize, and manage your codebase with search and code graph infrastructure.

Search and understand code structure, dependencies, and architecture using semantic analysis.

Autonomously research, benchmark, and implement performance optimizations with production-ready pull requests.

Test AI systems for security vulnerabilities like prompt injection and jailbreaking.

Extract colors, fonts, and design tokens from any website into multiple formats.

Manage development workflows using OpenSpec specifications and Superpowers execution framework.

Check web interfaces for WCAG compliance and keyboard, screen-reader, and focus accessibility.

Automatically label GitHub issues and pull requests across your repository.

Red-team a proposal with independent perspectives, then distill findings into actionable objections.

Get a cross-model review from Google Gemini on code, ads campaigns, or SEO changes.

Measure and analyze Go application performance with benchmarks, profiling, and statistical comparisons.

Build and extend command-line tools in Go with proper structure and flag handling.

Design reliable, scalable data systems with proven patterns for consistency, replication, and streams.

Generate well-formatted pull request titles, bodies, and comments.

Track code quality metrics across repositories with weekly automated scorecards.

Launch and monitor AI coding agents in tmux with session management and parallel worktree support.

Search and index your codebase semantically to find relevant code quickly.

Run end-to-end validation tests with screenshot evidence for pull requests.

Run end-to-end tests for claude-tap using pytest.

Generate GIF and MP4 demo videos from terminal recordings and screenshots.

Test JavaScript logic in HTML files using Python unit tests and browser integration tests.

Search and manage documentation, live streams, and skills across platforms.

Extract and organize your GitHub Copilot sessions into searchable Obsidian wiki pages.

Turn website data extraction into reusable, deployable skills with automatic API discovery.

Automate browser tasks like navigation, form filling, and content extraction for AI agents.

Audit your CLAUDE.md file for vague instructions, stale facts, and unnecessary bloat.

Install Codex skills from curated lists or GitHub repositories.

Manage code execution with frozen requirements, bounded scope, and verification checkpoints.

Build custom extensions for Super Agent Party with frontend or Node.js backends.

Discover and install agent skills to extend your capabilities.

Create, analyze, and modify Word, Excel, and PowerPoint files without Office installed.

Convert security findings into a defensible risk score and dollar-based breach cost estimate for board reports.

Generate standards-compliant DCAT feeds for your PortalJS portal to enable harvesting by open-data registries.

Create and register code patches for Claude Code customizations.

Review code changes for quality, security, and performance issues.

Fetch brand logos and cloud service icons as ready-to-use SVG files.

Set up persistent memory files to retain project knowledge across Claude sessions.

Update documentation across your repository when adding a new ArcKit command.

Provision and orchestrate GPU workloads across clouds, Kubernetes, and on-premise clusters.

Convert any webpage to clean markdown with rendered HTML snapshot.

Avoid common GA4 API pitfalls that return misleading data instead of errors.

Audit blog posts across quality, SEO, and AI content to get a scored report with actionable improvements.

Generate audio narration of blog posts with multiple voices and podcast modes.

Access documentation and configuration guidance for the docmd AI-first docs engine.

Generate systematic checklists to verify design implementations match specifications.

Delegate coding tasks to Cursor Agent and review diffs before committing.

Build ChatGPT and MCP apps from concept to deployment.

Guide developers through creating and deploying ChatGPT apps with tools and custom UI.

Guide developers through creating and deploying MCP apps with tools and custom UI views.

Turn ideas into designs through guided questions and collaborative dialogue.

Load and execute implementation plans with built-in review checkpoints.

Delegate independent tasks to isolated agents working simultaneously without shared state.

Guide completion of development work with merge or cleanup options.

Search code by meaning and trace function calls in your codebase.

Create a new release with CI checks, version bumps, changelog updates, and GitHub release.

Generate flat favicons from prompts and export as PNG, ICO, and WebP files.

Discover, build, and run repeatable AI-agent loops with safety checks and evidence tracking.

Ask clarifying questions before implementing to avoid misaligned work.

Design cohesive visual stories for GitHub READMEs with custom SVG assets.

Merge verified spec changes and archive them following OpenSpec delta semantics.

Fix bugs quickly with open → build → verify → archive workflow.

Generate design documents and specifications through structured brainstorming.

Identify pitfalls in Google Search Console API queries to avoid silent errors.

Add a new OAuth provider to your registry with platform approval and connection flows.

Sync changes from hotpath crates to their meta counterparts for profiler testing.

Add performance profiling to your Rust project with zero overhead when disabled.

Capture diagnostic information and file bug reports for OpenKnowledge issues.

Maintain an agent-authored wiki documenting your codebase's architecture, modules, and flows.

Import media files into OpenChatCut projects for video editing.

Edit local video projects with timeline, captions, and motion graphics tools.

Plan and structure AI-generated short films with storyboards, shot lists, and visual prompts.

Create durable handoffs to pass work context and progress to teammates.

Create a summary document for the next agent to continue your work seamlessly.

Build UI components following Penguin Harness web app conventions and patterns.

Build stateful AI agents using graph-based workflows and specialized skills.

Improve agent performance using benchmarks, scoring, and iterative refinement cycles.

Create and refine project specifications through guided analysis and documentation-driven development workflows.

Capture, clarify, and review product requirements before development starts.

Create and update feature task plans with progress tracking and blocker management.

Turn a topic into a narrated 4K explainer video with script, voiceover, and music.

Set up and run OpenTag to connect collaboration platforms with local coding agents.

Check your UI against WCAG 2.2 standards and identify accessibility issues with fixes.

Create, edit, and validate n8n workflows and automation configurations.

Generate multiple competing explanations for an observed problem or signal.

Decompose boundary statements into legal, admissibility, deontic, and evidence categories.

Manage project governance charters, interviews, and doctrine artifacts in Spec Kitty.

Add analytics cards that parse local data and display metrics with period comparisons.

Add new AI assistant providers to ClaudeBar following test-driven development patterns.

Structure code so business logic stays independent from frameworks and databases.

Create generative art with p5.js using custom algorithms and interactive parameters.

Create complex React artifacts with Tailwind CSS and shadcn/ui components.

Apply professional color and font themes to slides, docs, and web pages.

Test local web applications with automated browser interactions and debugging.

Create original visual designs as PNG and PDF files using design philosophy.

Build Model Context Protocol servers to connect LLMs with external APIs and services.

Detect AI-generated audio, images, video, and text to identify deepfakes and synthetic media.

Create, edit, and analyze Excel files with formulas, formatting, and data visualization.

Generate meeting prep materials and agendas by gathering Notion context and research.

Turn product specs into actionable Notion tasks with implementation plans.

Generate customer-friendly release notes from git commit history automatically.

Explain code, features, or pull requests step-by-step for beginners.

View your context usage trends, quality scores, and session history in a live dashboard.

Search, transcribe speech, and extract text from documents using Azure AI.

Set up AI Runway on Azure Kubernetes Service from cluster to running model.

Fetch and summarize pull request review comments into actionable items.

Capture bug details and create structured reports your team can act on.

Find security, correctness, and quality issues across your codebase.

Set up Agentlas project continuity files in a workspace folder.

Create interactive HTML mockups to design and plan UI layouts visually.

Create flowcharts, architecture diagrams, and visual sketches with Excalidraw.

Design database schemas visually with entity-relationship diagrams and Prisma format.

File bug reports and feature requests for Nimbalyst to GitHub Issues.

Automate browser interactions and render web pages for visual evidence.

Design multi-agent systems with defined roles, handoffs, and team structure.

Learn state management best practices for the vm0 platform.

Apply consistent design patterns and conventions when building CLI commands.

Design and optimize SQL, NoSQL, and vector databases with schemas, indexing, and compliance.

Build and review APIs, databases, authentication, and server logic with clean architecture.

Analyze software architecture decisions with tradeoff analysis, risk assessment, and stakeholder synthesis.

Ask clarifying questions before implementing to prevent building the wrong thing.

Organize branch chains and manage stacked rebases, merges, and PR workflows.

Archive completed tasks and record your coding session progress.

Find, download, and track movies, TV shows, and anime from your local media agent.

Review GitHub pull requests or local branches with parallel independent reviewers.

Install, list, validate, and package LiveAgent skills from various sources.

Design schemas, optimize queries, and choose the right database for your application.

Start or continue implementing tasks from an OpenSpec change.

Finalize and archive a completed change in your experimental workflow.

Build Node.js backend AI apps with text and image generation models.

Call AI models directly from browser apps using CloudBase JavaScript SDK.

Generate and stream text using AI models in WeChat Mini Programs.

Handle server-side authentication, user lookup, and custom login in Node.js CloudBase apps.

Resume an in-progress task by loading the current phase and step details.

Search previous coding sessions for relevant context, decisions, and past attempts.

Explore traces, services, and performance metrics in Datadog.

Extract design systems from UI screenshots and generate implementation-ready design prompts.

Optimize your CLAUDE.md file for clarity, efficiency, and maintainability.

Diagnose and fix plugin installation, enablement, and activation problems.

Configure custom statuslines for Claude Code with token counts, costs, and git status.

Generate a trusted workflow with flowchart and adapter for any business domain.

Transcribe audio and video files to text with fast local or remote processing.

Investigate and resolve Cloudflare configuration issues using API-driven evidence gathering.

Merge redundant documentation files while keeping all unique content and information.

Transform meeting transcripts into structured minutes with speaker identification and iterative review.

Convert markdown documents to professional PDFs with Chinese font support and theme options.

Orchestrate complex tasks with parallel verification agents and strategic execution gates.

Convert DOCX, PDF, and PPTX files to clean, readable Markdown.

Debug network and streaming bugs using evidence-driven investigation and layered isolation experiments.

Deploy configuration changes to production after editing config files.

Capture macOS application windows programmatically with window control and automation.

Recover context from interrupted Claude sessions and continue work without replaying full history.

Find new Japanese NLP GitHub repositories missing from awesome-japanese-nlp-resources lists.

Create and triage GitHub issues from repository evidence and bug reports.

Design documentation that's easy to understand, remember, and scan quickly.

Write warm, direct feedback for pull requests, issues, and team messages.

Export and import Claude Code sessions between developers securely.

Run Claude Code with external AI models through sub-agents.

Delegate coding tasks to Antigravity CLI and review diffs before landing changes.

Write and update documentation for features, guides, and specs in Paca Docs.

Convert product requirements into structured epics with user stories and spec documents.

Turn bug reports and feature ideas into polished pull requests for Retentioneering.

Author and publish curated release note story decks with images and videos.

Extract YouTube metadata, subtitles, and download videos with proxy support.

Scrape websites and extract structured data without getting blocked.

Debug and verify changes to the CORAL framework with targeted reproduce loops.

Convert markdown files into a complete static website with zero configuration.

Follow code quality, testing, and contribution guidelines for the Marmite codebase.

Document real-world examples and empirical evidence for engineering practices.

Recreate award-winning creative websites with forensic precision by reverse-engineering their code.

Translate and sync App Store metadata to multiple languages automatically.

Test a running assistant end-to-end from the terminal without a web UI.

Review components for accessibility issues and WCAG compliance.

Automatically update component documentation when source code changes.

Explain what code does in plain English.

Fix GitHub issues by number following project best practices.

Scaffold a new React component with a matching test file.

Coordinate component sourcing across distributors and manage electronics project bills of materials.

Extract component specifications, pinouts, and electrical characteristics from datasheet PDFs.

Store and retrieve decisions, discoveries, and patterns across chat sessions.

Search electronic components, check pricing and stock, download datasheets.

Verify a game build is playable by testing rendering, input, core loop, and designed outcomes.

Install and manage a shared Markdown-based memory system for Claude agents.

Create and configure MATLAB experiments to sweep parameters and compare configurations.

Import PyTorch, ONNX, and Keras models into MATLAB as dlnetwork objects.

Automate website interactions like filling forms, clicking buttons, and scraping data.

Classify and resolve conflicts when ingesting data bundles.

Create interactive UI mockups, prototypes, and wireframes as self-contained HTML.

Start or restart a local Temps development server with isolated ports per branch.

Access stock quotes, charts, and financial data via the Yahoo Finance library.

Create and update terminal demo GIFs for mcpc using VHS scripts.

Review design specs and prototypes against aesthetic standards and anti-AI-slop guidelines.

Deploy merged code to an isolated local UAT environment with pre-flight checks and smoke tests.

Refactor code for readability using DRY, KISS, and YAGNI principles.

Set up and manage scheduled automation agents that run tasks on your GitHub repository.

Build dashboards using YAML or TSX with widgets, filters, and templating.

Control and inspect live browser panels within Horizon workspace.

Find the right AI model for your task with capabilities and cost comparisons.

Query and manage MySQL or PostgreSQL databases on AWS Aurora with serverless scaling.

Convert planning documents into an executable contract for implementation.

List, monitor, inspect, and control active Bernstein agents in real-time.

Generate framework-aware code from Figma designs using your project's existing components and tokens.

Audit websites and repositories for SEO issues, Core Web Vitals, and schema optimization.

Create and review technical documents using PRD, ADR, and design templates.

Choose the right development approach for your project based on current state analysis.

Analyze any codebase and explain what it does, why, and what alternatives exist.

Track project tickets, issues, and context across coding sessions.

Manage and monitor the AWS-hosted Pilot daemon with status, logs, and operational commands.

Explore and pressure-test new features, designs, and architecture before implementation.

Clarify ambiguous goals and competing constraints before making directional decisions.

Track and record AI agent work using agentacct as a lightweight workflow ledger.

Interview users deeply about specs and tasks to extract complete implementation details.

Convert conversations into Flow Next spec files with review before saving.

Visualize spec dependencies, blocking chains, and execution order.

Search your past AI coding sessions to find previous solutions and decisions.

Reference guide for GSAP animation methods, easing, timelines, and performance optimization.

Install and wire reusable blocks and components into HyperFrames compositions.

Train custom anime character and style adapters for the Anima model locally.

Run questions across multiple AI providers and synthesize their responses.

Create flowcharts, sequence diagrams, and other visual charts.

Navigate websites, interact with pages, and extract data through automated browser control.

Delegate coding tasks to a separate Claude session, review the diff, and merge the changes.

Design and implement Flutter state management using the Bloc and Cubit patterns.

Review Flutter and Dart pull requests against a structured quality checklist.

Structure Flutter apps with layered, feature-first architecture and dependency injection.

Convert approved game design and art direction into a playable game build.

Define visual style, composition, and audio direction for game production from design specs.

Build native UIs for Android, iOS, Desktop, and Web with Jetpack Compose.

Scaffold new external service integrations with credentials, auth polling, and settings UI.

Debug ACP agents by spawning them, capturing JSON-RPC frames, and analyzing capabilities.

Delete local Git branches whose remote has been removed, including worktrees.

Compress memory files into minimal text format to save tokens while preserving all essential content.

Generate changelogs automatically from Git commit history.

Identify performance bottlenecks and generate optimization suggestions for code, databases, and networks.

Generate CI/CD workflows for GitHub Actions based on your project's tech stack.

Analyze GitHub issues for validity, priority, and recommended actions.

Create, edit, test, and optimize skills with performance benchmarking and accuracy improvements.

Execute stories end-to-end through planning, validation, execution, and quality gates.

Break down project scope into epics, stories, and prioritized tasks.

Search EasyEDA agent repository for capabilities, implementation examples, and design documentation.

Run multiple solution attempts in parallel and merge the best parts into one optimized result.

Investigate Sentry issues, events, traces, and logs from the command line securely.

Resume conversations later when background tasks like CI jobs or reviews complete.

Configure and manage local Avibe installations, routing, models, and integrations.

Inspect and modify Avibe settings, routing, tasks, and cloud remote access.

Build a mental map of your codebase once, then answer questions across multiple turns.

Monitor and manage long-running AI coding missions, switch backends, and keep them progressing toward completion.

Coordinate and delegate tasks to parallel workers with built-in monitoring and integration.

Create and manage reusable skills, agents, commands, and tools in your library.

Calculate your agent's productivity score from session metrics and cache efficiency data.

Review UI code for compliance with web design and accessibility best practices.

Plan and validate your design before building anything.

Classify incoming work requests and route them to the appropriate workflow skill.

Build native mobile app screens with production-quality design and UX.

Build AI chat interfaces with pre-made conversation and message components.

Search and retrieve SVG icons from 200+ libraries instantly.

Format concise, scannable output rules for AI agents and planning.

List, query, version, and clean up model data artifacts with flexible filtering.

Generate a checklist document of Java system prompts from your skills inventory.

Generate a Java agents inventory checklist document from a predefined template.

Generate a Java commands inventory checklist document from a template.

Install predefined project commands into your IDE configuration directories interactively.

Generate professional system architecture diagrams as shareable HTML and SVG files.

Reference formatting rules for changelog management and semantic versioning.

Audit components for WCAG accessibility issues and get fixes.

Add loading, success, error, and empty states to your components.

Create and apply brand.yml files for consistent branding across Shiny and Quarto projects.

Generate accessible alt text descriptions for images and data visualizations.

Split epics into detailed feature documents with scope and acceptance criteria.

Update architecture documentation and diagrams without reinitializing your repository.

Write, edit, and debug Vera code, a functional language with typed slots and mandatory contracts.

Plan projects and create task boards with dependencies and agent assignments.

Convert a photo of handwriting into an installable font file.

Run security, quality, and performance audits on entire codebases with detailed, quote-backed reports.

Monitor and fix continuous integration failures on pull requests automatically.

Validate code changes against project contribution guidelines and checklists.

Automate GitHub commits, pull requests, and release notes for code changes.

Build sprite and skeletal 2D animations in Godot with frame timing and procedural effects.

Create realistic 3D surfaces using Godot's PBR material system and texture workflows.

Draft replies to code review questions using implementation reasoning.

Get design feedback by comparing your screen to real examples and improvement ideas.

Design refined, purposeful UI animations for hovers, transitions, and micro-interactions.

Render interactive SVG diagrams, charts, and HTML widgets directly in chat.

Find routes, locations, distances, and elevation data for any geographic query.

Learn the architecture and design decisions for the Google Maps MCP server project.

Find the exact name for any web animation or motion effect from a vague description.

Compile agent artifacts into a structured, interlinked markdown wiki.

Tag main with the next version to cut a new macOS release.

Generate shadcn/ui-styled status badges for project documentation.

Get code review, debugging help, and design feedback from Claude via CLI.

Consult Gemini for coding tasks like prototyping, debugging, and code review.

Search, save, and index your local documents for quick semantic retrieval.

Organize technical details into a patent disclosure package for attorney review.

Discover and extract all URLs from any website's sitemaps.

Show available harness templates and what each scaffolding option includes.

Publish a generated harness to npm with automated testing, signing, and provenance verification.

Score a repository's readiness across test coverage, release, and deployment risk.

Turn frozen research plans into reproducible, auditable experiment code with data leak prevention.

Generate and validate architecture compliance manifests for the Open Intelligence Architecture framework.

Pause execution and request human approval before proceeding with critical decisions.

Design and automate circuit boards with EasyEDA Pro schematics and PCB layouts.

Design and iterate UI layouts, components, and flows on an infinite canvas.

Load named personas that shift how Claude approaches tasks and reviews work.

Get expert guidance on writing, debugging, and maintaining Playwright tests.

Install and manage custom skins for HeiGe Codex Desktop on macOS or Windows.

Register and manage agent accounts, subscriptions, and API keys.

Approve paused approval gates in your workflow runs.

List and manage durable alert instances across your system.

Generate PNG, JPEG, or WebP images using your ChatGPT account without an API key.

Deploy and manage generative AI models and ML workflows on SAP's enterprise cloud platform.

Review and improve open source project documentation for clarity and usability.

Synchronize your CHANGELOG.md with git commits from the past week.

Synchronize your website with changes from local markdown files.

Master Godot 4.3+ 2D systems: tilemaps, parallax, lights, particles, and custom drawing.

Create an AI skill capturing a coworker's expertise and work style from your connected tools.

A fixture skill demonstrating incomplete implementation documentation.

Demonstration skill containing intentionally broken cross-references.

Check if your local kernel matches the harness scaffold version.

Scaffold an AI agent harness in one command from pre-built templates.

Scaffold a custom AI agent harness with CLI, MCP server, and marketplace identity.

Diff two scaffolded harnesses and report manifest, host, and file changes.

Build polished, production-ready web components and pages with distinctive design.

Build production-grade web components and interfaces with polished, distinctive design.

Design responsive game menus and HUDs that work across all screen sizes and input devices.

Verify that rendered UI components actually use your design system tokens and catch styling violations.

Collect opinions from multiple AI agents and synthesize them into one answer.

Draft and update CHANGELOG.md files for releases with git-cliff.

Create, edit, and export video timelines with AI voiceover and subtitles.

Prepare and submit pull requests to the Awesome Claude community resource directory.

Generate browser-rendered pages and components with dark mode and theme support.

Run a comprehensive WCAG compliance audit and generate a remediation plan.

Add, fix, or remove animations from your UI with purpose and restraint.

Create a clear implementation plan before coding complex features or changes.

Generate a daily AI news digest from top tech sources and blogs.

Redesign and beautify pixel-art decorations for top-down game sprites.

Generate interactive architecture diagrams from codebases or system descriptions.

Create and manage Jira tickets from requirements and requests.

Verify completed work claims against actual system state and flag discrepancies.

Review KiCAD schematics and PCBs for errors, violations, and design issues.

Create and manage KiCAD symbols, footprints, and component libraries.

Generate manufacturing files and export KiCAD projects to fabrication houses.

Audit and build accessible web interfaces meeting WCAG standards for news and academic sites.

Build modular data processing workflows with batch jobs and API integration.

Capture and display screenshots of web pages or specific elements.

Plan and structure OpenSpec changes before implementation work begins.

Find, audit, and design AI agent loops with safe triggers, actions, and stopping conditions.

Manage tasks, boards, and workflows in your terminal with a CLI kanban tool.

Create and configure AI agents for automation, coding, research, and support tasks.

Review UI code for compliance with web design and accessibility best practices.

Generate a comprehensive UX architecture bible by auditing your app's code and design patterns.

Plan UI features with design specs, accessibility, and navigation before coding.

Connect your current work session to a Linear, Jira, or GitHub ticket.

Add purposeful animations and micro-interactions to enhance UI usability and delight.

Train and optimize AI agents using reinforcement learning and automatic prompt tuning.

Build self-improving AI agents using 9 reinforcement learning algorithms.

Extract design tokens and variables from Figma and generate ready-to-use QML code.

Apply your project's design system to UI, styling, and copy decisions automatically.

Generate multiple design variations for users to review and react to before building.

Log deviations and edge cases discovered during development for future reference.

Create and edit YAML configuration files for LPM projects, services, and actions.

Break down objectives into focused, scoped work units with clear success criteria.

Store and search AI agent memories locally with mathematical ranking and entity graph scoring.

Design WCAG-compliant accessibility tests for keyboards and assistive tech.

Create and manage GitHub issue-based software tasks with automated workflow tracking.

Manage CodeKanban workflows and sessions from the command line.

Remove AI-generated patterns and add handcrafted polish before shipping.

Design accessible iOS and Android interfaces following platform guidelines and modern best practices.

Explore ideas and tradeoffs through interactive conversation before implementation.

Manage GPU instances, volumes, and billing on Vast.ai.

Manage GPU instances, volumes, and serverless endpoints on Vast.ai.

Create accessible UI designs with token compliance, responsive layouts, and WCAG standards.

Learn patterns from past tasks and share them across multiple agent loops.

Create and manage database schema changes with Flyway naming conventions and versioning.

Monitor Claude Code sessions and approve tasks remotely via Telegram, Feishu, or web dashboard.

Read, edit, and create Microsoft Word documents with tracked changes and comments.

Migrate embedding models in Qdrant without downtime or data loss.

Manage machine learning workloads on the Inspire platform via command-line interface.

Build WCAG 2.2 compliant web apps with keyboard navigation and screen reader support.

Build accessible animations and page transitions with Motion library patterns.

Generate, review, and integrate AI-built UI components into design systems.

Query local project analytics for agent usage, costs, and performance trends.

Build animated React components for Next.js with Tailwind CSS and Framer Motion.

Generate, analyze, and debug Verilog RTL designs with synthesis validation.

Review UI code for visual hierarchy, spacing, typography, accessibility, and responsiveness issues.

Fine-tune open-weight language models with LoRA adapters and custom datasets.

Render Portable Text to React, Vue, HTML, Markdown, and plain text.

Design flexible, reusable content schemas for headless CMSes.

Analyze code architecture, call graphs, and refactoring issues without AI.

Transform feature ideas into annotated stories with automated greenfield or brownfield detection.

Train custom small language models using knowledge distillation and production data.

Debug code issues by forming hypotheses from structural knowledge before reading code.

Apply a confirmed refactoring plan to your codebase step by step.

Write and run automated accessibility tests for web apps using Playwright and axe-core.

Scan web pages for WCAG compliance issues and accessibility violations using automated testing.

Generate Chen-model ER diagrams from SQL or DBML schemas with export options.

Generate HTML reports showing your Claude Code usage, projects, and activity statistics.

Create surveys, forms, and sign-up sheets that multiple people can access and fill out online.

Create custom color schemes for MulmoTerminal terminals and save them to your config.

Test trading strategy parameters and generate performance heatmaps.

Run multi-turn AI analysis tasks with database and RAG context.

Generate a complete backtesting script for trading strategies with data, signals, and performance charts.

Optimize GSAP animations for smooth 60fps with transforms, opacity, and batching.

Add, search, and style shadcn components in your project.

Build Android TV apps that work with only a d-pad remote control.

Extract design tokens and starter files from any public website.

Parse, build, and serialize JSON with SnowBank's high-performance DOM and code generators.

Generate custom TipTap nodes for edit, preview, and PDF modes.

Sync YouTube channel branding, status, and localization settings with local config.

Define product scope and generate PRDs, epics, and user stories.

Analyze compiled applications, decompiled code, and runtime behavior to understand features and architecture.

Create or migrate functional skills from requirements or legacy code.

Normalize skill requests into structured specifications for skill generation.

Analyze legacy skills to plan refactoring into modular components.

Scan code for WCAG 2.1 AA and EU accessibility compliance issues.

Generate multiple creative solutions in parallel for open-ended design problems.

Run automated accessibility tests and fix issues in your CI pipeline.

Test and improve web accessibility for WCAG compliance and inclusive design.

Attack any document or plan to find flaws, gaps, and weak points you'd miss otherwise.

Turn local HTML, Markdown, or static projects into shareable public URLs.

Turn rough ideas into approved specs with testable acceptance criteria before coding.

Guide a greenfield project through structured architecture planning before coding.

Deploy AI models to resource-constrained hardware using MATLAB and Simulink.

Convert your website or PWA into an iOS app with App Store submission strategy and release guidance.

Audit and fix Flutter widgets for WCAG 2.2 accessibility compliance.

Control 3D Gaussian splatting rendering with voice commands and real-time parameter editing.

Compress and optimize 3D Gaussian Splatting models for web, mobile, and edge deployment.

Query scientific figures, select visual examples, and export reference bundles for plotting.

Turn feature specs into approved task plans with optional ADRs and branches.

Build polished, production-grade web components and interfaces with distinctive design.

Turn product specs into design prompts for web UI generators like Figma and v0.

Replicate a website's design and visual style for your own product.

Keep documentation accurate and consistent with code changes.

Add, search, and customize shadcn components in your UI projects.

Evaluate and fix unresolved pull request review comments from any reviewer.

Monitor open PRs for CI failures and review comments, then fix and push automatically.

Analyze permissions and suggest wildcard patterns to optimize access settings.

Create animated videos by writing HTML, CSS, and GSAP timelines.

Create multi-component React artifacts with Tailwind CSS and shadcn/ui components.

Automate browser tasks like scraping, form-filling, and screenshots on JavaScript-heavy sites.

Characterize and size MOSFETs using gm/ID methodology with ngspice simulations.

Determine if preview changes are real regressions or just unstable rendering.

Generate branded interfaces and assets following Honeycomb design guidelines and components.

Break design documents into atomic parallel tasks with dependencies and acceptance criteria.

Search local files and content with progressive context levels to minimize token usage.

Interview you to create project specs, charters, and acceptance criteria.

Get oriented to a multi-agent codebase and establish your role within the team.

Create reusable skills by analyzing your conversation history and learning from what worked.

Brainstorm ideas with a partner LLM in alternating turns, then synthesize the best into a plan.

Break complex work into atomic tasks executed in fresh context windows.

Scan your project for stalled branches, failed builds, and plan drift, then fix confirmed issues.

Decide whether an AI agent should run code or reason in text for each task.

Stream real-time and historical US stock data from Alpaca via REST and WebSocket.

Get nine pre-built Home Assistant dashboard styles with ready-to-copy CSS and templates.

Reverse-engineer a website into a working local implementation with audit artifacts.

Build polished, designed UI that avoids generic AI defaults with design tokens and visual QA.

Extract a website's design tokens and generate a spec-compliant DESIGN.md file.

Convert screenshots and diagrams into editable SVG and PowerPoint files.

Prepare a winning hackathon submission with track selection, demo scripts, and judging checklists.

Create pitch decks, one-pagers, objection docs, and demo scripts to help close deals.

Analyze production agent behavior using session traces and Data Cloud.

Review, debug, and mentor Python and JavaScript code with security and testing rigor.

Build, debug, and deploy Salesforce agents using Agent Script.

Check your project files for conflicts before launching a team environment.

Review, optimize, and deploy Grafana dashboards and alerting rules.

Analyze a URL or document snapshot into a structured knowledge base report.

Diagnose HitKeep tracking installation issues and verify event collection is working correctly.

Analyze consistency and quality across spec, plan, and task documents.

Generate a custom checklist to validate requirement quality and completeness.

Maintain dashboard translations and locale-aware formatting across HitKeep.

Verify documentation matches unreleased changelog changes before shipping.

Create a professional portfolio website or presentation homepage with responsive design.

Search, create, update, and manage Jira issues, comments, and workflows.

Convert design prototypes to production React, Vue, or Svelte code.

Ship a new version by tagging and pushing to trigger automated builds and updates.

Add auto-update functionality to Tauri 2 desktop apps with manifest generation.

Publish npm packages with local verification and authentication handling.

Generate a lean project memory file for Claude by scanning your repo and asking key questions.

Query wallet balances, token portfolios, transactions, and NFTs on Solana with USD pricing.

Read, create, and manage notes in Obsidian vaults from the command line.

Improve your portfolio's visibility to search engines and AI systems.

Execute substantial development tasks with isolated workspaces, testing phases, and quality gates.

Guide two agents through parallel research and joint design before implementation.

Plan and document design decisions before writing code.

Create a self-contained summary document to resume work in a new session or with another developer.

Monitor Treasury and bank liquidity impacts during US government shutdowns.

Extract keywords and patterns from converted text recordings.

Record and query project decisions with timestamps, rationale, and consequences.

Design beautiful, on-brand UIs instead of generic AI-generated interfaces.

Analyze SwiftUI app flows to find navigation issues and broken user paths.

Build AI chat interfaces with pre-built UI components for Next.js apps.

Generate responsive email templates that work reliably across Outlook, Gmail, Apple Mail, and mobile clients.

Generate JSON-LD schema markup for search engine rich results.