Recently, Addy Osmani published an article that gave me much to think about: “Self-Improving Coding Agents”. The idea is simple but powerful: agents that not only execute tasks, but improve their own performance over time.
This isn’t science fiction. It’s happening now, in 2026. And it has profound implications for the future of software development and, by extension, for all professions.
What is a Self-Improving Agent?
A self-improving agent is an AI system with the capacity to:
- Evaluate its own performance - Know when it’s doing well or poorly
- Learn from its mistakes - Modify behavior based on failures
- Optimize its processes - Improve how it approaches tasks
- Update autonomously - Incorporate improvements without direct human intervention
Addy’s Example: Cyclical Coding Agents
The key concept Addy presents is the continuous improvement cycle:
# Pseudocode of the flow
while there are failed tasks:
for each task:
generate solution
execute tests
if passes:
mark as completed
if fails:
analyze error
generate correction
retry
update task list
The brilliance isn’t each individual step, but the complete autonomous cycle. The agent doesn’t need a human to say “this test failed, fix it.” It detects it, corrects it, and learns from the process.
The Three Critical Capabilities
According to industry analysis, an effective self-improving agent needs:
- Autonomy - Operate independently without constant supervision
- Learning - Capacity to acquire new skills and knowledge
- Self-improvement - Modify its own algorithms, parameters, and decision processes
Without all three, it’s not really a self-improving agent. It’s just a script with some ML models underneath.
The 80% Problem
Addy also mentions the “80% Problem in Agentic Coding”:
“Agents can rapidly generate 80% of the code, but the remaining 20% requires deep knowledge of context, architecture, and trade-offs.”
This is the current challenge. Agents are brilliant at “obvious” tasks, but struggle with:
- Subtle architectural decisions
- Long-term design trade-offs
- Tacit domain knowledge
- Experience-based judgments
My reading: this won’t change soon. Agents will continue to be powerful tools for the 80%, but the 20% will still need experienced humans.
What This Means for Us
The Developer as Orchestrator
If agents can do 80% of the work… what do we do?
I think the developer role is evolving toward:
- Orchestrator - Design multi-agent systems that work together
- Architect - Define system structure and constraints
- Reviewer - Review and curate agent outputs
- Problem-solver - Tackle the difficult 20% agents can’t solve
My Personal Take
I have to admit: Addy’s mentioned transition from 80/20 to 20/80 resonates with me a lot. I’m also doing much more “orchestration” and much less “pure coding” than a year ago.
Is it good? Is it bad? Neither. It’s different.
What worries me is the skills gap that’s opening:
- Developers who adopt agents → Super-productive
- Developers who don’t adopt agents → Left behind
- Developers who only know how to use agents → Superficial
The sweet spot is in the middle: knowing how to use agents but understanding what they’re doing.
Conclusion
Self-improving agents aren’t the future. They’re the present.
And it’s not hype. It’s a natural evolution of AI we’re seeing: from passive tools to autonomous systems that learn and improve.
The question isn’t “will agents replace us?” The question is: “how do we work with agents to be 10x more productive?”
My answer: understanding they’re tools, not magic. And that human value is in thinking critically about what problem to solve, how to solve it, and whether the solution the agent produced is really good.
The rest? Well, agents already do that pretty well.
Comments