Creates a small-step, verifiable implementation plan to approve before starting work. Focuses on the smallest shippable slice.
Install
mkdir -p .claude/skills/spec-andrewdryga && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/17564" && unzip -o skill.zip -d .claude/skills/spec-andrewdryga && rm skill.zipInstalls to .claude/skills/spec-andrewdryga
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Design an opinionated, boring-by-default implementation plan before writing code. Use when a change spans more than one file or context, when the approach isn't obvious, or when asked to plan/design/think through a feature. Produces a small-step, verifiable plan to approve before /work.Key capabilities
- →Identify the job-to-be-done and target audience
- →Determine the smallest shippable slice of a feature
- →Map changes to specific files and functions
- →Choose the simplest, most boring implementation approach
- →Produce a numbered list of small, verifiable steps
- →Define done-conditions and required tests for each step
How it works
The skill first clarifies the job-to-be-done and identifies the smallest shippable slice. It then maps the work to specific files and functions, choosing the simplest approach, and outputs a detailed, verifiable plan.
Inputs & outputs
When to use spec
- →Planning multi-file refactors
- →Designing complex feature workflows
- →Decomposing large tasks into small, shippable slices
About this skill
Plan a change (the boring, shippable way)
Produce a plan the user can approve, then hand to /work. Optimize for the
smallest correct slice, not the grandest design. Read AGENTS.md and the code
you'll touch before planning — plan against the real code, not a guess.
1. Wear the PM hat first
Before how, settle whether and what:
- What's the job-to-be-done, and who for?
- What's the smallest slice that delivers it? Cut everything else into "later".
- Does this already exist? If so it's a small edit, not a project.
If the request is vague or oversized, say so and propose the thin slice.
2. Map the work
Name what changes, and where, in the smallest set of files. Walk the layers your codebase actually has (schema / data / API / UI / tests) and skip the ones that don't apply. For each piece, name the function/file and what it does.
3. Choose boring on purpose
For each non-obvious decision, write the chosen approach and a one-line why it's the dull option. If you reach for something clever (a new process, a macro, a dependency), justify why boring can't do it — or drop it. No new abstraction that serves one caller.
4. Output
- A numbered list of small, independently verifiable steps, each with its own done-condition (what gate proves it).
- The tests each step needs — happy path and the failure/denial path.
- Anything you're unsure of → a
/verify-apito run, or adecision.mdin the task folder entry if it needs a human call.
Stop and let the user approve before /work. Don't start building from /spec.
When not to use it
- →When a change spans only one file
- →When the approach is obvious
- →When the user wants to start coding immediately
Limitations
- →Requires user approval before /work
- →Does not start building from /spec
- →Optimizes for the smallest correct slice, not the grandest design
How it compares
This skill prioritizes a 'boring-by-default' approach to planning, focusing on small, verifiable steps and explicit done-conditions before any code is written, unlike ad-hoc coding.
Compared to similar skills
spec side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| spec (this skill) | 0 | 1mo | No flags | Intermediate |
| spec-workflow | 10 | 8mo | No flags | Intermediate |
| feature-design-assistant | 6 | 6mo | No flags | Intermediate |
| sp-writing-plans | 0 | 3mo | No flags | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by AndrewDryga
View all by AndrewDryga →You might also like
spec-workflow
TencentCloudBase
Standard software engineering workflow for requirement analysis, technical design, and task planning. Use this skill when developing new features, complex architecture designs, multi-module integrations, or projects involving database/UI design.
feature-design-assistant
davila7
Turn ideas into fully formed designs and specs through natural collaborative dialogue. Use when planning new features, designing architecture, or making significant changes to the codebase.
sp-writing-plans
ddmanyes
當你有明確需求或設計方案時，在動手改代碼前，用來撰寫多步驟的詳細實作計畫。
brainstorming
obra
Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes
create-plan
antinomyhq
Generate detailed implementation plans for complex tasks. Creates comprehensive strategic plans in Markdown format with objectives, step-by-step implementation tasks using checkbox format, verification criteria, risk assessments, and alternative approaches. Use when users need thorough analysis and structured planning before implementation, when breaking down complex features into actionable steps, or when they explicitly ask for a plan, roadmap, or strategy. Strictly planning-focused with no code modifications.
project-planner
adrianpuiu
Comprehensive project planning and documentation generator for software projects. Creates structured requirements documents, system design documents, and task breakdown plans with implementation tracking. Use when starting a new project, defining specifications, creating technical designs, or breaking down complex systems into implementable tasks. Supports user story format, acceptance criteria, component design, API specifications, and hierarchical task decomposition with requirement traceability.