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 | Map the decision tree, then resolve every currently unblocked question in dependency-frontier rounds until you share an understanding. | Agent Engineering Skills + Agent Engineering Skills → tree / 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. | Agent Engineering 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. | Agent Engineering 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. | Agent Engineering Skills + Agent Engineering Skills (red-green-refactor, vertical) + Agent Engineering 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 decision tree are explicit; the frontier is empty or every deferred branch has an owner, and Kevin confirms the shared understanding. |
| 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.
Gate compression follows authority, not a fixed count
Limestone's saved ADLC framing—eight stages, six agent-driven steps, two human touchpoints, 98% non-handwritten code, and weeks-to-days cycle time—is retained as a useful factory-floor hypothesis, not as a universal lifecycle or verified performance result. The post and current company material did not expose the task corpus, baseline, counting method, failure/incident rate, rework, cost, deployment authority, or a reproducible case study for those exact numbers.
Automating planning, architecture, coding, tests, deployment, and monitoring
does not eliminate their gates. It changes who prepares evidence and who owns
the decision. Human involvement is selected by authority, reversibility,
uncertainty, blast radius, legal/accountability boundary, and evaluator
coverage: a low-risk reversible internal change may need only goal and ship
approval; a data migration, security boundary, spend, customer communication,
or production deployment may need more. Measure lead time, deployment
frequency, change-failure rate, MTTR, defects, rework, cost, and operator load;
percentage of generated code is not an outcome metric. Source: X/@mardehaym
2086769996496077036; Limestone Digital current site and Foundation sitemap,
reviewed 2026-08-12
Kevin's refinement: the pre-PRD phase needs more structure
The weakest link was pre-PRD (phases 1-3). The June source went straight to a depth-first, one-question-at-a-time walk. Kevin added a shape-first breadth pass so the decision axes and dependencies become visible before depth. Matt's later v1.2 source then removed the serial round-trip cost: compute the currently unblocked frontier, ask all of it in one numbered round, and leave downstream questions for later rounds. [Sources: local grill-with-docs, 2026-06-15; X 2078077849785815465; mattpocock/skills@84fdeffd]
Kevin's insight remains the first invariant: figure out the shape of the design tree before resolving it. The second invariant is now frontier before sequence: do not serialize independent questions, and do not ask a question whose prerequisite is unresolved. Escalate only load-bearing uncertainty to a prototype. This preserves dependency correctness while lowering user round trips and token cost. [Sources: User, 2026-06-15; X 2078077849785815465, 2026-07-17]
The full mental model is Design-Tree Exploration (Shape Before Depth), now implemented as Stage 1 of the Agent Engineering 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 Agent Operations 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 Agent Engineering 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-08-12 | Updated the Grill phase from a frozen June depth walk to Kevin's shape-first map plus Matt Pocock's released dependency-frontier rounds. The exit gate now requires an empty frontier or explicitly owned deferrals and Kevin's confirmation. [Sources: saved X video
2078077849785815465;mattpocock/skills@84fdeffd] - 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, Agent Engineering Skills, Agent Engineering Skills, Agent Engineering Skills, Agent Engineering Skills, Agent Engineering Skills, Agent Engineering Skills, and Agent Engineering 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