Something shifted in early 2026. The frontier models crossed a threshold where, given the right context, they could hold an entire subsystem in their head and change it coherently. At Road.io and across Rekall, the way we build changed with them — not because the tools got flashier, but because the leverage moved. The constraint stopped being how fast you can type and became how clearly you can think.

Slop Cannons or 100x'ers

The same model, pointed at two different teams, produces wildly different work. One team ships a coherent platform; the other ships a landfill of plausible-looking code that no one can maintain. The model didn't change. The inputs did.

Garbage in, garbage out is older than computing, but generative AI makes it brutal. The output tracks the human thought behind it with uncomfortable fidelity. Vague intent yields vague software at enormous speed — a slop cannon. Precise intent, captured in writing, yields the opposite: a small team moving like a large one. As Dan Shipper keeps pointing out, the people getting 100x out of these systems aren't prompting harder. They're thinking more clearly and writing it down.

Context is King

The difference between a slop cannon and a 100x'er is context. Not cleverness in the prompt — context: the specs, the constraints, the decisions already made, the shape of the system as it actually is.

High-signal specifications beat agentic improvisation every time. An agent left to guess will guess; an agent handed a tight specification will execute. We organize that context deliberately. Every project carries a CRAFT folder — a small, legible tree of the thinking that feeds the machine:

CRAFT/
  context/      what the system is, and why
  requirements/ what we're building, precisely
  architecture/ the decisions, and their tradeoffs
  flows/        how the pieces move
  tasks/        the work, decomposed

It reads like documentation, but its real job is to be source material for the compiler. When Bjarne Stroustrup described good design as making the hard things explicit, he was talking about C++. The same discipline now applies one level up: the explicitness lives in your specs, and the model is the thing that reads them.

AI as a Context Compiler

Here is the reframe that changed how we work: the agent is the compiler, and your specs are the source code.

A compiler is unforgiving and literal. It does exactly what the source says — no more, no less — and the quality of the binary is bounded by the quality of the source. Treating the agent this way collapses a lot of confusion. You stop "chatting" with it and start engineering the inputs. You version the context. You review the spec the way you'd review code, because it is the code now. You invest in the folder of human thinking (craft.directory is where we're collecting the patterns) because that's where the real work moved.

This is good news for craft, not bad. The engineering discipline doesn't disappear — it relocates. The teams that win the next decade won't be the ones with secret access to a better model. Everyone has the model. They'll be the ones who organize human thinking meticulously enough that the compiler has something worth compiling.