For most of my career the thing I was genuinely best at wasn't writing code. It was technical operations. I've run every CI provider under the sun and hand-crafted some frankly insane pipelines along the way, the kind other engineers were quietly afraid to touch (bloody hell, were they beautiful). That was my craft. Then, almost overnight, it looked like I'd totally wasted my time.
But here's the thing few realise: the writing was only ever one part of the role. The bigger part was architectural: knowing how to make systems that hate each other talk. That glue is what holds an organisation together, and the people who can see how the pieces should fit and wire them together efficiently are the ones who quietly win. The typing was always incidental. The architecture was everything.
So when even a non-frontier model laps me while I trip over my own clumsy human feet, it isn't a catastrophe. It's a relocation. The bottleneck moved, and it moved to context.
Feed an agent the right datapoints, correct and relevant and concise, and it nails the code. Feed it badly and you get confident nonsense to unpick. Anyone who has handed a seven-year-old too much ice cream knows the shape of this: overdo it and you are both in for a long, painful evening. And this was never only about code. The same skill decides how a change gets planned, rolled out, and verified. Context is the difference between everything downstream landing and none of it landing.
Agents don't fail at coding
Watch an agent faceplant and it's almost never because it can't code. These things write better code than most humans on a good day. It fell over because of you, not the model:
- you fed it malarkey
- you drowned its brain in goo until it couldn't find the signal
- you're too tight to pay for the model that would've nailed it
- you couldn't plan a rollout that wasn't one giant monolith
That's the list. None of it is the model failing to code.
Picture an agent debugging a production incident with only the code and the logs. It guesses, burns money, and lands nowhere, because the answer isn't in either. It's in the signals nobody handed it. The agent isn't stupid. It's blindfolded, and you tied the blindfold on.
The model didn't lack brains. It lacked attention pointed at the right place. Pointing that attention is the job now, and it turns out to be a real skill, not a party trick.
The three properties
Three properties. They sound similar. They are not.
Correct. The context has to actually be true. Feed it a stale schema, docs from two refactors ago, or a function signature that changed last Tuesday, and it will build something beautiful on top of a lie. Wrong context is worse than none, because the model has no way of knowing you've handed it a fib. This is why preproduction feeds are a quiet trap: production is the only source of truth. Point an agent at staging and it reasons confidently about a reality that isn't real, blind to the business nuance you carry in your head about how the two actually diverge.
Relevant. It has to be about this task. Everything you include is competing for attention with everything else you include. A whole-repo dump isn't generosity, it's you outsourcing the filtering to the one participant in the room who is worst at filtering.
Concise. Signal-to-noise is the entire game. The token budget is an attention budget, and every irrelevant line you toss in doesn't politely wait its turn; it elbows the important lines out of frame. The best context isn't the most context. It's the least context that still contains the answer, with the ability to reach for more when it needs it. Minimalism, but for reasons other than aesthetics.
Get these right and a middling model looks like a genius. Get them wrong and the most expensive model on the market flails like the rest of us.
Determinism in the spine, chaos at the edges
I should admit a bias here. All those years running operations weren't just pipelines. They were a Big 4 consultancy one quarter, a startup three funding rounds deep the next, relentless change and every compliance regime going. SOC 2, ISO 27001, insert your framework here; if it involved dragging a process into being repeatable, evidenced, and gloriously boring, I've done a version of it. Turns out being a kingpin nitpicker was just training for the leagues of agents.
The tempting move is to set the agent loose: let it grep around, let it decide what to read, let it "figure it out." Sometimes it does. Often it wanders off, burns half its budget reading the wrong files, and shows up to the actual task already three drinks in and mildly confused.
The better shape is a scaffold that does the routing for it. A deterministic pipeline that, handed a task, already knows how to fetch the right datapoints: the relevant files, the schema as it exists right now, the failing test, the last three related changes, the exact slice of telemetry. Not because the agent guessed well, but because the workflow was built to put precisely that in front of it and nothing else.
The agent still does the clever, unpredictable part: the reasoning, the writing, the judgement calls. But it does it standing on a foundation that quietly controlled its inputs and narrowed its options. You get the model's intelligence without the model's enthusiasm for taking scenic detours.
That's the whole trade: non-determinism where you want creativity, determinism where you want to sleep at night. The workflow is the part that's boring on purpose. Boring is what turns "it got it right this time" into "it gets it right every time," and every time is the only version that pays.
We got close once
We've had a proper run at this before, and it's worth being honest about how it went. The whole CI/CD revolution was this exact instinct: take the process of shipping software, codify it, make it repeatable, wring the human wobble out of it. And it half-worked, which is the most maddening outcome there is, because half-working is close enough to see the finish line and not close enough to cross it.
What held us back was never the idea. It was the primitives. Either your provider didn't support the one bespoke thing your business actually needed (and it's always one bespoke thing, sitting maddeningly outside the happy path), or wiring it up yourself was such a slog that it sank to the bottom of the backlog under "we should really do that someday," where it quietly died. So we took the 80% the tooling handed us for free and made a grudging peace with hand-cranking the rest forever. Preach.
The difference now is that the primitives can finally bend around the business instead of the business contorting itself around the primitives. The bespoke bits that used to demand a bespoke engineer are exactly the parts an agent can handle, if it's sitting inside a deterministic workflow that hands it the right context and won't let it wander.
This is what I'm building
This is the thesis under everything I'm working on right now. A pipeline isn't just a pretty diagram of how code ships. It's a machine for controlling what the agent sees at each step. Discovery surfaces the signals. Planning narrows the scope. Review hands each specialist only the context its check needs. Infinitely extensible.
The pipeline is the context engine. Every step is a decision about what reaches the agent and what gets quietly binned before it does.
The old skill was writing the code. The new skill is building the machine that feeds the thing that writes the code, and making that machine deep and deterministic enough to actually trust.
That's the whole project. Swamp is deterministic automation for AI agents. Check it out at swamp-club.com.