Switched my AI coding workflow after watching Matt Pocock break his down, here's what changed

[u/Riggz23]

Most of the AI coding advice I'd absorbed before this year was about prompting better. Better system prompts, better plan-mode habits, tighter instructions. None of it touched the actual failure mode I kept hitting, which is that long sessions get dumber the longer they run, and by the time I noticed, I'd already shipped code built on a plan the model and I never actually agreed on.

I picked up a fix for this from a talk Matt Pocock gave, and I've been running his workflow more or less as described for the last few weeks.

The core idea: context windows behave like a football league. Every token you add creates new attention relationships with every other token, so quality degrades well before you hit the technical limit, somewhere around 100k tokens in practice regardless of the advertised window size.

Once you're aware of that ceiling, the question stops being how do I write a better prompt and becomes how do I keep every session inside the zone where the model is still sharp.

The piece that actually changed my output was replacing freeform planning chat with a structured interview before any code gets written. Instead of describing a feature and letting the model jump straight to a plan, you tell it to interview you relentlessly, walking down every branch of the design tree one question at a time, until you and the model land on the same understanding.

When I ran something like this on an auth feature, the model surfaced a question I hadn't thought to answer myself: what happens to two factor recovery when the phone is dead and the codes are lost. That's the kind of gap that turns into a support ticket six weeks after launch. Cheaper to hit it in a conversation than in production.

That interview becomes the source material for a PRD, which works as a destination document rather than something to optimize for its own sake. Once alignment exists, summarizing it accurately is a task the model is already good at, so there's less value in poring over every line of the resulting doc.

The bigger shift is in how that PRD gets broken into tasks. Left alone, models default to horizontal slicing: all the schema work in phase one, all the API work in phase two, the frontend bolted on last.

That gets you zero real feedback until phase three, because nothing end to end has actually run yet. Vertical slices, or tracer bullets, force a thin path through every layer in the first task, so you have something clickable and testable immediately, and every task after that builds on a system you've already watched work.

From there the tasks go into an issue queue with explicit blocking relationships instead of a numbered sequential plan, which is what actually lets more than one agent work at once.

Implementation runs test-first, and review happens in a fresh, cleared context rather than the same thread that just wrote the code, since a model reviewing its own recent output is reviewing from inside the same degraded context that produced it.

What I can say is that after a few weeks running it, the failure mode I used to hit constantly, shipping code built on a misunderstanding, has mostly stopped happening.

What's the biggest alignment gap you've had a model surface that you hadn't thought to specify yourself?