I've been writing code and creating software as a hobby for three decades and professionally for fifteen years. For all of that time, the job has had the same fundamental loop. Humans write code, humans review code, humans deploy code, humans monitor what happens. The tools get better, the frameworks change, but the loop has stayed the same.
I think the loop is ending.
I've been doing AI-assisted programming for a while now and the productivity gains are real. But I keep running into the same wall: the codebases I work in were never designed for this way of working. The AI fights the architecture. The context windows fill up with legacy decisions. You spend half your time explaining the codebase to the machine instead of building.
Which got me thinking. What if you designed a codebase from scratch for a world where AI writes all the code?
Three layers
The software I want to build has three properties.
AI-built. The human writes specifications and reviews visual output. The AI writes all the code, runs the test suite, fixes what breaks, opens a pull request. The human never reads the source. The codebase is optimized for machine comprehension: small files, strict types, explicit boundaries. Code review gets replaced by automated verification. Type checking, linting, security scanning, visual regression, performance budgets, architectural rules. If the machine can't verify it, it doesn't ship.
AI-powered. AI capabilities are infrastructure, not features. Model routing, prompt management, cost tracking, caching, quality monitoring. Product people iterate on AI behavior through an admin interface, not through code deployments.
AI-operated. The application monitors itself. Error tracking, anomaly detection, incident analysis. When something breaks, an agent files a bug, another agent fixes it, CI verifies the fix, and it ships. The human sees a summary in the morning.
These three things together create a development loop that can run without human intervention. I haven't built this yet. But I believe it's possible today, with current tools, if you design for it from the start.
The context engine
Here's what I think most people building AI features are missing.
Your AI is only as good as what it knows. And right now, most AI features know almost nothing about the user's world. They work with whatever gets typed into a prompt box, maybe the current document.
The real unlock is a context engine. A system that connects to everything the user works with and makes all of it available as context. When you ask the system to create a board presentation, it already knows your financials, your strategic priorities, the key updates from Slack, the metrics from your analytics. It doesn't start from zero.
This changes what a product even is. The editor is a commodity. The accumulated understanding of your world is the product.
Agents talking to agents
We build software for humans to click through graphical interfaces. I think that's about to become the minority use case.
Soon, most interactions with most software will be agent-to-agent. Your personal AI talks to your company tools, which talk to external services. The human sets intent and reviews outcomes.
Software needs to be designed for this. Two layers: a structured API for precise operations, and an intent layer where agents describe what they want and the system figures out how. The second layer is what separates software that agents can technically use from software they can use well.
What changes
When one person with AI can ship more in a week than a team shipped in a quarter, the bottleneck moves. It stops being about headcount or velocity. It becomes about clarity of vision, rigor of verification, and taste.
I find this genuinely exciting. And a little scary. The ground is shifting under everything I thought I knew about building software, and I'm curious to see where we end up.