The Cascade: from PRD to Prompt Brief

Here's a mistake that feels productive and isn't: handing an agent a big goal — "build the billing system" — in one prompt and turning it loose. The agent will produce something, sprawling and hard to review, drifting from intent as it goes. Big goals don't survive contact with a single prompt.

The fix is to break work down in steps, each tier sharper and smaller than the last, until you reach something an agent can build cleanly. In C² that chain is the Cascade. Here's how it works and why each tier earns its place.

Why one big prompt fails

A big feature carries too much ambiguity for one build. The agent has to make dozens of unstated decisions along the way, and with no checkpoints it makes them all at once, confidently, in one giant diff. By the time you see the result, the small wrong turns have compounded into a mess that's hard to review and harder to correct.

The teams writing PRDs for AI coding agents hit this constantly: the requirements doc and the unit an agent should build are not the same size. You need a way down from one to the other.

The cascade tiers, top to bottom

C² breaks every piece of work through the same chain:

Platform PRD
  └── Feature PRD          ← one per feature, a living document
       └── Prompt Brief × N ← the atomic build unit
            └── Task × N    ← optional, for bigger briefs
                 └── Session Brief    ← every session, no exceptions
                      └── Release Note (optional)

Intent flows down — broad goal to scoped build. Learning flows back up — each session brief feeds what was discovered into the record. The Cascade is that two-way chain: decisions descend, knowledge ascends.

Platform PRD and Feature PRD

The top tiers hold intent, not implementation:

• Platform PRD — the whole product's direction. The why, the shape, the big constraints.
• Feature PRD — one per feature, and a living document. Not frozen at creation — it evolves as design and engineering reality changes. A PRD that never changes is one nobody's reading.

These answer "what is being built, and why." They're too big to hand an agent directly, which is the point — they're the source the smaller units derive from.

The Prompt Brief: the atomic build unit

This is where the Cascade earns everything. The Prompt Brief is the atomic build unit — a scoped spec for one piece of work an agent can build in a single session. It carries:

• what to build, and what not to,
• what to read first (the relevant context),
• the acceptance criteria — how you'll know it worked.

Stuart Leo

The Prompt Brief is where direction becomes execution. Its quality is the bottleneck — not the agent's capability.

This is the handoff point from pilot to crew. A sharp brief produces a clean, reviewable, verifiable change. A vague one produces drift. Almost all of your leverage as a pilot lives in writing good briefs — which is why the Cascade exists to get you to one.

How work flows down and learning flows up

The Cascade isn't just decomposition — it's a loop. Work descends from PRD to brief to the agent's hands. Then the session brief at the bottom sends what was learned back up: a discovered constraint updates the Feature PRD, a trap becomes a gotcha, a finished brief produces a release note. The living Feature PRD absorbs reality from the work below it.

So the Cascade turns a big, ambiguous goal into a stream of small, sharp, buildable briefs — and turns the learning from building them back into the record. Big work reaches an agent as a small, sharp brief — the Cascade is how you get from a goal to that brief.

Start here: learn to write a PRD with an agent, write acceptance criteria the agent can check, or read the method.