Using Agent Skills
Discovers and invokes agent skills. Use when starting a session, or when you need to decide which skill or workflow applies to the piece of work at hand. This is the meta-skill that governs how all other skills are discovered and invoked.
Get the complete skill folder, including its scripts and reference files.
When to use this skill
Use Using Agent Skills when an AI agent needs a reusable SKILL.md workflow for this job: Discovers and invokes agent skills. Use when starting a session, or when you need to decide which skill or workflow applies to the piece of work at hand. This is the meta-skill that governs how all other skills are discovered and invoked.
When not to use it
Skip Using Agent Skills when the task is outside the productivity category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/using-agent-skills # Save SKILL.md to ~/.claude/skills/using-agent-skills/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/using-agent-skills/SKILL.md. For a shared project, commit the folder at .claude/skills/using-agent-skills/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Using Agent Skills skill for this task: Use Using Agent Skills when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
71/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Using Agent Skills
## Overview
Agent Skills is a collection of engineering workflow skills organized by development phase. Each skill encodes a specific process that senior engineers follow. This meta-skill helps you discover and apply the right skill for your current task.
## Skill Discovery
When a task arrives, identify the development phase and apply the corresponding skill:
``` Task arrives │ ├── Don't know what you want yet? ──────→ interview-me ├── Have a rough concept, need variants? → idea-refine ├── New project/feature/change? ──→ spec-driven-development ├── No quality bar written down? ──→ constraint-driven-development ├── Have a spec, need tasks? ──────→ planning-and-task-breakdown ├── Implementing code? ────────────→ incremental-implementation │ ├── UI work? ─────────────────→ frontend-ui-engineering │ ├── API work? ────────────────→ api-and-interface-design │ ├── Need better context? ─────→ context-engineering │ ├── Need doc-verified code? ───→ source-driven-development │ └── Stakes high / unfamiliar code? ──→ doubt-driven-development ├── Writing/running tests? ────────→ test-driven-development │ └── Browser-based? ───────────→ browser-testing-with-devtools ├── Something broke? ──────────────→ debugging-and-error-recovery ├── Reviewing code? ───────────────→ code-review-and-quality │ ├── Too complex? ─────────────→ code-simplification │ ├── Security concerns? ───────→ security-and-hardening │ └── Performance concerns? ────→ performance-optimization ├── Committing/branching? ─────────→ git-workflow-and-versioning ├── CI/CD pipeline work? ──────────→ ci-cd-and-automation ├── Deprecating/migrating? ────────→ deprecation-and-migration ├── Writing docs/ADRs? ───────────→ documentation-and-adrs ├── Adding logs/metrics/alerts? ───→ observability-and-instrumentation └── Deploying/launching? ─────────→ shipping-and-launch ```
## Core Operating Behaviors
These behaviors apply at all times, across all skills. They are non-negotiable.
### 1. Surface Assumptions
Before implementing anything non-trivial, explicitly state your assumptions:
``` ASSUMPTIONS I'M MAKING: 1. [assumption about requirements] 2. [assumption about architecture] 3. [assumption about scope] → Correct me now or I'll proceed with these. ```
Don't silently fill in ambiguous requirements. The most common failure mode is making wrong assumptions and running with them unchecked. Surface uncertainty early — it's cheaper than rework.
### 2. Manage Confusion Actively
When you encounter inconsistencies, conflicting requirements, or unclear specifications:
1. **STOP.** Do not proceed with a guess. 2. Name the specific confusion. 3. Present the tradeoff or ask the clarifying question. 4. Wait for resolution before continuing.
**Bad:** Silently picking one interpretation and hoping it's right. **Good:** "I see X in the spec but Y in the existing code. Which takes precedence?"
### 3. Push Back When Warranted
You are not a yes-machine. When an approach has clear problems:
- Point out the issue directly - Explain the concrete downside (quantify when possible — "this adds ~200ms latency" not "this might be slower") - Propose an alternative - Accept the human's decision if they override with full information
Sycophancy is a failure mode. "Of course!" followed by implementing a bad idea helps no one. Honest technical disagreement is more valuable than false agreement.
### 4. Enforce Simplicity
Your natural tendency is to overcomplicate. Actively resist it.
Before finishing any implementation, ask: - Can this be done in fewer lines? - Are these abstractions earning their complexity? - Would a staff engineer look at this and say "why didn't you just..."?
If you build 1000 lines and 100 would suffice, you have failed. Prefer the boring, obvious solution. Cleverness is expensive.
### 5. Maintain Scope Discipline
Touch only what you're asked to touch.
Do NOT: - Remove comments you don't understand - "Clean up" code orthogonal to the task - Refactor adjacent systems as a side effect - Delete code that seems unused without explicit approval - Add features not in the spec because they "seem useful"
Your job is surgical precision, not unsolicited renovation.
### 6. Verify, Don't Assume
Every skill includes a verification step. A task is not complete until verification passes. "Seems right" is never sufficient — there must be evidence (passing tests, build output, runtime data).
Per-skill verification is the local check. The project-wide bar that applies to *every* change, regardless of which skill is active, is the Definition of Done: tests pass, no regressions, behavior verified at runtime, docs updated. See `../../references/definition-of-done.md`. It complements each task's acceptance criteria rather than replacing them.
## Failure Modes to Avoid
These are the subtle errors that look like productivity but create problems:
1. Making wrong assumptions without checking 2. Not managing your own confusion — plowing ahead when lost 3. Not surfacing inconsistencies you notice 4. Not presenting tradeoffs on non-obvious decisions 5. Being sycophantic ("Of course!") to approaches with clear problems 6. Overcomplicating code and APIs 7. Modifying code or comments orthogonal to the task 8. Removing things you don't fully understand 9. Building without a spec because "it's obvious" 10. Skipping verification because "it looks right"
## Skill Rules
1. **Check for an applicable skill before starting work.** Skills encode processes that prevent common mistakes.
2. **Skills are workflows, not suggestions.** Follow the steps in order. Don't skip verification steps.
3. **Multiple skills can apply.** A feature implementation might involve `idea-refine` → `spec-driven-development` → `planning-and-task-breakdown` → `incremental-implementation` → `test-driven-development` → `code-review-and-quality` → `code-simplification` → `shipping-and-launch` in sequence.
4. **When in doubt, start with a spec.** If the task is non-trivial and there's no spec, begin with `spec-driven-development`.
## Lifecycle Sequence
For a complete feature, the typical skill sequence is:
``` 1. interview-me → Extract what the user actually wants 2. idea-refine → Refine vague ideas 3. spec-driven-development → Define what we're building 4. planning-and-task-breakdown → Break into verifiable chunks 5. context-engineering → Load the right context 6. source-driven-development → Verify against official docs 7. incremental-implementation → Build slice by slice 8. observability-and-instrumentation → Instrument as you build (runs parallel with 7-9, not after) 9. doubt-driven-development → Cross-examine non-trivial decisions in-flight 10. test-driven-development → Prove each slice works 11. code-review-and-quality → Review before merge 12. code-simplification → Reduce unnecessary complexity while preserving behavior 13. git-workflow-and-versioning → Clean commit history 14. documentation-and-adrs → Document decisions 15. deprecation-and-migration → Retire old systems and move users safely when needed 16. shipping-and-launch → Deploy safely ```
Not every task needs every skill. A bug fix might only need: `debugging-and-error-recovery` → `test-driven-development` → `code-review-and-quality`.
## Quick Reference
| Phase | Skill | One-Line Summary | |-------|-------|-----------------| | Define | interview-me | Surface what the user actually wants before any plan, spec, or code exists | | Define | idea-refine | Refine ideas through structured divergent and convergent thinking | | Define | spec-driven-development | Requirements and acceptance criteria before code | | Plan | planning-and-task-breakdown | Decompose into small, verifiable tasks | | Build | incremental-implementation | Thin vertical slices, test each before expanding | | Build | source-driven-development | Verify against official docs before implementing | | Build | doubt-driven-development | Adversarial fresh-context review of every non-trivial decision | | Build | context-engineering | Right context at the right time | | Build | frontend-ui-engineering | Production-quality UI with accessibility | | Build | api-and-interface-design | Stable interfaces with clear contracts | | Verify | test-driven-development | Failing test first, then make it pass | | Verify | browser-testing-with-devtools | Chrome DevTools MCP for runtime verification | | Verify | debugging-and-error-recovery | Reproduce → localize → fix → guard | | Review | code-review-and-quality | Five-axis review with quality gates | | Review | code-simplification | Preserve behavior while reducing unnecessary complexity | | Review | security-and-hardening | OWASP prevention, input validation, least privilege | | Review | performance-optimization | Measure first, optimize only what matters | | Ship | git-workflow-and-versioning | Atomic commits, clean history | | Ship | ci-cd-and-automation | Automated quality gates on every change | | Ship | deprecation-and-migration | Remove old systems and migrate users safely | | Ship | documentation-and-adrs | Document the why, not just the what | | Ship | observability-and-instrumentation | Structured logs, RED metrics, traces, symptom-based alerts | | Ship | shipping-and-launch | Pre-launch checklist, monitoring, rollback plan |
Intended uses
- Use Using Agent Skills when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.