Module Overview

Module 5 is where the artifact chain becomes working software. You implement your Dev Tasks with AI through a disciplined loop — plan before code, one task per session, tests from acceptance criteria, read every diff before committing. It pulls the whole program together: the prompting from Module 3 and the context discipline from Module 4 are applied for real on production-grade code.

Prerequisites — What’s Already Done

This walkthrough assumes the upstream artifact chain is complete. Before development begins, the following must already exist:

Notice what is not on this list: AGENTS.md, coding standards, and the knowledge directory. These are generated during Stage 1 alongside the boilerplate. You need to understand the project first — by reading the architecture document — before you can write accurate project rules.

Project Structure After Stage 1

After the boilerplate stage is complete, the project has this structure. Items marked with an arrow are generated during Stage 1, not beforehand.

my-project/                          # parent project folder
├── docs/                             # artifacts — NOT committed to any repo
│   ├── brd/
│   ├── prd/
│   ├── arch-docs/                    #   ARCH-<code>-v1.0.md + one ADR per epic
│   ├── dev-tasks/                    #   one CSV per epic (epic-N-...-tasks.csv)
│   └── generated-figma/
│
└── <app-repo>/                   ← generated in Stage 1 (this is what gets committed)
    ├── AGENTS.md                 ←   cross-tool rules (+ CLAUDE.md overrides)
    ├── knowledge/                ←   generated in Stage 1
    │   ├── prompts/              #     dev/, solutions-architect/, tech-lead/, product/
    │   ├── patterns/             #     implement-and-test.md (E→P→A→V chain)
    │   ├── rules/                #     coding-standards.md (rules + rationale)
    │   ├── agents/
    │   ├── retros/
    │   └── templates/
    └── ...                       ←   source + config (boilerplate, stack-dependent)

The Core Loop

Every task follows the same four-step cycle. The artifacts and knowledge directory provide the context. The CSV task fields provide the prompt.

Stage 1 — Production Boilerplate

Every project starts with a boilerplate that matches the design from day one. Load the architecture document AND the Figma export together. The output is a complete scaffold: infrastructure, configuration, design system, UI components, pages — all on placeholder data. No business logic, no API wiring. Just a production-grade shell that looks and runs like the real app.

EVALUATE — Understand the Architecture and Design

PLAN — Boilerplate + UI Shell + Project Rules

APPLY — Generate the Complete Boilerplate

VALIDATE — Validate Infrastructure + Design Fidelity

Stage 1B — Connect Project Services via MCP

After the boilerplate is generated and running, connect your AI tool to the project’s services via Model Context Protocol (MCP). This gives the AI direct access to your database, APIs, and infrastructure — so it can inspect schemas, run queries, and generate code that matches what actually exists.

Supabase

claude mcp add --scope project --transport http \
  supabase "https://mcp.supabase.com/mcp"

After connecting, the AI can inspect your database schema, read table definitions, check Row Level Security (RLS) policies, and generate code that matches your actual data model — instead of guessing from the architecture document alone.

Other Common MCP Connections

Stage 2 — Task Execution

This is where developers spend most of their time. The tasks exist in the CSV. The architecture doc and coding standards are in the project. The developer loads the context and executes.

What to Load as Context

Before starting any task, load these files. How you load depends on your tool 2014 file references, project context, or upload. The method varies; what matters is that these files are in the AI2019s context window before you start.

The 4-Step Chain (per task)

This is the implement-and-test pattern from knowledge/patterns/. Each task goes through all four steps.

Step 1 — EVALUATE: Load context and understand

Step 2 — PLAN: State implementation plan

Step 3 — APPLY: Implement

That’s it. The AI already knows the description, the acceptance criteria, the coding standards, and the architecture — all from the loaded files. The APPLY prompt is two lines.

Step 4 — VALIDATE: Self-review against acceptance criteria

Concrete Example: TASK-019

Here’s what a real task execution looks like using CSV fields as the prompt. The developer loads the context files once, then works through the cycle.

The CSV row

The developer’s actual prompts

Total prompt effort: ~60 words across four steps. Everything else comes from the loaded files.

Stage 3 — Recurring Patterns

These live in knowledge/prompts/dev/ and knowledge/patterns/. Use them directly.

Code Review

From knowledge/prompts/dev/code-review.md:

Load: AGENTS.md, relevant source files
 
Review this code for: security vulnerabilities,
logic errors, error handling gaps, performance issues.
 
For each issue: Severity (Critical/High/Medium/Low),
line number, description, suggested fix.
 
Do not comment on style. Focus on things that break.

Database Migration

[EVALUATE] Load schema. What’s the current state?
[PLAN] New schema, data impact, backward compat, rollback
[APPLY] Migration file + updated schema + seed update
[VALIDATE] Data loss? Table locks? Broken queries? Rollback works?

API Endpoint

[EVALUATE] Load docs/arch-docs/. Which endpoint?
[PLAN] Validation rules, DB queries, error responses
[APPLY] Route handler following AGENTS.md standards + curl test
[VALIDATE] Invalid input? Auth bypass? Response format correct?

Bug Fix

[EVALUATE] Observed vs expected, stack trace, suspected code
[PLAN] Root cause → fix design → same pattern elsewhere?
[APPLY] Implement fix + regression test
[VALIDATE] Resolved without side effects? Related paths?

Stage 4 — Pre-Launch

Load: Full project, docs/arch-docs/, AGENTS.md
 
[EVALUATE] Audit for production readiness.
Security, performance, reliability, DevOps, UX.
 
[PLAN] Prioritize: [BLOCKER] / [FIRST WEEK] / [BACKLOG]
 
[APPLY] Fix every [BLOCKER]. Provide [FIX NOW] fixes for post-launch.
 
[VALIDATE] Fixes work? New problems? Deploy pipeline tested?

Contributing Back to Knowledge

The knowledge directory grows with the team. After completing tasks, contribute what you learned.

Quick Reference

Discipline Notes

Contribute back. When you find a better prompt, a new rule, or a useful pattern — add it to knowledge/. The team’s AI effectiveness compounds over time. One developer’s insight becomes every developer’s shortcut.