Published: Apr 8, 2026
After I published Two problems blocking autonomous AI coding assistants, I got some responses. And a pattern emerged.
For every problem I raised, someone had the same answer: “We’ll solve that soon.”
Verification is manual? Don’t worry, AI-generated tests are getting better. Code review doesn’t scale? Give it six months, the tools will summarize changes for you. The non-determinism problem? Next-gen models will be more consistent.
Always soon. Never now.
The promissory note
I’ve started calling this the promissory note pattern. Every limitation of agentic coding comes with an IOU attached: we know this is a problem, but the solution is right around the corner.
And it’s not just other people saying this. I’ve caught myself doing it too.
I had this thought the other day: “Soon we won’t need to structure code for humans to read. We’ll structure it for agents to read instead.” And for a moment it felt like a genuine insight. But then I realized - that’s another promissory note. We don’t know what “code structured for agents” even looks like. We don’t have the tools. We don’t have the practices. We just have the belief that it’s coming.
It’s like standing at the edge of a cliff, looking at the other side, and saying “we’ll build a bridge soon.” The gap is real. The bridge is imaginary.
The asymptote
Here’s what I think is actually happening. The value of agentic coding is approaching asymptotically.
If you remember your math classes - an asymptote is a line that a curve approaches but never quite reaches. The curve gets closer and closer, but the gap never fully closes.
That’s what agentic coding feels like to me right now. Every new model is better. Every new tool closes some gap. The productivity gains are real - I’m genuinely faster with AI assistance than without it. But the promise - the real promise, the one where AI handles the implementation and I just think about architecture - that stays just out of reach.
It’s like watching a hand stretch out to grab something, fingers extended, almost touching. And every time you think you’ve got it, it moves a little further away.
But what if I’m wrong?
Here’s the thing. Things are getting better. Noticeably, measurably better.
Anthropic’s upcoming Mythos model promises another leap. Every few months, something that was frustratingly broken just starts working. The models get more consistent. The context windows grow. The tools get smarter about understanding codebases.
So maybe the curve isn’t asymptotic at all. Maybe it just looks that way from where I’m standing. Maybe what feels like an asymptote is actually just a slow climb, and one day we’ll look back and realize the curve did cross the line - we just couldn’t see it happening in real time.
I’ve been writing software long enough to remember when “deploying to production without downtime” felt like an impossible promise. When “infrastructure as code” sounded like a fantasy. Those curves crossed their lines. It just took longer than the optimists said it would.
Either way, the reaching itself has already changed how I think about code. I structure things differently now. I think about verification earlier. I care more about architecture and less about implementation details. Even if the curve never crosses the line, I’m a better developer for chasing it.