Skip to content
Skills Library
Programming · Building & coding

spec-driven-implementation

/spec-driven-implementation

Execute spec-driven implementation — auto-detects Quick (plan.md) or Full (tasks.md) mode and runs step-by-step with verification. Use when implementing a planned feature or running TDD tasks.

Repository
kisune ↗
Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Execute spec-driven implementation — auto-detects Quick (plan.md) or Full (tasks.md) mode and runs step-by-step with verification. Use when implementing a planned feature or running TDD tasks.

Original author description

Execute spec-driven implementation — auto-detects Quick (plan.md) or Full (tasks.md) mode and runs step-by-step with verification. Use when implementing a planned feature or running TDD tasks.

How it works

  1. Purpose
  2. Activation Triggers
  3. Mode Detection (DO THIS FIRST)
  4. Quick Mode Execution
  5. Full Mode Execution
  6. Back to Planning
Original SKILL.md headings · 181 lines, 1,295 words
SKILL.md preview
---
name: spec-driven-implementation
description: Execute spec-driven implementation — auto-detects Quick (plan.md) or Full (tasks.md) mode and runs step-by-step with verification. Use when implementing a planned feature or running TDD tasks.
allowed-tools: Read, Write, Edit, Bash
---

# Spec-Driven Implementation Skill

## Purpose

Execute the planning artifacts produced by `spec-driven-planning`. The skill auto-detects which mode the feature is in and runs the matching playbook:

- **Quick mode** (`plan.md` exists) — follow bite-sized steps, run verification commands, commit. **No RED-GREEN-REFACTOR.** Tests welcome but not mandated.
- **Full mode** (`tasks.md` exists) — strict TDD per task: RED → GREEN → REFACTOR, traceability to REQ-### IDs, quality gates between tasks.

## Activation Triggers

- User says "implement this feature", "let's code this", "execute the plan"
- User mentions "tasks", "TDD", or "execution"
- User uses `/dev-workflow:spec` with `tasks` or `execute`
- Planning phase is complete

---

## Mode Detection (DO THIS FIRST)

Before doing anything, find the active feature folder and detect mode:

```
1. ls docx/features/  →  pick most recent or user-named feature
2. Inside docx/features/[NN-name]/, look for:
   - plan.md only                          → QUICK MODE
   - tasks.md only                         → FULL MODE
   - tasks.md + plan.archived.md           → FULL MODE (post-upgrade; archive is informational, ignored for routing)
   - plan.md + tasks.md (no archive)       → STOP AND ASK: ambiguous state.
                                              Likely a hand-conversion in progress.
                                              Ask user which file is authoritative.
                                              Do NOT auto-pick — risk of clobbering.
   - neither                               → ERROR: "No plan/spec found. Run /dev-workflow:spec first."
```

`plan.archived.md` is informational only and never affects mode detection — a clean post-upgrade state has `tasks.md` + `plan.archived.md` and routes to Full.

**Announce the mode:**
> "Detected [Quick/Full] mode from `docx/features/[NN-name]/[plan.md|tasks.md]`. Running [Quick/Full] execution."

Then run the matching section below.

---

## Quick Mode Execution

**Source:** `docx/features/[NN-name]/plan.md`

**Philosophy:** Behavior-based verification, not test-suite-based. The plan already tells you exactly what to do.

### Pre-flight

1. Read `plan.md` end-to-end
2. Review critically — raise concerns BEFORE starting:
   - Are file paths real? (sample-check 1-2 with Read)
   - Do the steps actually solve the Goal?
   - Are there obvious gaps?
3. If concerns: surface them to the user, wait for guidance
4. If clean: proceed

### Per-task loop

For each task in the plan:

1. **Mark task as in-progress** — Edit the Progress section: `- [ ] Task N` → `- [→] Task N`
2. **For each step in the task** (steps are themselves checkboxes `- [ ]` in the template):
   - Execute the action (write code from the plan, run the command, etc.)
   - Run the verification command shown in the plan
   - Compare actual output to "Expected:" — if mismatch, **stop and ask**, don't guess
   - **Edit `plan.md`** to flip the step's `- [ ]` → `- [x]` immediately after completing it
3. **Commit** using the message from the plan (the commit step itself is one of the checkboxed steps)
4. **Mark task complete** — Edit the Progress section: `- [→] Task N` → `- [x] Task N`
5. **Check before the next task** — every box of Task N in `plan.md` (its steps and its Progress line) is `[x]` before Task N+1's first step runs. Never save the ticks for one sweep after the last task: if the run stops between tasks, the plan must show which tasks are done.

### Quick mode rules

- **No RED-GREEN-REFACTOR enforcement.** If the plan lists a test step, do it. If not, don't invent one.
- **Opting into TDD per-task is allowed.** If a specific task warrants a test, the plan author adds an explicit test step (e.g., "1. Write failing test in `tests/foo.test.ts` ... 2. Verify: `npm test foo` → expect FAIL"). Execute it as ordinary verification. No test step in the plan = no test required.
- **Don't expand scope.** The plan is the contract. New ideas → tell the user, don't silently add tasks.
- **Use Edit on `plan.md`**, don't just announce progress. Mark step-level checkboxes (`- [ ]` → `- [x]`) as you complete each numbered step within a task — this preserves resumability if interrupted mid-task. A task's boxes are all ticked before the next task starts; "I'll update the checkboxes at the end" is the failure this rule exists to stop.
- **Stop when blocked.** Failing verification, missing file, ambiguous step → ask.
- **No quality gate between tasks** beyond what the plan specifies. (Optionally invoke `dev-workflow:review` before commits if the user requested it.)

### Quick mode completion

When all tasks are `[x]`:

1. Update `Status:` line in `plan.md` to `Complete`
2. Run any final verification listed in the plan
3. Report:

```
Quick implementation complete: [Feature Name]

- Tasks: N/N
- Commits: M
- Files changed: K

Plan: docx/features/[NN-name]/plan.md
Ready for PR or further work?
```

---

## Full Mode Execution

**Source:** `docx/features/[NN-name]/{requirements.md, design.md, tasks.md}`

### Prerequisites Check

- [ ] `requirements.md` complete (EARS, REQ-### IDs)
- [ ] `design.md` complete and approved
- [ ] `tasks.md` exists (Phase 4 done) OR run Phase 4 below

If `tasks.md` is empty/missing, run Phase 4 first.

---

### Pre-flight Review (before Phase 4)

Before breaking design into tasks or executing existing tasks, critically review the planning artifacts:

1. **Are referenced file paths real?** Sample-check 1-2 paths from `design.md` with Read. Hallucinated paths are a strong signal the design wasn't grounded in the actual codebase.
2. **Do the requirements actually match what the user asked for?** Re-read the original request and check `requirements.md` for drift.
3. **Does the design solve the requirements?** Each REQ-### should map to at least one design component.
4. **Are there obvious gaps?** Missing error handling, undefined interfaces, hand-waved sections.

If concerns: STOP. Surface them to the user BEFORE writing tasks or code. Don't push through hoping it'll work out.

> 🗣 Say: "Pre-flight: [N concerns found / clean — proceeding to Phase 4]."

---

### Phase 4: Task Breakdown (TDD Focus)

Skip if `tasks.md` already has tasks. Otherwise break the design into tasks of 30-60 minutes, each independently testable, shaped like:

```
[ ] Task N: [Description]
    [ ] RED: Write failing test for [functionality]
    [ ] GREEN: Implement minimal code to pass test
    [ ] REFACTOR: Clean up and optimize

    Acceptance Criteria:
    [ ] [Specific, checkable criterion]
    Linked Requirements: REQ-###, REQ-###
```

- Every task lists the REQ-IDs it satisfies; every requirement appears in at least one task.
- Cover components, their integration, error cases, docs, and a final verification task (review, security, performance).
- When the design hides complexity (tricky algorithms, unclear integration points), first ask what the simplest implementation is and where it will break, then size the tasks.

> "Tasks defined with TDD cycle. Ready to begin implementation?"

---

### Phase 5: Execution (Full Mode TDD)

Invoke `dev-workflow:test-driven-development` and follow it for every task. Set `Status:` in `tasks.md` to `In Progress` when you start.

**For each task:**

1. Edit `tasks.md`: `[ ] Task N` → `[→] Task N`.
2. **RED** — write the failing test, run it, and see it fail for the expected reason. Check off RED. Commit: `test: Add test for [functionality]`.
3. **GREEN** — minimal code; the whole suite passes. Check off GREEN. Commit: `feat: Implement [functionality]`.
4. **REFACTOR** — clean up with tests green. Check off REFACTOR. Commit: `refactor: [component]` (skip the commit if nothing changed).
5. Check off the acceptance criteria you verified, mark `[x] Task N`, and update the Progress Summary (`Completed: X/N`).

**Edit the file, then announce.** Saying a box is done is not checking it; a resumed session only sees what is in `tasks.md`.

Post a checkpoint when a meaningful unit of work lands: tests passing, type check, lint, tasks done, next task.

Before each commit, invoke `dev-workflow:review` and fix critical findings. When all tasks are `[x]`, set `Status:` to `Complete`, confirm tests, lint and type check pass (`dev-workflow:completion-validation`), and report tasks, tests added, commits and files changed.

---

## Back to Planning

If implementation uncovers a missing requirement or a design that cannot work, stop: "Implementation blocked: [issue]. Need to revisit [requirements/design]." Invoke `dev-workflow:spec-driven-planning` to update the documents before continuing.

Versions

RepositoryScoreLicence
This page · xbklairith/kisune100MIT
warpdotdev/common-skills100MIT
OutlineDriven/outline-driven-development90Apache-2.0

Database snapshot: 13.11.2026 · package version 7065d574051d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 95Implementation
    Execute implementation tasks from task documents following TDD workflow, phase-by-phase execution, and real-time progress tracking. USE WHEN implement, execute tasks, run tasks, start implementation, build feature, execute implementation, code the feature.
  • 100implementation-planning
    Break down specifications into executable implementation plans with TDD integration. Use when asked to "create plan", "break down tasks", "implementation roadmap", "規劃實作", "拆解任務", "執行計畫", or need step-by-step implementation guidance with test strategies and impact analysis. Use…
  • 90implementing
    Execute an approved implementation blueprint step by step with verification and checkpoints. Use when a blueprint exists and you are about to start implementation
  • 100dominicode-sdd-creator
    Run the Dominicode Spec-Driven Development lifecycle for non-trivial features and products: understand the request or Issue, create spec.md + plan.md + evidence-based tasks.md before code, then guide implementation, verification/fix, code review, final verification and…
  • 90spec-driven
    Guide spec-driven development workflow (Requirements → Design → Tasks → Implementation) with approval gates between phases. Use when user wants structured feature planning or says "use spec-driven" or "follow the spec process".
  • 84execute-plan
    Execute implementation plans step-by-step. Use when user says "execute the plan", "implement the plan we created", "start building based on the plan", "go ahead and implement it", "proceed with the implementation", "execute as a stack", "create a PR stack while implementing",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.