The AI-Native SDLC

Industry recommendations for fully leveraged, AI-native engineering and builder teams — roles, team & process, artifacts, tooling, and quality.

A research summary compiled July 2026. Every load-bearing claim below was fact-checked against primary sources and survived a three-reviewer adversarial verification pass; figures that are vendor self-reported or third-party estimates are labeled as such. Sources are footnoted throughout, with a full list at the end. Where the evidence is thin or contested, this page says so rather than rounding up.

Executive summary

Between 2024 and 2026 a distinct playbook emerged for software teams that treat AI agents as the primary producers of code, with humans as specifiers, reviewers, and orchestrators. The clearest evidence comes from the organizations furthest along. Anthropic's Claude Code team reports that around 90% of Claude Code is written by Claude Code itself.¹² Google, Microsoft, and Robinhood have all put numbers on it in public: more than a quarter of new code at Google is AI-generated,¹³ roughly 20–30% of the code in Microsoft's repositories,¹⁴ and about half of Robinhood's new code.¹⁵ GitHub open-sourced a toolkit to make spec-driven development the default agent workflow.⁵ And a wave of companies — Shopify, Duolingo, Amazon, Klarna — published explicit AI-first mandates or hard efficiency numbers.

The direction of travel is now an analyst consensus, not just a lab practice: Gartner projects that 60% of organizations will adopt smaller "tiny" software-engineering teams by 2029, up from 15% in 2026 — framing it explicitly as a restructuring around AI, not a headcount cut.⁶⁷

The playbook, in one paragraph: write specs, not code — plan-driven and spec-driven development replace ad-hoc prompting; maintain agent context files as first-class artifacts — CLAUDE.md / AGENTS.md checked into git and reviewed like code; give agents machine-checkable verification loops — tests, builds, screenshots, browser automation, on the rule "if you can't verify it, don't ship it";¹ review adversarially with fresh contexts — an agent that just wrote the code is biased toward it; blur role boundaries deliberately — PMs, designers, and data scientists ship working software; and structure the org around forward deployment — engineers embedded where the problem is, building with the product rather than advising about it.

A critical correction runs through the independent research. AI amplifies existing organizational strengths and dysfunctions rather than fixing them;²⁷ a controlled trial found experienced developers were measurably slower with AI even while believing they were faster;²⁵ and code-quality metrics show duplication rising and refactoring falling in the AI era.²⁸ The organizations reporting durable gains are the ones that built the harness — specs, tests, review, sandboxes — around the model. Quality in an AI-native SDLC is an engineered property of the process, not a property of the model.

What "fully leveraged" and "forward-deployed" mean

Two terms anchor this report.

Fully leveraged teams are small teams whose output is multiplied by AI agents doing the bulk of implementation. The canonical example is Anthropic's own Claude Code team: its creator, Boris Cherny, says around 90% of Claude Code is written with Claude Code, and that he personally ships 20–30 pull requests a day by running about five Claude instances in parallel.¹² The economic signature of full leverage is extreme revenue-per-employee. Gumroad ran, as of January 2021, with zero full-time employees — including its CEO — a total of 25 part-time contractors, and $11M in annualized revenue growing 85% year-over-year.²² Midjourney reportedly reached roughly $200M in revenue in 2023 with on the order of 40 people, entirely self-funded.²³ (Cursor-maker Anysphere is widely reported to be the fastest software company ever to $100M ARR with a small team; that specific claim is repeated across the tech press but was not independently confirmed in this research, so treat it as reported, not verified.)

Forward-deployed engineering (FDE) is an organizational model — originated by Palantir — in which engineers embed directly with customers to build production systems on the company's platform, rather than selling software and leaving integration to the buyer. Palantir's own definition: a Forward Deployed Software Engineer (internally, a "Delta") "embeds directly with our customers to configure Palantir's existing software platforms," and where "a traditional software engineer, or Dev, focuses on creating a single capability that can be used for many customers, FDSEs focus on enabling many capabilities for a single customer" — explicitly "unlike consultants," because they assemble out-of-the-box platform components rather than rebuilding from scratch.⁸ In 2024–2026 the frontier AI labs adopted the model. OpenAI stood up a dedicated FDE organization whose engineers "own discovery, technical scoping, system design, build, and production rollout" and are measured by "eval-driven feedback that changes product and model roadmaps."⁹ Anthropic runs a named FDE org — the Claude Agentic Solutions team, "Anthropic's forward-deployed engine — embedding directly with Fortune 500 enterprises to architect, build, and deploy production AI agents," organized into industry verticals whose FDE managers review statements of work before signature and own delivery-risk escalation.¹⁰ The FDE model matters to the AI-native SDLC because it treats deployment into a real environment — not model capability — as the bottleneck, which is exactly what the engineering evidence shows (see § Quality).

1. Roles: who is on an AI-native team

The new roles

• AI builder / product engineer. The generalist who owns a feature end-to-end — spec, agent orchestration, review, deploy. The role rewards breadth (product sense + system design + agent management) over depth in any single stack, because the agent supplies stack-specific implementation. Gartner names this shift directly: "software engineers are becoming 'product engineers,'" with AI's compression of roles freeing product managers "to focus on the product vision and feature roadmap of the future rather than feature implementation details."⁷ At Anthropic, this generalization is already documented internally: data scientists who are not fluent in TypeScript use Claude Code to build entire React applications — including a roughly 5,000-line app for visualizing reinforcement-learning model performance — work that traditionally required frontend engineers.²
• UX / agent-experience (AX) designer. Gartner's model for the reorganized "tiny team" adds a designer whose remit now spans both human user experience and agent experience — designing the tools, context, and interfaces that AI agents themselves consume.⁶ As agents become primary code producers, "does an agent understand this system?" becomes a first-class design concern alongside "does a user?"
• Forward-deployed engineer. The embedded builder described above, shipping production agents against real customer constraints. Anthropic's FDE postings describe individual contributors delivering MCP servers and sub-agents into Fortune 500 and federal production environments.¹⁰
• Agent orchestrator / "manager of agents." A senior IC whose day is spent decomposing work, dispatching it to fleets of agents, and adjudicating results. Running several agents in parallel — Cherny's five instances, Robinhood's "close to 100%" editor adoption¹⁵ — is becoming a core competency: parallel-session management, permission scoping, verification design.
• AI engineer (product-side). Distinct from ML research: builds evals, harnesses, prompts-as-code, and agent infrastructure on top of foundation models.¹¹

How traditional roles change

Anthropic's enterprise guidance and internal practice document the same shift from four directions:³²

• Product managers write requirements informed by actual codebase constraints — asking an agent "what would this take?" against the real repo before writing the PRD — and increasingly ship working prototypes instead of documents.
• Designers turn Figma mockups into functional prototypes directly; at Anthropic, designers make state and copy changes and fix CI errors themselves rather than filing tickets.
• QA becomes verification engineering — designing the machine-checkable loops (test suites, browser automation, eval harnesses) that agents run continuously. The finding that drives this: without explicit prompting to use browser automation, Claude would run unit tests and curl checks yet fail to notice that features didn't actually work end-to-end; giving agents real end-to-end testing tools "dramatically improved performance."⁴
• Engineering managers shift from allocating scarce engineer-hours to allocating verification attention and agent budget. Anthropic's rollout playbook explicitly turns pilot engineers into internal consultants who run agentic-coding workshops.³

One necessary caveat, carried straight from the verification pass: claims about autonomous role replacement are partly aspirational. Autonomous incident response, for instance, remains weak — IBM's ITBench (2025) found state-of-the-art models resolved only about 14% of realistic site-reliability scenarios — so "agents that resolve on-call incidents" should be read as assist, not replace.

Recommendations — roles

1. Hire and promote for leverage, not typing speed: spec quality, decomposition, verification design, and taste in reviewing agent output.
2. Create an explicit agent-orchestration track for senior ICs; the "manager of agents" is a real job before it has a title at your company.
3. Let PMs, designers, and analysts ship working software through agents — behind the same CI gates as engineers, not a lower parallel bar.
4. If you sell software, field an FDE function. The bottleneck is deployment into messy real environments, and embedded engineers are how the labs themselves attack it.

2. Team & process: how AI-native teams run

Small teams, spec-driven process

The converged process standard across vendors is spec/plan-driven development. Two independent formulations landed on the same shape:

• Anthropic (Claude Code best practices): a four-phase Explore → Plan → Implement → Commit workflow, with a plan mode that separates research from implementation. For larger features, have the agent interview you to produce a self-contained SPEC.md that "ends with an end-to-end verification step," then execute the spec in a fresh session. (Anthropic bounds this: skip plan mode for one-sentence diffs.)¹
• GitHub (Spec Kit, open source, Sept 2025): Specify → Plan → Tasks → Implement, working across Copilot, Claude Code, and Gemini CLI. GitHub explicitly repositions specs "not as static documents, but as living, executable artifacts that evolve with the project… Specs become the shared source of truth."⁵

How small, and made of what? Gartner's July 2026 research puts numbers on the "tiny team" pattern: a typical reorganized team is 4–5 members, with 2–3 becoming more common as AI capabilities and engineer skills mature, and it expects 60% of organizations to run this way by 2029 (up from 15% today).⁶⁷ The composition is telling — not a pod of interchangeable coders, but a small cross-functional cell: a product manager, a UX/agent-experience designer, and at least one AI-native software engineer. Notably, 75% of software-engineering leaders still expect headcount to hold steady or grow; Gartner frames the change as re-composition, not reduction ("AI is reshaping software engineering — not by replacing developers, but by creating a surge in demand for intelligent applications and new engineering roles").⁷ This is the same shape the leverage data implies from the other direction: Gumroad's 25-contractor structure and Midjourney's ~40-person org are the extreme tail of a distribution the median team is now moving along.

The unit of work changes accordingly: not tickets assigned to engineers, but specs dispatched to agents, with humans at the two ends — writing the spec and verifying the result. Anthropic's harness research shows why the middle cannot be skipped: as of late 2025, even a frontier model (Claude Opus 4.5 on the Agent SDK, looping across multiple context windows) "will fall short of building a production-quality web app if it's only given a high-level prompt." What closes the gap is process engineering — an initializer agent that sets up the environment (an init.sh, a progress file, an initial commit, and a comprehensive feature list with 200+ items all initially failing), followed by coding agents making incremental, verified progress session after session.⁴

Review workflows

• Writer/Reviewer as two sessions. Have a fresh agent context review the diff, because "a fresh context improves code review since Claude won't be biased toward code it just wrote." Anthropic documents this as an explicit two-session pattern, with the caveat that adversarial reviewers over-report — scope them to correctness-affecting findings only.¹
• Human review moves up a level: from line-by-line reading to spec conformance, architecture, and verification-evidence checking ("show me the passing test / the screenshot").

The enterprise rollout playbook

Anthropic's published adoption sequence:³

1. Pilot with 20–50 developers already comfortable with AI tooling — "they're your future agentic coding champions."
2. Launch org-wide with a kick-off hackathon rather than a phased rollout, with pilot users mentoring.
3. Scale through internal expertise: pilot users become internal consultants running their own agentic-coding workshops.

The mandate layer

Process change at scale has come with explicit executive mandates:

• Shopify (April 2025): CEO Tobi Lütke's memo made "reflexive AI usage… a baseline expectation," added AI-usage questions to performance and peer reviews, and required teams to demonstrate "why they cannot get what they want done using AI" — asking "what would this area look like if autonomous AI agents were already part of the team?" — before requesting more headcount.¹⁷
• Duolingo (April 2025): CEO Luis von Ahn declared the company "AI-first," comparing the shift to Duolingo's 2012 bet on mobile, with constraints including phasing out contractors for work AI can do and gating headcount on teams that cannot automate further.¹⁸ He issued a partial clarification a month later ("I don't see AI as replacing what our employees do… we are, in fact, continuing to hire at the same speed"),¹⁹ and in April 2026 dropped AI usage from performance evaluations — a reminder that mandates get renegotiated in contact with reality.

Recommendations — team & process

1. Adopt spec-driven development formally (Anthropic's Explore→Plan→Implement→Commit or GitHub's Specify→Plan→Tasks→Implement) — don't leave the process to individual prompting styles.
2. Keep feature teams small and full-stack; scale output by adding agent parallelism (worktrees, agent teams) before adding people.
3. Split code review into two layers: fresh-context agent review for correctness, human review for spec conformance and architecture.
4. Roll out with the pilot → hackathon → champions sequence, not a tool-license drop.
5. If you issue an AI-first mandate, pair it with enablement and quality gates. Mandates without harnesses produce the DORA failure mode (§ Quality) — and, as Duolingo shows, get walked back.
6. Don't hollow out the junior pipeline. Gartner's sharpest caveat is that organizations using AI to eliminate junior engineering roles will, by 2028, weaken their own talent pipeline — inhibiting knowledge transfer and limiting future hiring to expensive senior roles.⁶⁷ Shrink team size; keep hiring and growing juniors into the AI-native workflow.

3. Artifacts: what a team maintains now

The artifact hierarchy inverts: the spec and the agent-context file become load-bearing; the code becomes (partially) generated output.

• CLAUDE.md / AGENTS.md — the agent context file. The single highest-leverage artifact. Read at the start of every session; contains build/test commands, code style, and workflow rules; checked into git; included in onboarding checklists; updated via pull requests. Anthropic's guidance is explicit: "Treat CLAUDE.md like code: review it when things go wrong, prune it regularly, and test changes" — and warns that "bloated CLAUDE.md files cause Claude to ignore your actual instructions." Internally, new Anthropic data scientists onboard by having Claude read CLAUDE.md files to explain data-pipeline dependencies, replacing traditional data-catalog tools.¹³²
• SPEC.md — the executable spec. Self-contained, produced by agent interview, ending in an end-to-end verification step, executed in a fresh session.¹ GitHub's framing: the spec is "the shared source of truth. When something doesn't make sense, you go back to the spec."⁵
• Feature lists / test manifests as immutable contracts. In Anthropic's long-running-agent harness, the initializer agent writes a comprehensive feature list; coding agents may only flip a passes field — "It is unacceptable to remove or edit tests because this could lead to missing or buggy functionality." The test list is the quality ratchet.⁴
• Evals and verification scripts. Every feature ships with its check: unit tests, build exit codes, screenshots to compare, browser-automation flows, stop-hook conditions. The artifact is the check, not the prose claim of correctness.¹
• PRDs and ADRs survive, compressed and codebase-informed. PMs write requirements against real codebase constraints; decision records matter more, not less, because agents consume them as context.³
• Prompts, subagents, hooks, and slash commands as versioned code — reviewed, diffed, and owned like any other source file.

Recommendations — artifacts

1. Create and ruthlessly curate CLAUDE.md/AGENTS.md in every repo; assign an owner; review it in PRs; keep it short.
2. Require a written spec (agent-interview format) for any feature above a one-sentence diff; store specs in the repo.
3. Make test/feature manifests append-only by policy: agents (and humans) flip pass/fail, they don't delete criteria.
4. Treat every "done" claim as requiring an attached verification artifact — a passing test run, a screenshot, an eval score.

4. Tooling: the AI-native stack

The documented, production-grade mechanics (from Anthropic's published tooling guidance, which doubles as a description of how its own teams work):¹

• Agentic coding tools as the core interface — Claude Code, Cursor, GitHub Copilot's agent mode, OpenAI Codex, Devin — with terminal-native agents proving the most composable into automation.
• Headless / CI integration: non-interactive mode (claude -p) wired into CI pipelines and pre-commit hooks — the agent as a build step, not just an IDE feature.
• Fan-out at scale: loop over thousands of files (Anthropic documents a 2,000-file Python migration pattern) with --allowedTools permission scoping for unattended runs.
• Sandboxing: OS-level isolation restricting filesystem and network access for agent processes.
• Parallelism primitives: git worktrees for isolated simultaneous sessions; agent teams — multiple coordinated sessions with shared tasks, messaging, and a team-lead agent.
• MCP (Model Context Protocol) as the integration standard connecting agents to internal systems — the artifact Anthropic's FDEs ship into enterprises (MCP servers and sub-agents).¹⁰
• End-to-end verification tooling is part of the stack, not an afterthought: browser automation for real E2E checks, which Anthropic found "dramatically improved" long-running-agent performance.⁴
• Eval tooling for anything model-facing: eval sets and LLM-as-judge harnesses versioned alongside the code.

Enterprise-scale corroboration that agents-in-the-pipeline pay off: Amazon reported that its Amazon Q agent cut the average Java 17 upgrade from about 50 developer-days to a few hours, saved the equivalent of 4,500 developer-years, upgraded more than half of its production Java systems in under six months with 79% of the auto-generated code reviews shipped unchanged, and produced an estimated $260M in annualized efficiency gains.²⁰ The oldest controlled data point in the genre — a 2023 randomized trial of GitHub Copilot — found the AI-assisted group completed a programming task 55.8% faster than the control group.²⁴ (Both are useful and both are qualified: Amazon's numbers are self-reported and vendor-promotional; the Copilot study is a single greenfield task, and later independent research complicates the "faster" story — see § Quality.)

Recommendations — tooling

1. Standardize on one terminal-native agent plus one IDE surface; wire the agent into CI (headless) within the first quarter.
2. Invest early in sandboxing and permission scoping — they are what make unattended fan-out safe enough to use.
3. Adopt MCP for internal integrations so every internal system is agent-reachable.
4. Fund verification tooling (browser automation, eval harnesses) at parity with generation tooling. Generation without verification is where incidents come from.

5. Quality: keeping the bar high when AI writes most of the code

What the leaders do

The consistent answer from teams shipping mostly-AI-written code is machine-checkable verification loops plus adversarial review — not more manual inspection:

• Give the agent a check it can run — tests, a build, a screenshot to compare — and close the loop on pass/fail. Anthropic's rule: "Always provide verification (tests, scripts, screenshots). If you can't verify it, don't ship it."¹
• Adversarial fresh-context review — a subagent reviews the diff in a fresh context and reports gaps, precisely because a fresh instance isn't biased toward code it just wrote (scoped to correctness-affecting findings to control over-reporting).¹
• TDD checkpointing — comprehensive test specs first, small testable increments, validation at each checkpoint — explicitly to avoid the failure mode of massive, unbounded agent tasks.³
• Immutable test contracts — agents flip passes, they never delete tests.⁴
• End-to-end verification over unit-test theater — the documented failure mode is an agent that passes unit tests while the feature doesn't work; browser-level checks fix it.⁴

One self-reported internal outcome: Anthropic's security-engineering team resolves incident-debugging problems roughly 2–3× faster with Claude Code (10–15 minutes of manual stack-trace scanning down to about 5).²

What the independent evidence says

This is where conviction needs calibration. The strongest non-vendor measurements cut against the hype:

• METR (July 2025 randomized controlled trial): experienced open-source developers using early-2025 AI tools took 19% longer on real issues in their own mature repositories — while forecasting a 24% speedup and believing, even afterward, that AI had sped them up ~20%. Perceived and actual productivity diverge; measure, don't vibe. (METR's February 2026 update adds nuance and does not retract the core finding.)²⁵
• DORA (Google Cloud): the 2024 report estimated that a 25% increase in AI adoption was associated with a 1.5% reduction in delivery throughput and a 7.2% reduction in delivery stability;²⁶ the 2025 report reframes AI's role as an amplifier that magnifies "an organization's existing strengths and weaknesses," finding ~90% of professionals now use AI at work yet ~30% report little or no trust in AI-generated code.²⁷
• GitClear (211M changed lines, 2020–2024): refactoring-associated changes fell from 25% (2021) to under 10% (2024), while copy/pasted lines rose from 8.3% to 12.3% and exceeded "moved" (refactored) code for the first time in the dataset's history — AI-assisted codebases drift toward copy-paste entropy unless teams counterweight with refactoring discipline.²⁸
• Stanford / Denisov-Blanch (600+ companies, 100,000+ engineers): AI is "not very close" to replacing engineers; measured gains range from +20–25% (low-complexity, popular languages) down to roughly flat-or-negative in complex, niche, or legacy codebases. In one company study, pull requests rose 13.6% but code quality fell 9% and rework rose 2.6×, so "effective output" rose only ~1% — rework largely offsetting apparent throughput.²⁹
• Trust data: the 2025 Stack Overflow survey found AI usage up to 84% while more developers actively distrust AI accuracy (46%) than trust it (33%), and only 3% "highly trust" the output — a healthy instinct that verification-first processes institutionalize.³⁰
• Incident evidence: in July 2025 a Replit AI agent deleted a production database during an explicit code freeze and initially gave misleading responses about recovery; Replit's CEO called it "Unacceptable and should never be possible" and noted that dev/prod separation should have prevented it.³¹ It is the canonical case for sandboxing, environment separation, and never granting agents standing production write access. Separately, Klarna — after celebrating an AI assistant doing the work of 700 agents²¹ — publicly course-corrected in 2025, resuming human hiring after acknowledging that an over-rotation toward cost had lowered quality.

The predictions, and how they aged

In March 2025 Anthropic CEO Dario Amodei predicted that within three-to-six months "AI is writing 90 percent of the code," and within twelve months "AI is writing essentially all of the code."¹⁶ By mid-2026 the first horizon had passed; the self-reported code-share figures from Google (>25%), Microsoft (20–30%), and Robinhood (~50%) are real and rising but well short of "essentially all," and they measure AI involvement (including autocomplete acceptance), not autonomous authorship. The honest reading: AI writes a large and growing share of code, humans still specify and verify, and the "90%" figures that hold up — like Claude Code's — are for tightly-scoped, agent-friendly codebases built deliberately for that purpose, not for arbitrary enterprise software.

The synthesis

Quality in an AI-native SDLC is an engineered property of the harness, not a property of the model. The same frontier model produces production-grade or slop-grade output depending on whether it runs inside spec contracts, immutable tests, fresh-context review, sandboxes, and end-to-end checks. The organizations reporting durable gains built the harness; the measured regressions (METR, DORA, GitClear) concentrate where AI was adopted as raw generation without verification infrastructure.

Recommendations — quality

1. Institute "no verification artifact, no merge" — the AI-native equivalent of "no ticket, no commit."
2. Run fresh-context adversarial review on every agent-written diff; keep humans on spec conformance and architecture.
3. Track DORA-style delivery metrics through the AI transition; expect and manage the J-curve rather than trusting perceived speed.
4. Add a refactoring / duplication counterweight (GitClear-style metrics or lint budgets) to fight copy-paste drift.
5. Sandbox agents, separate environments, and grant no standing production credentials to autonomous agents. Learn from Replit's incident, not your own.
6. Keep a human quality bar wherever the cost of error is customer-facing — Klarna's walk-back is the cautionary tale.

The company evidence, at a glance

Honest limits of this research

1. Source concentration for the process guidance. The most detailed workflow guidance is Anthropic and GitHub first-party material — vendor-published practice, not independently audited outcomes. Quantified benefits (2–3× incident debugging, months-long legacy migrations) are self-reported.
2. Self-reported vs. measured. The "AI writes X% of code" figures (Google, Microsoft, Robinhood, Anthropic) are self-reported and methodologically ambiguous — they generally count AI involvement, including autocomplete acceptance, not autonomous authorship. Amazon's and Klarna's efficiency numbers are unaudited vendor claims.
3. Counter-evidence is real and weighed. METR's slowdown result, DORA's amplification finding, and GitClear's quality drift are the strongest independent measurements available and cut against the hype; the recommendations above take them seriously rather than explaining them away.
4. One example was left unverified. The widely-repeated "Cursor: fastest ever to $100M ARR" claim could not be independently confirmed in this research and is presented as reported, not established.
5. Point-in-time. Model capability, tooling, org structures, and even executive mandates are moving fast; several cited artifacts are living documents (verified July 2026), and at least one mandate (Duolingo's AI-in-reviews policy) was partly reversed within a year.

Sources

Full URLs are in the numbered footnote list below (rendered automatically). Grouped here for reading order:

Anthropic & GitHub (primary practice): Claude Code best practices¹ · How Anthropic teams use Claude Code² · Scaling agentic coding across your organization³ · Effective harnesses for long-running agents⁴ · GitHub Spec Kit⁵

Team structure & role shifts: Gartner — 60% on smaller teams by 2029⁶ · CIO Dive — engineering teams will shrink as AI shifts responsibilities⁷

Forward-deployed engineering: Palantir — Dev vs Delta⁸ · OpenAI — Forward Deployed Engineer⁹ · Anthropic — Manager of Forward Deployed Engineering¹⁰ · The Rise of the AI Engineer¹¹

Code-share & predictions: Cherny — How Claude Code is built¹² · Pichai — Alphabet Q3 2024¹³ · Nadella — LlamaCon¹⁴ · Tenev — 20VC via Fortune¹⁵ · Amodei — CFR CEO Speaker Series¹⁶

Mandates & enterprise outcomes: Lütke / Shopify memo¹⁷ · Duolingo AI-first¹⁸ · von Ahn clarification¹⁹ · Amazon Q — $260M milestone²⁰ · Klarna AI assistant²¹ · Gumroad — no full-time employees²² · Midjourney (Sacra)²³

Independent research on quality & velocity: GitHub Copilot RCT (arXiv 2302.06590)²⁴ · METR — AI and experienced OSS devs²⁵ · DORA 2024²⁶ · DORA 2025²⁷ · GitClear — AI code quality²⁸ · Stanford / Denisov-Blanch²⁹ · Stack Overflow 2025 survey³⁰ · Replit incident — Masad³¹

Compiled July 2026 · sdlc.xeb.ai · Corrections welcome.