I feel that in the future all code will be written by agents.
That might not be the time now for every company, but I think that’s where we’re heading. The interesting part is not whether that happens or not. The interesting part is how we get there.
I think there are multiple ways to reach a point where we can successfully ship production-quality code written by agents. Not in terms of quantity, but in terms of quality. Quality that is comparable to what humans produce today.
And to understand why that’s difficult, we first need to talk about context.
Context Is More Than Code
We all know that context is partly the limit, and even more so the context that is not part of the code.
Whenever we create a project, we create it with an intention. We define it with taste and goals. Those things are often not written in the code.
Sometimes they’re documented elsewhere. Sometimes they’re not documented at all.
The code is only one part of the project. The intentions behind it, the trade-offs, the expectations, and the taste of the people building it are often stored somewhere else, or nowhere at all.
That’s one of the biggest challenges if we imagine a future where agents write all the code.
Getting There
If the world eventually reaches a point where all code is written by agents, there will be multiple stages to get there.
Right now, what we’re seeing is that some people and companies are using agents directly, while other companies are all-in on using AI to augment a single developer.
Those are two different ways of approaching the problem.
I think the first group is going to have more trouble in the beginning because, again, the agent doesn’t know everything. It doesn’t know the taste, the goals, or the requirements that exist outside the immediate scope of the task.
That gets messy quickly.
All-In on Agents
This is similar to what OpenAI described in their Harness Engineering document around projects that are largely AI-generated where the agent does all the work, 100% code is written by it and it’s async. It doesn’t need a human to start working.
That poses some interesting questions.
You want to review the code. You want to make sure it’s clean, that it doesn’t introduce duplications, and so on.
At the same time, you want some kind of ownership of that code by the AI itself.
So you need to build processes that revolve around making sure the code continues to evolve asynchronously with minimal human interaction.
Humans are still involved, but they’re not guiding every step. They’re reviewing, controlling behavior, and making adjustments.
The goal becomes enabling the system to continue operating without needing a human to constantly push it forward.
AI as Augmentation
The other group is probably moving slower, but (probably) at higher quality.
They’re controlling the agents more. They’re augmenting their workload rather than delegating ownership completely.
But at the same time, whenever we reach a point where we can safely trust agents to do their work, or at least part of it, they won’t have learned how to guide agents in that way.
Current harness engineering and context engineering revolve around addressing the limitations of today’s agents, but whenever a new model comes out, you’re suddenly facing a different set of problems.
Some of the techniques you’re using become useless, for example models already require much less prompt engineering than they did before.
Trade-offs
I believe some companies are spending time on things that won’t matter anymore in a few years or maybe months.
One group is optimizing for quality and control.
The other group is optimizing for amplification and learning how to operate with autonomous systems. It’s a trade off one has to make.
The Winner
In the long term, I think the first group, the one adopting AI-written code more aggressively, is going to be faster, assuming they can sustain the errors long enough (or have a quick feedback loop for humans and AI agents) for the models to improve.
It’s a bet, of course. I’m betting too as I can’t predict the future.
My take is that models will reach a point where they can remove most of the issues they created. But to get there, you need to enable each model and agent to self-serve and self-direct.
Even something as simple as checking that reporting is consistent could become a task handled by an agent.
Or maybe it’s something that won’t matter anymore because the interface itself changes.
Maybe software stops being primarily UI-based and becomes something else, who knows.
Everyone Is Betting
I think everyone is betting on something right now.
The companies going all-in on agents are making one bet.
The companies focusing on augmentation are making another.
I think that learning how to give agents work and let them operate autonomously will be important for companies right now, the more that is possible, the better positioned your company will be if that future arrives.
What will you be betting on?
Leave a comment