PLAN2CODE Par Avion · Via Air Mail
2.0Plan2CodePostage

Spec-driven workflow for AI coding agents

Send the plan.
The build follows.

Addressed to

Anyone who has watched an AI agent confidently build the wrong thing. You approve a plan, it becomes phase documents in your repo, and the agent works to those documents one phase at a time.

90%Confidence gate
11Review dimensions
1Chat per phase
0Context pollution

Six written letters

Two optional
Opt
00

PathfinderNew in 2.0

/plan2code-0-pathfinder

For an idea that arrives too foggy to plan. It charts the idea as a map of decision questions and clears exactly one per session until nothing is left to decide.

it never answers its own questions — that's the point

  • One decision per file, one file per session
  • Research questions fan out to parallel agents
  • Clears at ≥18/25 on four confidence dimensions
  • Hands a hot plan draft to Step 1
Req
01

Plan

/plan2code-1-plan

A real back-and-forth about what gets built. Requirements pulled apart, your codebase actually read, the stack confirmed rather than assumed.

  • Functional and non-functional requirements
  • Integration points read from real source
  • Tech stack confirmed by explicit approval
  • Will not finalize below 90% confidence
Req
02

Document

/plan2code-2-document

The plan stops being a conversation and becomes files — an overview plus one self-contained phase document per phase, cut into one-story-point tasks.

  • overview.md and Phase 1…N.md land in your repo
  • One-point tasks with real checkboxes
  • Parallel groups marked for concurrent agents
  • Each phase readable with no prior context
Req
03

Implement

/plan2code-3-implement

Build to the drawing, one phase per conversation. Planning context bleeding into implementation is where most agent drift starts.

reply “approved” — nothing advances on a guess

  • Fresh conversation for every phase
  • Specs followed exactly as documented
  • Self-review against the spec before close
  • [/] claims prevent parallel-agent collisions
Opt

ReviewSecond opinion

/plan2code-review

An independent senior engineer with fresh eyes and no attachment to the code that just shipped. It reads every changed file completely and reports only what it can prove — file, line, and a concrete fix.

  • Scope adapts: files, branch diff, or subsystem
  • All 11 dimensions reported, clean ones justified
  • Ranked Critical / Warning / Suggestion
  • Read-only until you reply H, A, or S 1,3,5
Req
04

Finalize

/plan2code-4-finalize

Close it out. Every task audited against the spec it came from, a summary of what was built, docs checked for drift, and the folder filed away.

  • Audit for tasks quietly left open
  • Summary of what was built and changed
  • README and other docs reconciled
  • Specs archived to specs--completed/

Two routes

Same destination

Sent without an address

  • Coding starts, requirements arrive later
  • Design problems surface mid-build
  • Constant backtracking and rework
  • Context bloated with abandoned attempts
  • No way to prove requirements were met
  • Tokens burned on trial and error

Sent with a plan attached

  • The plan is approved before any code
  • Problems caught while they are still cheap
  • Implementation follows the drawing
  • Clean context, one phase at a time
  • Checkboxes prove what is done
  • Tokens spent building the agreed thing

Postal regulations

Four · non-negotiable
Reg 01

A fresh conversation for each step, and each implementation phase.

Reg 02

No code until the plan hits 90% confidence. The gate does not negotiate.

Reg 03

Checkboxes are the state, not the chat. Any session resumes cold.

Reg 04

Reply approved to close a phase. Nothing advances on a guess.

Installation

Node 14+ · re-run to update
$ npx --allow-git=all git+https://github.com/jparkerweb/plan2code.git

Post it once.
Then go outside.

free, MIT, twenty seconds to install
Get Plan2Code