> ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. --- title: "Levels of AI Adoption" url: https://daily.dev/agentic-ai-hub/levels-of-ai-adoption/ description: "Before you can improve how your team works with agents, you need a shared way to say where you are." lastUpdated: "2026-07-22" --- Before you can improve how your team works with agents, you need a shared way to say where you *are*. Two frameworks have become the common reference points, and they are complementary rather than competing. One describes the maturity of your *practice*, the other describes the autonomy you grant on a *given task*. ## Shapiro's Five Levels: a maturity ladder Dan Shapiro's ["The Five Levels: from Spicy Autocomplete to the Dark Factory"](https://www.danshapiro.com/blog/2026/01/the-five-levels-from-spicy-autocomplete-to-the-software-factory/) borrows the NHTSA's driving-automation levels deliberately, because the analogy gives "a common language for both where things were, and where things were going." The levels describe how much of the *job* has moved to the machine: - **Level 0: Manual.** The AI is a search engine or occasional tab-completion. "The code is unmistakably yours." No real productivity change. - **Level 1: Discrete task offloading.** Cruise control and lane-keeping. You delegate isolated, well-bounded work such as unit tests, docstrings, or a self-contained function, but your core job is unchanged. Classic Copilot/ChatGPT usage. - **Level 2: Active pairing.** Highway autopilot. The AI is a junior colleague handling "the boring stuff" while you manage flow and review. "You get into a flow state; you're more productive than you've ever been." Shapiro estimates ~90% of AI-native developers live here, and he issues the level's defining warning: it *"feels like you are done. But you are not done."* - **Level 3: Human-in-the-loop management.** Waymo with a safety driver. You stop writing code and start reviewing diffs from a senior-developer-grade agent running several tasks. "Your life is diffs." Shapiro notes that for many people "this feels like things got worse," and that "almost everyone tops out here." - **Level 4: Specification-driven.** A robotaxi. You are not driving. You write specs, argue requirements, craft prompts, and review test results. "You've now become that which you loathed: you're a PM." Leave for twelve hours, come back to check the suite is green. - **Level 5: The dark factory.** The Fanuc-style "dark factory," with robots building software while humans are "neither needed nor welcome." Shapiro reports this only working for very small teams (under five people) and calls it "nearly unbelievable," while conceding it "will likely be our future." The framework's most useful insight is that these are **qualitative shifts in human responsibility, not incremental speedups.** Each level up trades a kind of work you may love (writing code, being in flow) for a kind you may not (reviewing diffs, writing specs, arguing requirements). That is exactly why people plateau. Level 2 is pleasant and Level 3 feels like a demotion. The plateau is psychological rather than technical. Steve Yegge's ["Revenge of the Junior Developer"](https://sourcegraph.com/blog/revenge-of-the-junior-developer) sketches the same ascent as six *waves* (completions → chat → coding agents → agent clusters → agent fleets), each of which he claims is "conservatively about 5x as productive as the previous wave." Two of his observations complicate the plateau story. He reckons "vibe coding is still completely invisible to 80% of the industry outside Silicon Valley," and he sees adoption running *backwards* by seniority, in that "junior developers have actually been far more eager to adopt AI than senior devs." If so, the plateau may be demographic as well as psychological. ## Osmani's Agentic Autonomy Levels: a per-task dial Addy Osmani's ["Agentic Autonomy Levels"](https://addyosmani.com/blog/agentic-autonomy-levels/) covers similar ground but with a different unit of analysis. Where Shapiro describes *your career stage*, Osmani describes *how much rope you give the agent on this particular task*, built on two axes, agency (how much the agent does) and orchestration (how many agents, how coordinated): - **L0 Assist.** The agent suggests, you decide and act. - **L1 Supervised action.** The agent edits and runs commands but asks before anything consequential. The risk is *approval fatigue*, rubber-stamping every prompt. - **L2 Scoped task delegation.** Bounded work with clear goals, mostly unsupervised and interruptible. Verification shifts from reading every line to *automated evidence* (tests, types, screenshots). - **L3 Goal-driven autonomy.** The agent "does whatever it takes to achieve a goal, stopping only when some condition is met." Requires *measurable* stopping conditions. Vague goals fail here. - **L4 Parallel delegation.** Multiple isolated agents at once. The hard part is decomposing work into non-overlapping slices. - **L5 Managed-by-exception orchestration.** A manager agent dispatches, monitors, verifies, and escalates. You "step in only when things fail." The unifying idea is **calibrated autonomy**. The right level is a function of task risk, reversibility, and how good your verification is, not a badge of how advanced you are. A throwaway prototype can run at L3 safely. A database migration on production data might belong at L1 no matter how senior your team. Marc Nuri and others have since argued both ladders under-specify the messy middle where "agent chaos" precedes real orchestration, which is a fair critique. Treat the numbers as conversation-starters, not a certification scheme. ## What the data says Both ladders are practitioner syntheses, so it is worth checking them against survey data. The data supports the shape while complicating the optimism. Adoption is near saturation. The [2025 DORA report](https://dora.dev/dora-report-2025/) finds 90% of respondents using AI at work, and [Stack Overflow's 2025 survey](https://survey.stackoverflow.co/2025/ai/) has 51% of professionals using it daily. Trust is falling at the same time. 46% actively distrust the accuracy of AI output, and the top frustration, cited by 66%, is "AI solutions that are almost right, but not quite." DORA also offers the best corrective to ladder thinking. Instead of levels it describes seven team *profiles*, and it concludes that "AI's primary role is as an amplifier, magnifying an organization's existing strengths and weaknesses." Climbing the ladder scales whatever delivery system you already have, weak or strong. The sharpest single data point is [METR's randomized controlled trial](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/), which put 16 experienced maintainers through 246 real tasks on their own mature repos. With AI "they take 19% longer than without: AI makes them slower," yet even after the fact they believed AI had sped them up by 20%. The study's scope is narrow, but its lesson travels. Self-perceived productivity is not a measurement. Birgitta Böckeler's autonomy-pushing experiments at Thoughtworks ([How far can we push AI autonomy?](https://martinfowler.com/articles/pushing-ai-autonomy.html)) put an empirical ceiling on the top rungs. Full-app generation worked at small scope and degraded with complexity, and she concluded that "AI is not ready to create and maintain a maintainable business software codebase without human oversight." Supervision looks like a standing feature of the discipline rather than a stage you graduate out of. ## The tension between the ladders The two ladders are most useful read *against* each other, because they measure different things and the interesting failure modes live in the mismatch. Shapiro's level tells you how your role has structurally changed (are you still writing most code, or living in diffs and specs?). Osmani's level tells you your *default* trust setting per task (do you approve every edit, or only look when something breaks?). The pairing surfaces two common dysfunctions. The first is a team stuck at Shapiro L2 that *thinks* it's higher because it runs agents constantly but reviews nothing, which is the high-usage, low-trust gap the Stack Overflow numbers describe at population scale. The second is a team running L4 parallel delegation with L1 verification discipline, generating far faster than it can trust. One warning before you plot yourselves in a retro. METR's perception gap says teams misjudge their own position, so anchor the conversation in observable signals like review depth, rework rates, and incident trends rather than felt productivity. Anthropic's [study of agent autonomy in practice](https://www.anthropic.com/research/measuring-agent-autonomy), drawn from millions of real Claude Code sessions, found that "autonomy is not a fixed property of a model or system but an emergent characteristic of a deployment," co-constructed by model, user, and product. Experienced users, strikingly, auto-approve *more* and interrupt *more* at once. The levels are a vocabulary rather than a scoreboard. What matters is being "in a position to intervene when it matters."