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.
Overview
The most useful way to think about the AI maturity curve is not as a measure of how much AI a developer uses, but rather as a measure of 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 solely the result of generating code faster. Instead, developers increasingly shift toward specification, orchestration, review, and systems thinking as they become more experienced with AI-assisted development. Beneath this shift of bottlenecks runs a quieter transition in what the developer actually produces: code, then decisions, then direction.
Stage 0: Skeptic
Uses AI occasionally, treats it as an enhanced search engine or Stack Overflow replacement, copies small code snippets, and primarily writes code manually.
Primary bottleneck: producing code.
Typical question: Can AI generate this function?
Productivity impact: productivity gains are usually limited, because AI 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. Developers use GitHub Copilot, Cursor, or similar tools continuously; generate boilerplate code, tests, and documentation; and use chat interfaces for API questions and syntax assistance.
Primary bottleneck: typing and syntax recall.
Productivity impact: 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 occurs when developers stop asking AI to generate individual functions and begin asking it to solve larger problems: multi-file code generation, architecture discussions, AI-assisted debugging, automated refactoring, and design reviews.
Primary bottleneck: problem definition.
Typical question: Implement this feature given these requirements.
Key skill: developers increasingly invest effort in 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 problems 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.
Primary bottleneck: context management.
Key question: How do I provide the model with everything it needs to make good decisions?
Emerging practices: developers begin 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.
Primary bottleneck: decision quality.
Typical question: What should be built? Rather than: How do I build it?
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.
Primary bottleneck: delegation.
Key skills: 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.
Primary bottleneck: 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 and 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. 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 — task definition, review, orchestration — regardless of seniority, 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 dramatically 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% |
Key Conclusion
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)