Code That Evolves Itself
The Missing Loop
Eight articles into this series, I thought I'd mapped out the full picture. Agents write code (Part 8). Agents replace apps (Part 4). You manage agents instead of writing code yourself (Part 6). The paradigm shift already happened (Part 9).
But I was missing a loop. The one that makes all the other pieces click.
What happens when an agent knows its own source code?
Not "can read files." Knows. Understands its own architecture, knows which model it runs, knows what tools it can call, knows where its documentation lives. The moment that happens, something qualitatively new emerges — and Peter Steinberger's OpenClaw is the clearest proof I've seen.
Self-Aware Software
Peter built the framework in about an hour. A simple bridge: WhatsApp messages piped to Claude Code's CLI, responses sent back. It became the fastest-growing repository in GitHub history — 175,000+ stars. But the growth isn't the interesting part.
The interesting part is what he did next. He made the agent aware of itself.
Peter uses the framework to develop the framework. When debugging, he doesn't dig through code himself. He asks the agent: "What tools do you see? Can you call this tool yourself? Read the source code. Figure out what's wrong." The agent knows its own harness, its architecture, its capabilities. Peter gave it deep self-knowledge.
And then this started happening: users who have never written code send what Peter calls "prompt requests" — natural language descriptions of changes they want. The agent reads the request, reads its own source code, understands the architecture, writes the implementation, and submits a pull request.
"People talk about self-modifying software," Peter said. "I just built it."
This is a fundamentally different loop from anything I've described in this series. In Part 6, the shift was from writing code to managing agents. In Part 8, the insight was that the harness unlocks the model's potential. But self-aware software closes a new loop entirely: the agent doesn't need a manager. It manages itself. The one-hour prototype evolves on its own.
The Evidence Was in My Own Hands
When I look back, the signs were already there in my own experience.
I set up the framework on GCP and connected it to Feishu so non-technical team members could work directly with an agent — I wrote about this in Part 5. What I didn't emphasize enough was what happened after the initial setup. The agent didn't just answer questions. When someone needed a small tool that didn't exist, the agent built it. When a workflow was inefficient, the agent figured out a shortcut. It wasn't waiting for instructions — it was solving problems with whatever it had.
Peter saw the same thing in Marrakesh. He sent his agent a voice message — something he'd never built support for. The agent received an unknown file, checked the file header, identified Opus audio, used ffmpeg to convert it, found an OpenAI API key in the environment, called the transcription API, and answered the question.
"How the fuck did he do that?" Peter said, staring at his phone.
The model's intelligence was always there. The harness gave it permission. But self-awareness — knowing your own tools, your own code, your own capabilities — turns permission into initiative. The agent doesn't wait to be told how. It figures it out by understanding what it has.
This is the difference between a tool and a collaborator. A tool does what you tell it. A collaborator understands its own capabilities and applies them creatively. When the agent knows its own source code, it stops being a tool.
Software Eats Itself
Peter predicts 80% of apps will die. I think he's right.
Every standalone app is a frozen assumption about what you need. MyFitnessPal assumes you want to manually log food. Eight Sleep's app assumes you want to manually adjust your bed temperature. Your calendar app assumes you want to manually create events.
An agent that knows you — your schedule, your location, your habits — doesn't need any of those assumptions. "Remind me about dinner tomorrow, invite two friends, send them a message." Done. No app required.
This is where Part 4's "disposable software" thesis reaches its logical end. I argued that AI makes software cheap enough to generate on demand. The actual endgame is more radical: you don't even need to generate software. The agent is the software. Every app becomes a slow API that your agent navigates — through legitimate APIs when available, through the browser when not. Peter watched his agent click "I'm not a robot" buttons. The agent doesn't care about your UX.
And when the agent can build custom software just for you — a one-off tool tailored to your exact need, used once and discarded — why would you pay monthly for a service that does 80% of what you want?
The moats from Part 9 — data lock-in, workflow lock-in, integration complexity — crumble at every level. Not just enterprise SaaS. Every app on your phone.
The Loop Closes
Code has learned to evolve itself. The agent reads its own source, modifies its own architecture, submits its own pull requests.
Peter built the framework in one hour. Three months later, 175,000 stars. No venture capital, no team. The software is rewriting itself.
References: