Skills tagged developer-tools: 144 agent skills for Claude Code

• aflpp — Sets up and runs AFL++ for multi-core fuzzing of C/C++ projects built with afl-clang-fast or afl-gcc-fast.
• agents-get-started — Use when a developer wants to create a new agent project or get started with AgentCore.
• algorithmic-art — js with seeded randomness and interactive parameter exploration.
• archify — Create polished, validated architecture, workflow, sequence, data-flow, and lifecycle/state diagrams as explorable standalone HTML with inline SVG.
• archify-review — Review Archify issues, PRs, or code through value, cost, and impact to support evidence-based maintenance decisions.
• atlassian-mcp — Integrates with Atlassian products to manage project tracking and documentation via MCP protocol.
• bdi-mental-states — This skill should be used when modeling agent mental states with BDI concepts: beliefs, desires, intentions, RDF-to-belief transformations.
• book-to-skill — Converts books and documents (PDF, EPUB, DOCX, HTML, Markdown, plain text, RTF, MOBI/AZW with Calibre) into structured agent skills, extracting frameworks.
• brainstorm-ideas-existing — Brainstorm product ideas for an existing product using multi-perspective ideation from PM, Designer, and Engineer viewpoints.
• brainstorming — You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior.
• browser-testing-with-devtools — Tests in real browsers via Chrome DevTools MCP. Use when building or debugging anything that runs in a browser.
• c-review — Performs comprehensive C/C++ security review for memory corruption, integer overflows, race conditions, and platform-specific vulnerabilities.
• cad — Create/edit parametric CAD models, organize CAD projects, export STEP/STL/3MF/GLB files, resolve prompt references, and measure geometry with cadgen.
• changelog-video — md into a finished branded changelog video (square 1080, ~45-60s, Annie VO, animated brand background, mock-UI visualizations, lowkey captions).
• ci-cd-and-automation — Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines.
• claude-api — Reference for the Claude API / Anthropic SDK — model ids, pricing, params, streaming, tool use, MCP, agents, caching, token counting, model migration.
• cli-developer — Use when building CLI tools, implementing argument parsing, or adding interactive prompts.
• code-documenter — Generates, formats, and validates technical documentation — including docstrings, OpenAPI/Swagger specs, JSDoc annotations, doc portals, and user guides.
• code-improver — Runs an autonomous review-and-fix improvement loop over any code target — a skill, plugin, module, or directory — using a reviewer the user names.
• code-review — Review code for actionable defects. Correctness is the core; performance and security are optional sub-cases of the same engine.
• code-review-and-quality — Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human.
• code-reviewer — Analyzes code diffs and files to identify bugs, security vulnerabilities (SQL injection, XSS, insecure deserialization), code smells, N+1 queries.
• code-simplification — Simplifies code for clarity. Use when refactoring code for clarity without changing behavior.
• constraint-driven-development — Establishes a project's quality bar as a written contract and stops agents quietly lowering it.
• context-compression — This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization.
• context-degradation — This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion.
• context-engineering — Optimizes agent context setup.
• context-engineering-collection — A comprehensive collection of Agent Skills for context engineering, harness engineering, multi-agent architectures, and production agent systems.
• context-fundamentals — This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window.
• context-optimization — This skill should be used for improving context efficiency: context budgeting, observation masking, prefix or KV-cache strategy, partitioning.
• cpp-pro — Writes, optimizes, and debugs C++ applications using modern C++20/23 features, template metaprogramming, and high-performance systems techniques.
• debugging-and-error-recovery — Guides systematic root-cause debugging.
• debugging-wizard — Parses error messages, traces execution flow through stack traces, correlates log entries to identify failure points.
• defuddle — Extract clean Markdown from HTML pages with Defuddle CLI.
• deploy-to-vercel — Deploy applications and websites to Vercel.
• deprecation-and-migration — Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another.
• dev-browser — Browser automation with persistent named pages via the dev-browser CLI.
• devcontainer-setup — Creates devcontainers with Claude Code, language-specific tooling (Python/Node/Rust/Go), and persistent volumes.
• diagnosing-superpowers — Use when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results.
• dispatching-parallel-agents — Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
• documentation-and-adrs — Records decisions and documentation.
• doubt-driven-development — Subjects every non-trivial decision to a fresh-context adversarial review before it stands.
• dummy-dataset — Generate realistic dummy datasets for testing with customizable columns, constraints, and output formats (CSV, JSON, SQL, Python script).
• dwarf-expert — Analyzes DWARF debug information in compiled binaries.
• dxf — Generate, regenerate, and validate 2D DXF drawings from Python build123d sources.
• embedded-systems — Use when developing firmware for microcontrollers, implementing RTOS applications, or optimizing power consumption.
• evaluation — This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates.
• executing-plans — Use when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution.
• figma — Import Figma content into a HyperFrames composition — rendered assets, brand tokens, components.
• filesystem-context — This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery.
• find-skills — ", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
• finishing-a-development-branch — Use when implementation is complete, all tests pass, and you need to decide how to integrate the work
• frontend-design — Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one.
• game-developer — Use when building game systems, implementing Unity/Unreal Engine features, or optimizing game performance.
• git-workflow-and-versioning — Structures git workflow practices. Use when making any code change.
• github-triage — Triages a repository's open GitHub issues and pull requests via the gh CLI.
• harness-engineering — This skill should be used when designing autonomous agent harnesses: research loops, evaluation scaffolds, locked and editable surfaces, durable logs.
• harness-writing — Designs and improves fuzzing harnesses for C/C++ and Rust.
• hosted-agents — This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools.
• hyperframes — Mandatory entry point: read this first for any request to make, create, edit, animate, or render a video, animation, or motion graphic, including a promo.
• hyperframes-animation — js, CSS keyframes, Web Animations API, TypeGPU). g. js mixer).
• hyperframes-audio — Use when audio already placed in a HyperFrames composition needs to be mixed: fade-in/fade-out, crossfade, track gain or volume, volume automation, ducking.
• hyperframes-cli — Use the HyperFrames CLI development loop: init, add, catalog, capture, lint, check, snapshot, compare, grade-compare, preview, play, present, beats, keyframes.
• hyperframes-core — The HyperFrames composition contract — build one renderable project.
• hyperframes-keyframes — js, WAAPI, FLIP, paths, masks, SVG morph/draw, text trails, 3D depth, or `hyperframes keyframes` diagnostics.
• hyperframes-registry — Search, install, and wire registry blocks and components into HyperFrames compositions.
• hyperframes-studio — Use when building or editing a HyperFrames project that people open in Studio: how the timeline should be laid out so it reads well (one caption track.
• incremental-implementation — Delivers changes incrementally in thin, verifiable slices.
• intended-vs-implemented — The method for finding the gap between what a system is supposed to do and what the code actually does — the class of bug generic scanners miss because they.
• javascript-pro — js APIs. cjs files for correctness and best practices.
• knap — Render Markdown from templates and structured data using Knap CLI.
• latent-briefing — This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context".
• legacy-modernizer — Designs incremental migration strategies, identifies service boundaries, produces dependency maps and migration roadmaps.
• libafl — Builds custom fuzzers with LibAFL, the modular Rust fuzzing library.
• libfuzzer — Sets up and runs libFuzzer, the coverage-guided fuzzer built into LLVM, on C/C++ code that compiles with Clang.
• long-horizon-prompting — This skill should be used when writing, enhancing.
• mcp-builder — Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools.
• mcp-developer — Use when building, debugging, or extending MCP servers or clients that connect AI systems with external tools and data sources.
• memory-systems — This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity.
• modern-cpp — Guides C++ code toward modern idioms (C++20/23/26). Use when writing new C++ code, modernizing legacy patterns, or working on security-critical C++.
• modern-python — Configures Python projects with modern tooling (uv, ruff, ty). Use when creating projects, writing standalone scripts, or migrating from pip/Poetry/mypy/black.
• multi-agent-patterns — This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs.
• observability-and-instrumentation — Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting.
• obsidian-cli — Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more.
• performance-optimization — Optimizes application performance across frontend, backend, queries, and databases.
• php-pro — 3+ features, Laravel, or Symfony frameworks. Invokes strict typing, PHPStan level 9, async patterns with Swoole, and PSR standards.
• planning-and-task-breakdown — Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks.
• playwright-expert — Use when writing E2E tests with Playwright, setting up test infrastructure, or debugging flaky browser tests.
• pr-improver — Runs an autonomous review-and-fix improvement loop over the current branch's changes until a PR review comes back clean.
• pr-to-video — Turn a GitHub pull request (a PR URL, owner/repo#N, or 'this PR' in a checked-out repo) into a code-change explainer video — changelog, feature reveal, fix.
• project-development — This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand.
• provision-cloud-agent — Provision an always-on cloud-hosted coding agent: pick a host platform (Railway or AWS EC2; pluggable for Fly.io, …).
• reasoning-trace-optimizer — Debug and optimize AI agents by analyzing reasoning traces, context degradation, tool confusion, instruction drift, repeated task failures.
• receiving-code-review — Use when receiving code review feedback, before implementing suggestions.
• release-notes — Generate user-facing release notes from tickets, PRDs, or changelogs.
• remotion-to-hyperframes — Port an existing Remotion (React) composition's source to HyperFrames HTML.
• requesting-code-review — Use when completing tasks, implementing major features, or before merging to verify work meets requirements
• rust-engineer — Writes, reviews, and debugs idiomatic Rust code with memory safety and zero-cost abstractions.
• rust-review — Performs comprehensive Rust security review for safe/unsafe boundary issues, memory safety in unsafe blocks, concurrency hazards, panic-induced DoS.
• sarif-parsing — Parses and processes SARIF files from static analysis tools like CodeQL, Semgrep, or other scanners.