Tab completion was the first taste. Your cursor blinks, you start typing, and suddenly the next three lines appear. You press tab. It's right. You keep going. That was Stage One - and we're already way past it.
A detailed framework on Dev.to maps out where AI-assisted coding has been and where it's heading. The progression isn't just about better models - it's about fundamentally different types of problems at each stage. And the barriers ahead are harder than most people realise.
Stage One: Autocomplete on Steroids
This is what GitHub Copilot launched with. Single-step prediction. You write a function signature, the AI suggests the body. You write a test, it suggests the implementation. The AI is reacting to immediate context - the file you're in, maybe a few related files, patterns it's seen in training data.
Stage One works because the problem is narrow. Predict the next logical chunk of code given current context. It's impressive, and genuinely useful, but it's not reasoning about your codebase. It's pattern-matching at scale. When it works, it feels like magic. When it fails, it's obvious - the suggestion is syntactically correct but semantically wrong for your specific case.
Stage Two: Agent-Assisted Development
This is where we are now. Tools like Cursor, Aider, and Copilot Workspace move beyond single-step prediction. They can navigate your codebase, make multi-file changes, understand project structure. You describe what you want - "add authentication to the API" - and the AI figures out which files to touch, what changes to make, how to test it.
The shift is from autocomplete to collaboration. The AI isn't just predicting the next token - it's planning a sequence of changes. It's reading error messages and adjusting. It's maintaining context across multiple files and editing sessions.
But Stage Two still requires constant human oversight. You review every change. You catch the mistakes - and there are always mistakes. The AI can write code, but it can't verify correctness beyond surface-level checks. It doesn't truly understand what your code does. It's very good at looking like it does.
Stage Three: The Autonomous Software Factory
This is the theoretical endpoint. You describe a product in natural language. The AI builds it - architecture, implementation, tests, deployment. It handles bugs, updates dependencies, refactors as requirements change. Full long-horizon autonomy. This is what everyone's excited about and nobody has working yet.
The barriers here are fundamental, not just engineering challenges. Verification is the big one. How does an AI know its code is correct? Current approaches rely on tests, but who writes the tests? If the AI writes them, how do we know the tests are right? You end up with an AI checking an AI's work - which sounds good until you realise both could be wrong in the same way.
Natural language ambiguity is another wall. "Make the app faster" - faster how? Latency? Throughput? Perceived speed? For which users? Under what conditions? Humans resolve this ambiguity through conversation, context, and shared understanding. AIs don't have that shared understanding. They can ask clarifying questions, but they don't know what questions matter most.
The Honest Assessment
We're solidly in Stage Two. Stage Three isn't six months away. It might be years. The progression from Stage One to Stage Two took better models plus better scaffolding - context windows, file navigation, planning capabilities. The jump to Stage Three requires something harder: reliable verification, true long-horizon reasoning, and handling the ambiguity of real product requirements.
That doesn't make Stage Two less useful. AI that can navigate a codebase and make multi-file changes is genuinely powerful. It changes how fast you can build, what one person can accomplish, how much time you spend on boilerplate versus product thinking.
But for anyone expecting Stage Three imminently - full autonomous software development - the technical barriers are clearer now than they were a year ago. Verification, ambiguity resolution, and long-horizon planning remain hard problems. Progress is being made. It's just not exponential.
For developers, the practical message is: learn to work well with Stage Two tools now. They're not going to replace you this year or next. But they will change what you spend your time on. Less typing, more thinking. Less boilerplate, more architecture. That's the shift that's already happening.