The 7 Phases of AI-Powered Development
Kevin's pipeline for shipping real software with coding agents - not vibe coding. Align before building, design before coding, slice before implementing, verify before shipping. Adapted from Matt Pocock's skills repo, with each phase backed by a small, composable, model-agnostic skill.
The phases
| # | Phase | What it does | Skill / artifact |
|---|---|---|---|
| 1 | Grill | Have an idea for an app, feature, or refactor - then get the agent to interrogate it until you share an understanding. | Frontend and Design Skills + Agent Engineering Skills → CONTEXT.md / ADRs |
| 2 | Research (optional) | If execution involves difficult "explore" phases, cache the findings in a research.md asset so they're not re-derived. |
research.md asset (cf. zoom-out) |
| 3 | Prototype (optional) | Hash out ideas in throwaway code for early feedback; produce assets reusable in the real implementation. | Frontend and Design Skills (LOGIC: terminal app for state/logic · UI: variations on one route) |
| 4 | PRD | Write a markdown file describing the destination - user stories + implementation notes. | Agent Engineering Skills (synthesizes context, no interview; picks test seams) |
| 5 | Issues | Turn the PRD into individual tickets with blocking relationships. | Google Workspace Skills (tracer-bullet vertical slices; HITL/AFK; blocked-by) |
| 6 | Implement | In a loop, run a coding agent to execute all tickets on the kanban board. | Browser Testing Skills + Frontend and Design Skills (red-green-refactor, vertical) + Security and Review Skills |
| 7 | Review | Create a QA plan for a human to QA the completed work. | review (Standards + Spec, parallel sub-agents) |
The discipline that runs through all seven: align before building (1), design before coding (2-4), slice before implementing (5), verify before shipping (6-7). The skills are deliberately small and composable so you keep control of the process - unlike all-in-one frameworks (GSD, BMAD, Spec-Kit) that own the process and make bugs in the process hard to fix. Source: github.com/mattpocock/skills README, 2026-06-15
When to use it
Use this workflow for a feature, app, refactor, or agent loop that is too large to safely hand to a coding agent as one prompt. Do not invoke the full seven phases for tiny fixes. The point is to control uncertainty: when the design tree has branches, map it; when implementation has risk, slice it; when output quality matters, evaluate it.
Phase Exit Criteria
| Phase | Exit criterion |
|---|---|
| Grill | The goal, users, constraints, vocabulary, and major decision axes are explicit. |
| Research | Unknown APIs, libraries, or domain constraints have a reusable written note. |
| Prototype | The riskiest logic or UI interaction has been tested cheaply and can be thrown away. |
| PRD | The target behavior, data model, edge cases, and test surfaces are written. |
| Issues | Work is sliced into dependency-aware vertical tickets with acceptance criteria. |
| Implement | Each ticket has code, targeted verification, and no unresolved blocking ambiguity. |
| Review | Human QA plan or eval rubric checks the shipped behavior against the original spec. |
Skipping a phase is allowed when its exit criterion is already satisfied. Skipping without naming why is how "quick" projects become archaeology.
Kevin's refinement: the pre-PRD phase needs more structure
The weakest link is pre-PRD (phases 1-3). Today, grill-with-docs instructs the agent to "walk down each branch of the design tree, resolving dependencies between decisions one-by-one" - it goes straight to depth-first decision resolution. Source: grill-with-docs/SKILL.md, 2026-06-15
Kevin's insight: you need to figure out the shape of the design tree first - breadth - before walking down it with higher-fidelity prototypes - depth. Enumerate the major decision axes and branch points up front so you can see the whole tree, then descend the branches that matter, escalating prototype fidelity as you go. Mapping the tree first prevents the common failure where a depth-first grill resolves branch A in detail, only for a later branch B to invalidate those decisions. Source: User, 2026-06-15
The full mental model is Design-Tree Exploration (Shape Before Depth), now implemented as Stage 1 of the Frontend and Design Skills skill (a personal fork of Pocock's, with the breadth-first design-tree pass added).
How it maps to Kevin's existing stack
- Phase 6 (Implement loop) is an instance of the Browser Testing Skills / Harness Engineering while-loop - tickets are the work queue, tdd/diagnose are the invariants.
- Phase 7 (Review) is the The Eval Loop (Slop Is an Output Problem) applied at the human-QA gate (Standards = rubric, Spec = does it match the PRD).
- CONTEXT.md (phase 1) is now owned by Agent Engineering Skills and is the same compiled-knowledge move as the The Brain-Agent Loop - a queryable, opinionated glossary that makes the agent more concise and the codebase more navigable.
- Deep modules are now owned by Frontend and Design Skills when a phase discovers an abstraction/seam decision that needs vocabulary beyond the PRD.
Output Discipline
This workflow should leave artifacts near the work: CONTEXT.md, research.md, prototype notes, PRD, issue list, branch/PR links, tests, and review checklist. Durable lessons about the process itself belong back in the relevant skill or workflow page, not in a transient planning doc.
When used inside kevin-wiki, update the skill registry and generated surfaces if the run changes executable skills. When used in another repo, propose a wiki update unless Kevin explicitly wants the wiki changed.
Run Contract
This workflow follows Workflow Run Contract: name the sources, write output or no-op proof, promote only durable facts, update state only when the run really completed, refresh generated surfaces when durable pages or skills change, and log user-visible work.
Timeline
- 2026-07-01 | Added use criteria, phase exit criteria, and output discipline so the seven-phase model is runnable as a workflow rather than only a reference concept. Source: User request, 2026-07-01
- 2026-06-30 | Deep-reviewed Matt Pocock's original seven-phase visual artifact; confirmed the canonical phases remain Grill, optional Research, optional Prototype, PRD, Issues, Implement, and Review, with Kevin's breadth-first design-tree pass still the local pre-PRD refinement. Source: X/@mattpocockuk, 2026-06-15
- 2026-06-25 | Updated the phase table after promoting the core
mattpocock/skillsengineering flow into local executable skills: Agent Engineering Skills, Frontend and Design Skills, Agent Engineering Skills, Google Workspace Skills, Browser Testing Skills, Frontend and Design Skills, Security and Review Skills, and Frontend and Design Skills. Source: github.com/mattpocock/skills commit8370e760d0251a3738e006aeacec6d1cb31dd208 - 2026-06-15 | Captured from Kevin's framework diagram + his refinement that the pre-PRD phase needs a breadth-first "shape the design tree" pass before depth-first prototyping. Framework adapted from Matt Pocock's skills repo. Source: User, 2026-06-15; github.com/mattpocock/skills