The Levels of Agentic Programming
Most developers are stuck at level 2. Here's the full progression from autocomplete to autonomous agents, and what changes at each step.
> Key Takeaways
- > There are five distinct levels of agentic programming, from basic autocomplete (L1) to fully autonomous agents (L5).
- > Most developers plateau at Level 2 (chat-based copilot usage) and mistake it for the ceiling.
- > The jump from L2 to L3 requires a fundamental shift: writing specs and constraints instead of writing code.
- > Level 4 (supervised autonomy) is where the highest ROI currently sits for production teams.
- > Level 5 is real but narrow. It works for well-bounded, well-tested domains only.
> Linked Resources
Specs before prompts
2,500+ research papers on agentic development.
Sweeping the jagged frontier.
> Transcript
▶ Show full transcript
Welcome to Ship the Loop. Today we're talking about the levels of agentic programming.
Most developers I talk to are somewhere around level 2. They've got a copilot, they're using chat to generate code, and they think that's the end of the road. It's not. There are five distinct levels, and the jump between each one changes how you work in fundamental ways.
Level 1 is autocomplete. This is where most people started. Tab completion, line suggestions, maybe a function body here and there. It's useful, but it's just typing faster. Your process doesn't change at all.
Level 2 is chat-based copilot. You open a side panel, describe what you want, paste code in, get code back. This is where the majority of developers are right now. The problem is that the feedback loop is still manual. You're the bottleneck at every step.
Level 3 is where things get interesting. This is agentic task completion. You give the agent a well-defined task ("implement this API endpoint according to this spec") and it does the work across multiple files, runs tests, iterates on failures. Your job shifts from writing code to writing specs and reviewing output.
Level 4 is supervised autonomy. The agent operates continuously on a backlog of tasks. You're reviewing pull requests, not writing code. The key word is supervised. You're still in the loop, but your role is quality assurance and architectural direction, not implementation.
Level 5 is full autonomy. The agent handles end-to-end delivery with minimal human intervention. This sounds like science fiction, but it works today in narrow, well-bounded domains with strong test coverage. The catch is that "narrow and well-bounded" does a lot of heavy lifting in that sentence.
The takeaway: don't stop at level 2. The real productivity gains start at level 3, and most teams can get there with better specs, better tests, and a willingness to change how they define "doing the work."
That's the loop. Ship it.