3 AImigo S1E1: Where AI Stands in Software Development

Start with four coordinates, not a model ranking: the SDLC stage, the degree of delegation, the maturity of the practice, and the unit in which impact is measured. Completion and a cloud agent may use a related model, but they draw a very different responsibility boundary. Likewise, an engineer completing a short task faster is a different claim from the whole delivery system moving faster.

Coordinate 1 is the SDLC stage: where AI acts, from discovery and specification to operations. Coordinate 2 is the degree of delegation: assist, interact, delegate a bounded task, orchestrate a chain, and operate within a production loop. Coordinate 3 is practice maturity: norm → scaling → experiment → horizon. The table below keeps all four states; a separate three-zone view later shows the shift in responsibility from individual practice to team process and the horizon. Coordinate 4 is the unit of effect: task → developer → team → delivery → business. It prevents code-writing speed from masquerading as value-delivery speed. DORA frames AI as an amplifier of the system already in place. Stack Overflow's 2025 annual survey captured low trust and agent use trailing simpler assistance; its April 2026 pulse shows rapid growth in agent use, but not a shift to full autopilot. [S01] [S02] [S37]

The four coordinates also explain how one practice can mature without changing its headline use case. A team may begin by asking questions about unfamiliar code, add repository context, allow the agent to write to a branch, and automate draft pull requests only once it has accumulated evidence. The SDLC stage stays the same while delegation and potential blast radius grow. The reverse move is legitimate too: when a team enters an unfamiliar library or a critical service, it may deliberately return the agent to explanation mode even if end-to-end task execution is routine elsewhere.

Maturity should therefore be attached to a repeatable operating contract, not license count. Who frames the task? Which context is supplied, and how is its provenance known? What may the agent change? Which check catches an unsafe result? Who accepts the work? Which measure would show that the overall flow improved? Those questions turn a debate about AI-generated code share into a discussion of the production system. Without them, heavy usage may represent a valuable habit—or an expensive way to produce more variants for people to inspect.

By mid-2026, individual AI tools had become commonplace, and coding agents had moved quickly beyond demos. In the global January 2026 AI Pulse, 90% of more than 10,000 developers regularly used at least one AI tool at work and 74% used a specialized development tool. This is a weighted but self-selected vendor survey, not a census, and it does not cleanly separate completion, chat, and agents. In a separate self-selected Stack Overflow pulse survey in spring 2026, 59% of 1,100 respondents used agents at work at least occasionally. [S36] [S37]

Agent presence is not an autonomous process. In the same pulse survey, 63% rarely or never ran an agent fully autonomously, 60% blocked unapproved system changes, and 68% preferred a single agent to a complex multi-agent setup. Anthropic telemetry puts the median Claude Code turn at about 45 seconds; only the extreme tail has grown into tens of minutes. An analysis published in July 2026 of 25,264 agentic pull requests in 2,361 popular public repositories found that the median repository receives only one or two such pull requests across its May–July 2025 window, and predominantly single-human oversight; because that window is 2025, it sets a floor rather than the current level. Public open source and a self-selected survey do not describe the whole market, but they point to the same boundary: agentic delegation is growing, while intensive team adoption remains concentrated.[S37] [S38] [S41]

The most mature area still centers on code. In Claude Code telemetry from October 2025 through April 2026, the human made about 70% of planning decisions in a typical session while the model made about 80% of execution decisions. By April 2026, GitHub had expanded its cloud agent into repository research, plan approval, and branch work with diff inspection before a pull request. This is the current capability boundary, not evidence of accepted change or faster delivery. Anthropic's April telemetry and GitHub's September GA announcement from 2025 remain in the ledger only as early milestones in the shift from assistance to delegation—not as an August 2026 market snapshot.[S05] [S39] [S04] [S14]

In requirements, AI generates alternatives but does not own the trade-off. In review it is useful as one more first reader, but cloud-agent documentation keeps approval and merge with a human. In operations, summaries, triage, and bounded runbooks are useful; a long-lived autonomous SRE still needs too much authority and too much judgment about sufficiency. [S15]

Before implementation, AI is most useful where the goal is to widen the space of alternatives quickly. It can assemble questions for a stakeholder, identify contradictions, draft acceptance criteria, and compare architectural paths. Value appears only when an accountable owner closes the loop. A model does not know the actual cost of delay, the political weight of a dependency, or the product's tolerated risk. An agent-ready specification is therefore not simply a long document: it states the goal, boundaries, examples, verification path, and decisions that must remain human.

Beyond implementation, maturity is bounded by the cost of a wrong action. Generated tests and documentation are relatively safe when their artifacts can be executed or compared with code. Security, release, and operations demand authority and consequence awareness: finding a vulnerability is not safely fixing it; a green build is not release readiness; a plausible incident explanation is not an appropriate production action. The closer an action gets to production, the more important bounded commands, previews, owner confirmation, and a fast rollback become.

Modernization is a special case. Agents are well suited to reading many similar files, mapping dependencies, applying mechanical transformations, and rerunning tests. Yet portfolios are rarely homogeneous. Exceptions, historical workarounds, and missing owners turn a universal migration into a set of local decisions. Mature practice first classifies applications, identifies reversible steps, and defines stop conditions. The agent scales a transformation that is already understood; it does not decide which legacy should be preserved, rewritten, or retired.

In a bounded JavaScript task, Copilot participants finished 55.8% faster. Across three field experiments, AI access increased completed tasks by 26.08% in pooled data from 4,867 developers. A separate supplier-run study found AI-assisted work far more likely to pass every unit test—a 53.2% greater likelihood—while readability, reliability, maintainability, and conciseness improved by only 2–4%. These are real results—inside their tasks and denominators. [S06] [S07] [S08]

These are primarily historical trajectory points: they measured completion or early assistants on bounded work. A fresher organizational snapshot arrived in July 2026. An observational study of an early CLI-agent rollout among tens of thousands of Microsoft engineers estimated that adopters merged roughly 24% more pull requests over four months. Adoption was not randomized, however, and a merged pull request is a proxy for engineering output—not value, quality, or delivery stability.[S40]

METR found the opposite in a different setting: 16 experienced developers who had contributed to their own large repositories for years took 19% longer across 246 real tasks with early-2025 tools, a result METR has since marked out of date. Its follow-up with late-2025 tools shrank the slowdown markedly — to −18% for returning participants and −4% for new recruits — but the point estimate stayed negative, the confidence intervals include zero, and METR itself calls the new estimate an unreliable signal while it redesigns the study. Another evaluation of 296 pull requests found that four maintainers would reject roughly half of the benchmark-passing changes without revision. [S10] [S11] [S12]

The contradiction dissolves once context returns. A short greenfield artifact is not a familiar repository with tacit constraints. “Task complete” is not “maintainable and mergeable.” A public benchmark is not an internal eval suite. OpenAI now argues that SWE-bench Verified no longer offers a clean frontier signal; prior DORA work found individual gains alongside weaker delivery measures.[S09] [S13]

One way to reconcile the studies is to follow an outcome through four filters. The model first produces a technically plausible change. Automated checks then catch known error classes. A human evaluates tacit repository conventions, architecture, and maintainability. Finally, the released change must produce the intended user or operational outcome. An experiment may estimate the first filter well and say almost nothing about the fourth. That is not a weakness when the boundary is explicit; it becomes a problem only when a narrow result is marketed as system impact.

Internal measurement should preserve all five units. A bounded task can use time to first draft and test pass rate. A developer can track personal effectiveness, cognitive load, and learning. A team can track time to acceptance, review cycles, rework, and reviewer waiting. The delivery system needs idea-to-production time, change failures, and recovery. Business impact requires the intended outcome itself. If AI produces more open pull requests but no more accepted change, the rollout has still discovered something useful: it exposed the next constraint. The response is to invest in that part of the flow, not to declare universal success or failure.

The same discipline governs how teams are compared. An identical usage share says nothing about task difficulty, the quality of the starting repository, or how available the checks are. Compare each team against its own baseline, then look for constraints that repeat. That way the organization does not reward easy artifacts produced for the metric, and it can see where a shared platform service would genuinely cut waiting, review cost, or release risk. Discuss the result with the team rather than using it as a ranking: measurement exists to find the constraint and choose the next experiment. That keeps trust in the data and stops engineers from optimizing visible activity instead of useful accepted change.

Generation reduces the cost of a first version. It does not remove ambiguity, architectural trade-offs, maintainability review, or integration. Cheap variants can increase the queue facing human reviewers. Local speed becomes system speed only when batch size, specifications, tests, review capacity, and feedback also change.

A team capability starts around the model: explicit intent and acceptance criteria; repository, decision, and dependency context; tests and evals; identity, least privilege, and isolation; traces of action, cost, and outcome. DORA associates better outcomes with internal-platform quality, small batches, data access, and policy. NIST contributes a neutral Govern–Map–Measure–Manage sequence without claiming that the framework itself creates productivity.[S29] [S30]

The specification becomes an executable interface between a person and an agent. It needs desired behavior, prohibitions, representative examples, verification commands, dependency constraints, and an expected result format. Context is not solved by loading the entire repository. A system map, current decisions, owners, contracts, and a way to retrieve detail on demand are more useful. Excess context raises cost and makes signal harder to distinguish; stale context confidently steers the agent toward the wrong system.

Evals must cover several qualities at once. Tests preserve known behavior. Policy checks enforce architectural and security boundaries. Reviewers judge clarity and maintainability. Post-release observation verifies the actual outcome. Combined evidence lets a team widen authority progressively: writing to an isolated branch, invoking a bounded tool set, and later preparing a release. Each additional permission should follow a history of accepted outcomes, not the persuasiveness of the latest demonstration.

Claude Code telemetry suggests expertise is not disappearing; its return is changing. Sessions where a classifier assigns the user high expertise in that specific task trigger longer action chains and more often end in classifier-rated success. This is not job seniority, tenure, or an observed downstream result. Field work also found larger short-term gains among less experienced participants. In another experiment, the AI group scored lower on immediate mastery of a new library. A post-hoc analysis associated heavy AI reliance with low scores, but the authors explicitly do not treat that pattern as causal.[S05] [S07] [S19]

Labor data offers early, not final, signals. In US sponsored LinkedIn postings, AI-literacy requirements rose 71% year over year as of September 2025, with software engineer among the leading affected titles. US Indeed postings show the hiring rebound tilted toward senior and AI-named roles. This is job-text analysis, not a measurement of daily work or evidence that AI caused layoffs. [S16] [S17]

Public role descriptions make the shift concrete. Tailscale sought a Software Engineer, AI Enablement for tooling, safe practice, and education across engineering. ID.me connects quality engineering with shared test infrastructure, CI/CD, progressive delivery, and AI-assisted testing. Microsoft explicitly connects engineering management with agentic workflows, quality gates, and observability. A conventional Amazon DynamoDB senior role instead adds interest in AI-assisted development tools without weakening its core-engineering requirements. These are four illustrative snapshots viewed on August 12, 2026, not a representative sample. [S20] [S21] [S31] [S32]

The composition of strong engineering work changes. The ability to implement remains the basis for verification, but more value moves toward decomposing ambiguous goals, choosing boundaries, preparing a reproducible environment, and explaining why a result is safe to accept. A tech lead gains another audience: the agent. Decisions that live only in a few people's memories become a direct limit on automation. Clear contracts, architecture records, and fast tests reduce cognitive load for humans while improving agent performance.

Engineering leaders need more than licenses and monthly-active-user charts. They need a portfolio of workflows with owners, baseline measures, risk levels, and stop criteria. An enablement team should not become a prompt help desk. Its product is a safe route from an idea to a verified process: reusable environments, a context catalog, gates, eval suites, education, and failure reviews. Domain teams still own the outcome; otherwise the central function becomes a queue detached from real product work.

Headcount alone misleads. Four conditions matter more: greenfield versus brownfield work, blast radius, internal-platform maturity, and decision speed. Regulation is an overlay: a small firm may have a strict data boundary, while a new enterprise unit may operate almost like a startup.

As of the evidence cutoff we found no representative comparison of AI4SDLC depth across startups, scale-ups, midmarket firms, and enterprises. The May–July 2025 public-open-source study reports a higher agentic-PR participation ratio in small projects with one to five contributors, but public project size is not company type. Census simultaneously finds broader reported AI use among larger firms; US Indeed data finds AI postings highly concentrated among the largest hiring firms. The table above is therefore an authorial operating-model synthesis based on system age, blast radius, platform maturity, and decision speed—not a ranking of measured adoption by company size. [S41] [S23] [S24]

Shopify shows another pole: AI use can become an explicit baseline expectation in engineering culture. That establishes a company policy, not a causal outcome. Direct midmarket evidence is weak; its profile here is author synthesis: less capacity for a bespoke platform increases the value of a managed environment and a narrow choice of high-value workflows. [S22]

A startup can rebuild its process around an agent quickly because it has fewer historical conventions and a shorter decision path. That does not remove the need for backups, secret boundaries, dependency checks, and a release owner. Its minimum control layer must be cheap and embedded in the normal development path, or the speed advantage will disappear at the first incident or growth transition.

A scale-up often experiences the hardest transition. Individual tricks still work, but shared context diverges, service count grows, and reviewer capacity does not. It needs a short standard: which work may be delegated, where decisions live, what checks are mandatory, and who owns exceptions. Enterprises can build a rich internal platform but risk designing the universal solution before choosing valuable workflows. Midmarket firms benefit from the opposite order: two or three economically clear flows, a managed environment, and outside help with an explicit knowledge handoff.

One early signal of the shift came from US hiring: in its 2025 snapshot, Indeed reported that management consulting accounted for 12.4% of all GenAI-mentioning postings, up from 0.2% a year earlier, while such postings remained a small fraction of the labour market overall—about three in every thousand. Fresher offering pages show that by August 2026 providers converge on the same vocabulary—strategy, agents, modernization, platform, learning—yet enter through different problems and carry different incentives. Compare the entry point, deliverable, economics, and handoff, not the slideware. [S18]

McKinsey offers a progression from task acceleration to AI-native delivery; it is a useful diagnostic, but its cases lack open counterfactuals. Accenture GenWizard and Capgemini package full-SDLC and modernization accelerators as integration services. AWS embeds specialized agents in professional services while remaining the adviser, platform, and beneficiary of cloud consumption.[S26] [S27] [S28] [S34]

OpenAI Frontier Alliances explicitly separates strategy, global integration, and forward-deployed engineering. Deloitte describes Ascend Agentic SDLC with agents across roles and phases and positions forward-deployed engineering alongside it. BCG X shows a strategy house adding in-house technology build and delivery. These pages establish an offer and its positioning, not independent client impact. [S25] [S33] [S35]

• —Entry: a concrete workflow and baseline, not an abstract “AI strategy.”
• —Outcome: a working loop for context, authority, evals, and accepted-result measurement.
• —Handoff: an internal team that can change rules and vendors without repeating the transformation.
• —Commercial model: provider incentives must not replace the client's outcome measure.

A practical transformation loop starts with a baseline, not a demo. Choose a workflow whose volume, waiting time, rework, and cost of error are understood. Run a bounded pilot on real tasks and define acceptance and stop criteria in advance. Early failures then produce gates, education, and data owners. Only after that does the use case enter a shared platform path and expand to adjacent teams. On every cycle, the scorecard returns to accepted outcomes, system flow, quality, total cost, and organizational learning.

The ownership boundary prevents acceleration from becoming lock-in. Frontier models and a generic agent loop are sensible to rent: they change quickly and reward provider scale. Context packaging, routing, and workflow integration must be adapted. Identity, policy, eval suites, accepted outcomes, and the exit plan should remain internal because they encode unique knowledge and authority. A consultant can build the first versions, but the engagement must name the internal owner, documentation, training, and a path to change models without rediscovering the production process.

As of August 13, 2026, three conclusions are robust. Code completion, search, and working with an AI assistant in chat are now routine for many individual tasks. Agentic delegation is spreading quickly, but usually remains bounded, single-agent, and human-reviewed. Autonomous release, long-lived operations, and broadly privileged multi-agent organizations remain horizons because the ability to produce change has advanced faster than the ability to prove usefulness and safety.

Future episodes should not return to generated-code share or a single benchmark. Ask five stable questions instead: what outcome was accepted; whether whole-system flow changed; what happened to quality and risk; the total cost of the accepted task; and what people and the organization learned. Then a model update will not erase the comparison.

Horizon claims are especially easy to confuse with operating practice. A long-lived agent must survive context turnover, tool failures, dependency updates, and state handoff. A multi-agent workflow adds coordination, conflicting decisions, and complicated provenance. Autonomous operations require more than recognizing a symptom: the system must estimate blast radius, choose a reversible action, observe the outcome, and stop. Demonstrations prove pieces of this chain, but they do not yet justify broad authority as a general engineering default.

The next baseline should record movement in the boundary. Has the draft pull request become a team standard? Which actions moved from per-step approval to outcome review? Is there reproducible evidence about maintainability and release? Did human load decline or merely change shape? Can the company still develop engineers and switch providers? These questions age more slowly than product names and reveal both progress and newly displaced constraints.

Organizational maturity has another signal: disagreement no longer depends on anecdotes. A team can show where the agent helps, where it adds rework, which permissions it holds and why, how different experience levels fare, and what happened to the cost and time of accepted work. Leadership then decides not whether to adopt AI at all, but which control loop to improve next and what evidence is required to expand authority. That framing leaves room for different speeds: a new team can experiment more deeply, a critical system can move more carefully, and a shared platform can collect the data that lowers the price of a safe step for both. What matters is keeping one comparison language — accepted outcome, system flow, quality, total cost, and learning. Local differences then stop hiding the overall direction, and a displaced bottleneck becomes visible in time. That turns the baseline into a working management instrument rather than a one-off market review.