AI Couldn’t Build Serious Software. Then Coding Agents Arrived
View Original ↗This is how early technology looks.
When we started building OpenAlgo around 2024, there were no coding agents in the way we understand them today.

We were mostly using ChatGPT.
Copy some code.
Paste it into ChatGPT.
Explain the problem.
Get some code back.
Paste it into the editor.
Run it.
Find the error.
Go back to ChatGPT.
Repeat.
At the time, a common reaction was:
“You can build small scripts with AI, but you cannot build large software.”
“AI-generated code will become impossible to maintain.”
“ChatGPT doesn’t understand the entire codebase.”
“You still need to write most of the serious code yourself.”
And they were right about one thing.
The technology was not ready yet.
Context windows were limited.
Models forgot earlier decisions.
Large refactoring was painful.
Debugging required constant human intervention.
There was no agent sitting inside your repository, reading files, running tests, executing commands, checking errors and iterating on its own.
But something important was already visible.
Potential.
For the first time, I could describe what I wanted to build in plain English and have AI help me turn that idea into working software.
It didn’t matter that I had to copy and paste code.
It didn’t matter that the model occasionally hallucinated functions.
It didn’t matter that I had to fix things manually.
The direction was obvious.
Then came coding agents.
Cursor.
Claude Code.
Codex.
And now we have tons of agent harnesses that can explore repositories, write code, run commands, execute tests, debug failures, refactor multiple files and keep iterating toward a goal.
The workflow itself has changed.
2024:
Human writes prompts.
AI writes snippets.
Human copies, integrates, tests and fixes.
2026:
Human defines intent, architecture and constraints.
Agents explore, implement, test, debug and iterate.
Humans increasingly review, steer and make engineering decisions.
That is a very different way of building software.
And I don’t think we are anywhere close to the end of this transition.
Today people still point at agent-generated code that is messy, inefficient or occasionally ridiculous and conclude:
“AI cannot build serious software.”
Maybe.
But that reminds me of looking at early AI-generated images with six fingers and concluding that machines would never generate realistic images.
The flaws are real.
But the trajectory matters more.
The interesting question isn’t:
“Can an AI agent build perfect production software today?”
The more interesting question is:
“If coding agents have progressed this much in just a couple of years, what will software development look like five years from now?”
OpenAlgo has given me a front-row seat to this transition.
We started with ChatGPT-assisted coding.
Then moved into agent-assisted development.
Now we are increasingly thinking about software development as orchestrating agents, tools, tests, skills, context and workflows.
The role of the developer is changing with it.
Less time may eventually be spent typing every line of code.
More time will be spent defining what should be built, designing systems, providing context, setting constraints, testing assumptions, reviewing outputs and coordinating agents.
This is how early technology looks.
Imperfect.
Flawed.
Sometimes ridiculous.
But full of possibilities for those curious enough to look beyond what it can do today and imagine what it is becoming.