Agent 05 — Phaser

Phaser

Implementation plans built for first-attempt success.

An implementation plan that's too vague leads to hallucination. One that's too large leads to failure. Phaser finds the right granularity — breaking your project into phases small enough to execute reliably, large enough to deliver meaningful progress.

The Steel Thread principle

Phase 1 is always a Steel Thread: the minimum viable end-to-end path that proves your tech stack is wired together before any feature development begins.

Connecting a frontend to a backend. Verifying a database connection. Confirming an API handshake works. It sounds unglamorous, but it's the most important phase of any project. If the plumbing doesn't work in Phase 1, every subsequent phase fails. Phaser makes sure you know the stack is alive before you build on top of it.

What makes a good phase

Each phase in Spec4 is designed around a single principle: an AI coding agent should be able to implement this phase on the first attempt.

Strict scoping

Each phase contains only what's needed for that phase. Future requirements don't appear until they're needed. The agent implementing Phase 2 doesn't know — and shouldn't know — what Phase 5 looks like.

Cumulative progress

Phase N builds directly on Phase N-1. No orphaned scaffolding, no skipped steps. Each phase produces a working, testable state that the next phase extends.

Explicit verification

Every phase ends with an exact command or criterion that proves it succeeded — not a vague checklist, but a specific command to run and a specific output to expect.

Risk assessment

Every phase identifies where an AI coding agent is most likely to go wrong, and provides explicit guidance to prevent it. The places where LLMs reliably make mistakes are called out in advance.

Stack spec fidelity

Phaser treats your stack spec as the authoritative list of approved components and dependencies. If a phase would require something not already in the spec, Phaser stops — explains why it's needed, what it would add — and waits for your explicit approval before including it. It never assumes.

Example phases

From the healthcare app (ClinicAssist), a 5-phase plan:

Phase 1 — Steel Thread

{ "phase_number": 1, "total_phases": 5, "phase_title": "Steel Thread — API Health Check & Database Connection", "phase_summary": "Establish a live end-to-end connection from the FastAPI backend to PostgreSQL. A single /health endpoint confirms the stack is wired together before any feature development begins.", "instructions": [ "Initialise the FastAPI app in main.py with a single GET /health endpoint.", "Configure SQLAlchemy with the DATABASE_URL env var and open the connection on startup.", "Add a startup event that runs SELECT 1 to verify the database is reachable.", "Return {\"status\": \"ok\", \"db\": \"connected\"} on success." ], "verification": "Run `uvicorn main:app --reload` and call GET http://localhost:8000/health — expect HTTP 200 with {\"status\": \"ok\", \"db\": \"connected\"}." }

Phase 2 — Database Schema

{ "phase_number": 2, "total_phases": 5, "phase_title": "Database Schema — Users, Patients, and Clinical Records", "phase_summary": "Define and migrate the core data models. No business logic yet — schema stability before feature development.", "verification": "Run `alembic upgrade head` with no errors. Inspect tables in psql — confirm users, patients, and clinical_records tables exist with correct columns and constraints." }

How to use Phaser's output

When you approve the phase plan, Phaser outputs all phase JSON blocks in a single response — one per phase, in order. Work through them one at a time with your agentic coding tool of choice:

Paste Phase 1 into Claude Code, Cursor, or your tool

Let the agent implement it

Run the verification command

When it passes, move to Phase 2

Each phase is self-contained and scoped. The agent implementing Phase 2 doesn't need to know what Phase 5 looks like — and it shouldn't.