playbooks

home / skills / vaayne / agent-kit / specs-dev

specs-dev skill

/skills/specs-dev

This skill guides plan-first development with review gates, enabling disciplined feature work, iterative implementation, and clean commits.

npx playbooks add skill vaayne/agent-kit --skill specs-dev

Review the files below or copy the command above to add this skill to your agents.

Files (8)
SKILL.md
4.8 KB
---
name: specs-dev
description: Plan-first development workflow with review gates. Use when implementing features, refactoring, or any task requiring structured planning, iterative implementation with reviews, and clean commits. Triggers on requests like "implement feature X", "plan and build", "spec-driven development", or when user wants disciplined, reviewed code changes.
---

# Specs-Dev Workflow

A disciplined, review-gated development workflow ensuring quality through structured planning and iterative implementation.

## When to Use

- Implementing new features
- Complex refactoring
- Any task requiring planning before coding
- When user requests "plan first" or "spec-driven" approach
- Multi-file changes that benefit from review gates

## Workflow Overview

| Phase             | Purpose                       | Exit Criteria                |
| ----------------- | ----------------------------- | ---------------------------- |
| 1. Discovery      | Understand requirements       | User approves summary        |
| 2. Planning       | Create reviewed plan          | Plan reviewed and approved   |
| 3. Implementation | Iterative coding with reviews | All tasks complete, reviewed |
| 4. Completion     | Final validation              | Tests pass, docs updated     |

## Phase 1: Discovery

**Goal:** Reach shared understanding before planning.

1. Interpret the request — state initial understanding
2. Ask clarifying questions (goals, constraints, success criteria, out-of-scope)
3. Iterate — reflect answers, tighten understanding
4. Summarize — present final requirements

**Gate A:** "Do I understand correctly? Should I proceed to create the plan?" — Wait for approval.

## Phase 2: Planning

**Goal:** Create a comprehensive, reviewed implementation plan.

1. Draft plan using `references/templates/plan.md`
2. Review loop with reviewer (max 3 rounds) — see `references/agents/reviewer.md`
3. Integrate feedback, iterate until approved
4. **Gate B:** Present to user, wait for approval
5. Create session: `.agents/sessions/{YYYY-MM-DD}-{feature-name}/`
6. Save `plan.md` and `tasks.md` (use `references/templates/`)

Quality gates: see `references/gates.md`

## Phase 3: Implementation

**Goal:** Implement tasks iteratively with approval-gated review loops.

> ⚠️ **MANDATORY: You MUST follow `references/loop.md`** — Read and execute the implementation loop exactly as specified. Do not skip or deviate from the defined state machine.

**Summary:** For each task:

```
IMPLEMENTING → VALIDATING → REVIEWING → loop until approved → COMMITTING → DOCUMENTING → NEXT TASK
```

**Required Steps:**

1. **Read `references/loop.md`** before starting any implementation
2. Follow the state machine transitions exactly
3. Complete each state's requirements before transitioning
4. Max 3 iterations per task before escalating to user
5. Subagents: `references/agents/worker.md`, `references/agents/reviewer.md`

Quality gates: see `references/gates.md`

## Phase 4: Completion

**Goal:** Final validation and wrap-up.

1. Run full test suite
2. Update `plan.md` with results, final status, known issues
3. Verify all tasks complete in `tasks.md`
4. Summarize completed work, risks, outcomes
5. Confirm with user — session ready for merge/release

Quality gates: see `references/gates.md`

## Subagent Delegation

**Reviewer** — Plan reviews, code reviews:

```
Context: references/agents/reviewer.md
Task: Review [plan/code] for completeness, security, performance, patterns
```

**Worker** — Focused implementation:

```
Context: references/agents/worker.md
Task: Implement [objective] in [files] with [acceptance criteria]
```

## Session Structure

```
.agents/sessions/{YYYY-MM-DD}-{feature-name}/
├── plan.md      # Strategic plan
└── tasks.md     # Tactical tasks
```

## References

```
references/
├── loop.md          # Phase 3 state machine, steps, fix routing
├── gates.md         # Quality gates for all phases
├── help.md          # Common issues, best practices
├── agents/
│   ├── reviewer.md  # Reviewer subagent context
│   └── worker.md    # Worker subagent context
└── templates/
    ├── plan.md      # Plan document template
    └── tasks.md     # Tasks document template
```

| File                 | When to Read                      |
| -------------------- | --------------------------------- |
| `loop.md`            | Phase 3 (MANDATORY — must follow) |
| `agents/reviewer.md` | Plan/code reviews                 |
| `agents/worker.md`   | Task implementation               |
| `templates/plan.md`  | Phase 2                           |
| `templates/tasks.md` | Phase 2                           |
| `gates.md`           | Each phase exit                   |
| `help.md`            | When stuck                        |

Overview

This skill implements a plan-first, review-gated development workflow for disciplined TypeScript projects. It guides discovery, produces a reviewed implementation plan, executes iterative task loops with mandatory review gates, and finalizes with tests and documentation. Use it to ensure clean commits, traceable sessions, and predictable quality outcomes.

How this skill works

The skill drives four phases: Discovery (requirements and clarifying questions), Planning (produce plan.md and tasks.md and run reviewer loops), Implementation (task-by-task state machine with mandatory loop rules), and Completion (tests, docs, and final summary). It enforces explicit approval gates before moving between phases and requires following the implementation loop exactly as specified. Sessions are stored in a dated folder structure so work is reproducible and auditable.

When to use it

  • Implementing a new feature that needs structured design and reviews
  • Complex refactors that must be planned and validated incrementally
  • Any task where you want a ‘plan first’ or spec-driven approach
  • Multi-file or cross-module changes that benefit from gated reviews
  • When you need clear session artifacts (plan.md, tasks.md) for handoff or audit

Best practices

  • Start with a focused Discovery: ask goals, constraints, success criteria, and out-of-scope items
  • Keep planning review loops short (max 3 rounds) and record feedback in the plan
  • Always read and follow the implementation loop before coding to avoid state machine violations
  • Limit per-task iterations to three before escalating to the user
  • Run the full test suite and update plan.md and tasks.md before closing the session

Example use cases

  • Add a new API endpoint with schema changes and client updates — plan, review, implement, test, document
  • Refactor a core module across multiple files with incremental reviewed commits
  • Implement a cross-cutting performance improvement that requires coordinated changes
  • Onboard a second developer: use session artifacts to transfer context and task ownership

FAQ

What must I never skip during implementation?

Never skip reading and following the implementation loop; it governs state transitions and review requirements for each task.

How many review iterations are allowed?

Planning and task reviews are limited to three rounds each before you escalate to the user for direction.