The AI Maturity Curve for Software Developers
This post was created with AI assistance and follows the Kladde 26 manifesto.
Kladde 26 is a manifesto for transparency in AI-assisted writing; it asks writers to show their workings. The frequently asked questions provide the background.
The most useful way to think about the AI maturity curve is not how much AI a developer uses, but how the developer's primary bottleneck changes over time.
A developer who has used AI tools for two years is often performing fundamentally different work from a developer who started using AI last month.
Research suggests that productivity improvements from AI are not only about generating code faster. As developers gain experience with AI-assisted development, the work shifts toward specification, orchestration, review, and systems thinking. Beneath this shift of bottlenecks runs a quieter transition in what the developer actually produces: code, then decisions, then direction.
Stage 0: Skeptic
AI is used occasionally, more like an enhanced search engine or Stack Overflow replacement than a code-writing tool. Small snippets get copied, but the code is still written manually.
The primary bottleneck is producing code. The typical question is: can AI generate this function?
Productivity gains are usually limited, because the tool is used only intermittently and has not yet become part of the developer's normal workflow.
Stage 1: Assisted Coding
This is where most developers begin. GitHub Copilot, Cursor, or similar tools are used continuously for boilerplate code, tests, and documentation, and for chat-assisted API questions and syntax assistance.
The primary bottleneck is typing and syntax recall. This stage often delivers the largest immediately visible gains, because repetitive work is automated.
Controlled experiments involving 4,867 developers across Microsoft, Accenture, and a Fortune 100 company found that developers with access to AI coding assistants completed approximately 26% more tasks than those without access. Less experienced developers tended to adopt the tools more aggressively and experienced larger short-term gains. (Microsoft)
Stage 2: Conversational Development
A significant transition happens when developers stop asking AI for individual functions and start asking it to solve larger problems: multi-file code generation, architecture discussions, AI-assisted debugging, automated refactoring, and design reviews.
The primary bottleneck is problem definition. The typical question is: implement this feature given these requirements. The key skill becomes requirements clarification: context preparation, examples, constraints, and acceptance criteria.
At this stage, success depends less on prompt wording and more on the ability to formulate the problem clearly.
Stage 3: Workflow Integration
At this stage, AI becomes part of the development workflow rather than a standalone tool: it writes code, generates tests, drafts pull request descriptions, reviews code, explains legacy systems, and generates migration plans.
The primary bottleneck is context management. The key question becomes: how do I give the model everything it needs to make good decisions? Developers start creating coding standards, architecture documents, project rules, reusable prompts, and AI-readable documentation.
Research from Google and DORA suggests that developers who trust AI use it more extensively, and broader adoption is associated with greater productivity benefits. (research.google)
Stage 4: Orchestration
Recent research describes a transition from "coder to conductor". Developers spend less time writing code directly and more time defining tasks, reviewing outputs, coordinating AI-generated work, evaluating alternatives, and making architectural decisions.
The primary bottleneck is decision quality. The typical question changes from "how do I build it" to "what should be built".
A 2026 qualitative study of senior engineers found that developers increasingly describe AI as a cognitive partner and report a shift from implementation-focused work toward strategic and architectural thinking. Researchers characterize this transformation as a movement from "coder to conductor". (research.google)
Stage 5: Agent Management
This stage is emerging with the rise of autonomous coding agents. Developers increasingly define objectives, specify constraints, delegate implementation, review outputs, correct direction, and repeat.
The primary bottleneck is delegation. The key skills are goal definition, risk management, quality assurance, validation, and guardrail design.
The role begins to resemble engineering management more than traditional software implementation.
Stage 6: Team-Level AI Maturity
Many organizations currently struggle at this stage: individual developers may experience substantial productivity gains, while team-level productivity improvements remain smaller. Organizations invest in AI coding standards, AI review policies, AI testing strategies, governance frameworks, shared architectural context, and documentation systems.
The primary bottleneck is organizational coordination.
Research on developer productivity consistently shows that factors such as code quality, technical debt, communication, tooling, and organizational processes remain major determinants of productivity regardless of AI adoption. (research.google)
The Hidden Transition: From Developer to Architect to Product Manager
Beneath the changing bottlenecks runs a quieter transition that the stages make easy to miss: what the developer produces changes. Early on, the output is code. Further up the curve, it becomes technical decisions: architecture, trade-offs, constraints. At the top, the output is the answer to a different question: what should be built at all. The typical questions of the stages already trace this trajectory: "Can AI generate this function?" gives way to "Implement this feature given these requirements," and finally to "What should be built?" The center of gravity moves from developer to architect to product manager.
The transition is not a series of promotions with clean boundaries. The roles overlap, the shift is gradual, and even at the top of the curve most people still write some code. The developer role shrinks, but it rarely disappears.
The change is neither pure gain nor pure loss. The gain is speed of verification: an idea becomes working software quickly, and the loop from idea to evidence shortens dramatically. The loss is depth of understanding: less time producing code means fewer opportunities to develop a gut feeling for the code, the intuition about where bugs hide and how systems really behave, which only grows through hands-on work. Mature AI users trade some of that embodied understanding for a wider view; the best ones are aware of the trade and deliberately keep their hands in.
The hidden transition may also explain why so many organizations struggle at Stage 6. Hiring still targets the old developer role: organizations hire seniors, because seniors already embody exactly this horizontal skill set (task definition, context management, review, orchestration), developed while performing a developer role. Juniors, many of whom worked with generative AI largely in secret because schools and universities could not adapt fast enough, often possess that skill set natively. Yet without a chance to be hired, they never accumulate the domain knowledge needed to apply it. By hiring for immediate need rather than strategically, organizations miss the next generation of developers entirely.
The remedy is simple to state and hard to implement: evaluate and hire for the horizontal skills directly, regardless of seniority (task definition, review, orchestration), and bring juniors in early enough to build domain knowledge on the job. Managing the developer-to-architect-to-product-manager trajectory as an explicit career path would turn what already happens implicitly into a planned move instead of an invisible drift.
What Distinguishes Highly Mature AI Users?
The most important difference is not prompt-writing skill. It is task decomposition skill.
Less mature users ask: "Generate code for X." More mature users ask: "Given these requirements, constraints, and quality standards, implement X, generate tests, explain trade-offs, identify risks, and propose alternatives."
The AI may generate similar code in both cases, but the engineering outcome is often very different.
A Useful Mental Model
Traditional development
| Activity | Approximate Share |
|---|---|
| Writing code | 60% |
| Reading code | 20% |
| Design | 10% |
| Review | 10% |
Highly AI-mature development
| Activity | Approximate Share |
|---|---|
| Writing code | 10–20% |
| Context building | 20–30% |
| Design | 20–30% |
| Review and validation | 20–30% |
| Orchestration | 10–20% |
The evidence emerging from recent research suggests that AI maturity is not primarily about becoming a faster programmer.
Instead, developers progressively become:
- better problem definers,
- better system designers,
- better reviewers,
- better orchestrators of human-AI workflows.
The highest-performing AI-assisted developers increasingly spend less time implementing solutions and more time deciding what should be built, defining constraints, evaluating outcomes, and coordinating work across humans and AI systems. (research.google)
The curve is therefore also a role trajectory, from developer to architect to product manager, and the choice is whether that transition happens deliberately or by drift.
References
- Cui, K., Demirer, M., Jaffe, S., Musolff, L., Peng, S., & Salz, T. (2025–2026). The Effects of Generative AI on High-Skilled Work: Evidence from Three Field Experiments with Software Developers. Microsoft Research / Management Science. Available via Microsoft Research and Management Science. (Microsoft)
- Edwards, R., & Appiah, R. (2026). Developer Productivity in the Age of Generative AI: A Psychological Perspective. Research exploring the transition from "coder to conductor" among senior software engineers. (research.google)
- Peng, S., Kalliamvakou, E., Cihon, P., & Demirer, M. (2023). The Impact of AI on Developer Productivity: Evidence from GitHub Copilot. Microsoft Research. (Microsoft)
- Storer, K., DeBellis, D., D'Angelo, S., & Brown, A. (2024). Fostering Developers' Trust in AI. Google DORA Research. (research.google)
- Cheng, L., Murphy-Hill, E., Canning, M., et al. (2022). What Improves Developer Productivity at Google? Code Quality. Foundations of Software Engineering. (research.google)
- Jaspan, C. N. C., & Green, C. (2023). Developer Productivity for Humans: A Human-Centered Approach to Developer Productivity. IEEE Software. (research.google)
- Storer, K. (2024). How Gen AI Affects the Value of Development Work. Google DORA Research. (research.google)