AI as Primary Author

Sources#

• AI Engineering Report 2026: The Acceleration Whiplash
• Characterizing the Quality Profile of AI-Generated C++ in Production
• The State of AI Impact in Engineering: Q2 2026

Summary#

Faros AI's framing of the structural shift its 2026 telemetry documents: AI has crossed from assistant to author — "without a deliberate decision by most organizations." The marker is acceptance rate: the share of AI-generated code accepted into codebases rose from 20% to 60% (Faros's two datasets), driven substantially by Cursor and Claude Code running in agent mode where the agent applies changes directly. "The distinction between assistant and author has collapsed in practice. Not an assistant. The author."

vendor-claim source — see Acceleration Whiplash for the evidence caveat. The 60% figure is the load-bearing number and is attributed to Faros's platform telemetry.

The threshold, not the slope#

What makes this a concept rather than a metric is that the transition happened silently and structurally. The original promise was "the human is in charge, the AI suggests, the human decides." As models improved and vendor ambitions grew, "co-pilots became peers," and acceptance crept past the point where the human is meaningfully authoring. No org convened to decide "AI should write most of our code"; utilization simply rose (licenses were already bought — what changed was usage, not seats), and one day 60% of accepted code had an AI author. The shift is in who/what does the work, with humans "increasingly in a review and oversight role rather than a creation role."

This is the same role-inversion Fiona Fung describes from inside Anthropic and Karpathy frames as agentic engineering — but Faros supplies the population-level number for how far it has gone in the broader industry, and frames it as a problem rather than a capability.

"An authoring problem, not a review problem"#

The report's sharpest consequence. Because AI is the author, the quality gap originates at generation and cannot be closed at review:

"The quality gap is not being caught at the point of review… To be clear, the problem is not who is reviewing the code. It is that the code arriving for review was never ready. This is an authoring problem, not a review problem."

This reframes the entire remediation strategy (see Acceleration Whiplash): adding reviewers or tightening gates treats a symptom. The fix is to raise the quality of what the author produces — equip the AI author with codebase standards, architectural intent, security constraints, and testing requirements before it writes, so its output is closer to shippable from the start. It is the authorship analog of shift-left: shift the quality investment all the way left, into the act of authoring itself.

The authorship/responsibility gap#

Authorship moved to the AI; accountability did not. "You're still responsible for your software" (Karpathy), yet the entity producing 60% of the code cannot be held responsible, carries no persistent memory of intent, and infers architecture from "a point in time" rather than from how the codebase evolved. The result is the compounding-debt mechanism at industrial scale: an author that re-derives intent every session. Faros's rec #10 — a "context engine" supplying intent-from-history — is an attempt to give the AI author the thing a human author carries implicitly.

The boundary: authoring vs. agentic authoring#

Faros draws a sharp line. AI is the primary author with a human still in the loop — but agentic authoring (the agent independently writes, commits, and submits a PR with no human initiation) is still <1% of PRs. Faros treats that <1% as "for now, a good thing," warning that removing the human entirely would multiply every quality pressure "an order of magnitude." So "primary author" here means humans accept most AI-written code, not agents ship unsupervised. Meanwhile agentic review has gone 0%→25% of PRs — the oversight layer is automating faster than the authoring layer is going autonomous.

The number, measured non-vendor at production scale (2026-08)#

The 60% figure above is Faros's platform telemetry across customers. Tran et al. (Google, arXiv 2608.06640) supplies the same shift from inside one enterprise, empirical, measured by authoring-time byte-level provenance rather than by acceptance events — the strongest instrument in the corpus for this question, because it avoids the post-hoc-attribution problem entirely (AI-code detectors "generalize poorly across models and settings"; the provenance is a recorded property of the authoring session).

Over 3.52M submitted changes from April 2025 to April 2026:

• AI-generated share of submitted code across major languages: 28.99% to 68.62% (April 2025 to March 2026).
• C++ majority-AI changes: 27.65% to 59.69%, while majority-human changes fell 72.10% to 40.04% — the crossover happens inside the window.
• The overall C++ monthly share runs 28.56% to 62.80%; adoption is uneven by org, reaching 70.19% in Machine Learning & AI and 67.45% in Consumer Products/Apps/Devices, with some slices plateauing after initial uptake.

Two things this adds beyond corroborating the level. First, the RQ1 summary's own caveat: developers "substantially filter generated text before it reaches submitted-code analysis," so even a 68.62% provenance share is a measure of what survived the human, which is the closest thing the corpus has to a principled reading of what "acceptance" means (this page's first open question).

Second, and the more consequential: the interaction-mode mix inverts across the window. Read off Figure 3's stacked-area panel — approximate, plus or minus roughly 3pp, since no numeric mode shares appear in the paper's prose — agentic editing goes from roughly 4% of attributed bytes to roughly 55%, while inline completion falls from ~28% to ~13% and pasted/smart-paste code from ~54% to ~20%. Manual typing sits near 7% for the whole window.

Hold that against this page's boundary section carefully, because the constructs differ and it is easy to read a contradiction that is not there. Faros's "<1% of PRs" counts agentic authoring — the agent independently initiating, committing and submitting a PR with no human trigger. Google's "agentic workflows" category pools conversational generation, transformation-based editing, automated test generation and AI-driven refactoring, all human-initiated. So the two are compatible: the human still starts and submits nearly every change, while the mode by which bytes get written has moved from suggestion-and-accept to instruct-and-review inside a single year. That is the assistant-to-author threshold crossing a second time, one layer down, and it is the layer where "acceptance" stops being a discrete event a developer can be said to perform.

The third instrument: what developers say the share is (2026-08)#

DX's Q2 2026 readout (vendor-claim, 500+ customer organizations) supplies the same quantity from the one instrument the vault did not yet have on it: self-report. Its headline is that over 50% of code is now AI-generated, rising from 34% in Q1 2026 to 52% in Q2 2026 — an 18-point move in a single quarter.

Instrument	Construct	Series
Faros (vendor-claim)	acceptance events on a metrics platform	20% to 60%
Tran et al. (empirical)	authoring-time byte-level provenance	28.99% to 68.62% (Apr 2025 - Mar 2026)
DX (vendor-claim)	self-reported share	34% to 52% (Q1 - Q2 2026)

The ordering is the finding. For the overlapping period the self-reported figure is the lowest of the three — 52% in Q2 2026 against a provenance measurement of 68.62% by March 2026. Populations differ enough (a cross-industry customer panel against one C++ monorepo) that this is not a clean instrument comparison, but the direction is worth recording because it is the opposite of the naive worry about a vendor's survey number. Self-report under-states here, which is what Kalff & Simbeck's construct collapse predicts: people count what they recognize as AI, and the modes that grew fastest over this window — agent-applied edits the developer steered, in-line completions accepted without ceremony — are precisely the ones least likely to be counted as "code the AI generated."

The vault therefore holds three numbers for one shift, none of which measures the same object, and the gap between the highest and lowest is roughly 17 points at the same moment in time. DX publishes no methodology for its figure (the report is gated), so who was asked, how, and over what unit is unknown.

Connections#

• Acceleration Whiplash — the downstream consequence: an AI author at 60% acceptance is what floods the human-paced system

• Vibe Coding vs. Agentic Engineering — Karpathy's "you're still responsible for your software" is the responsibility half of the authorship/accountability gap

• Verification as the New Bottleneck — humans-as-reviewers-not-creators is exactly the bottleneck shift Fiona Fung names; Faros adds "but you can't fix authoring at the review stage"

• Agentic Technical Debt — an author with no persistent intent re-derives architecture each session; the "context engine" is the org-scale CLAUDE.md

• Software 3.0 — programming-in-English is the paradigm in which an AI can be the author at all

• Claude Code — agent mode (apply-changes-directly) is named as a primary driver of the 20%→60% acceptance jump

• Printing Press Software Democratization — authorship moving to the machine is the supply-side of the same democratization

• Compute Allocator — if the human is no longer the author, their residual role is deciding what the author should spend effort on

• Planning / Execution Division of Labor — the apparent contradiction, resolved: Faros's 60% line-authorship and Anthropic's ~70% human planning-decision share measure different layers — Claude writes most lines (execution) while humans still own most planning. "Without a deliberate decision" and "humans still decide what to build" are both true

• Agentic Coding Work-Composition Shift — more end-to-end agentic use (operate/analyze/write) is the usage-side of authorship moving toward the agent; the work shifts as the author does

• Conversation-to-Delegation Shift — delegated production is authorship moving to the agent; Codex's output-token share (16.5% / 63.3% / 99.8%) is how far that move has gone across populations

• Conversation Artifacts — the artifact is authorship moving to the model made measurable per conversation; the reading-level lift (Claude answers ~1 education-year above the prompt) is one gauge of how much of the output is the model's

• Security Debt of Agent-Generated Code — the authorship shift measured on a security axis, with a twist that complicates the framing: inside agent-authored PRs the human collaborator still committed 67.6% of the genuine leaked credentials, so "the agent is the author" does not make the agent the source of the worst-severity artifact

• The Solo-Authorship Rebound — the same authorship shift in science, with the visibility inverted. Here it is measurable (acceptance rates, PR provenance); there it is invisible by construction, and Matsui's Implication 1 is why: contribution statements and collaboration networks were the two instruments for inferring who did what, and for a solo paper whose execution work an LLM supplied, "the contributing agent appears in neither the author list nor the collaboration network." The credit gap moves from unlisted humans to machines that cannot be listed at all — and the solo author, like the accepting engineer, signs for everything

• Efficiency Debt of AI-Generated Code — the non-vendor, provenance-measured version of this page's number (28.99%→68.62% across languages), plus the mode-mix inversion above and the downstream cost of the authorship shift: ~5% relative compute and ~8% relative memory overhead in AI-heavy production functions

• Agent Review Comment Resolution — the oversight layer this page notes is automating faster than authoring (agentic review 0% to 25% of PRs against agentic authoring under 1%), measured on its own terms: 54,713 agent-generated review comments, roughly seven in ten resolved. It is the first population-level reading of whether the machine half of oversight produces anything humans act on — and a reminder that as authorship moves to the agent, so does the reviewing, in a loop where neither side's participant is the one accountable for the result

• Review as the Control Point — the drivers of that theory are this authorship shift seen as inputs to review: volume/velocity, surface plausibility, and code opacity (lost intent). Its "is the developer who invoked the agent an independent reviewer or the author reviewing their own work?" ambiguity — which flips the sign of the independent-review trend — is the review-side of this page's "what does acceptance mean when the agent applies the change directly?"

• Post-Acceptance Edit Behavior — acceptance measured as a state that keeps moving. DECODE (CMU, empirical) tracks 53.6K in-IDE edits to already-accepted AI completions from 1,141 developers, which is the layer beneath every number on this page: a median 63% of the accepted completion survives to the end of its trajectory, retention is bimodal (kept essentially whole or discarded outright), and 31% of trajectories carry an edit whose intent is removal. So "accepted" is not a terminal state even in the strongest case, where a human affirmatively took the suggestion. It corroborates the authorship claim from the other direction too — developers add only 20% of the final code, and under 5% of it in 36% of final states — so where a completion survives, it survives as the model's text. Different layer from everything else here: pre-commit, in-IDE, inline autocomplete from 2024-vintage models, not agent-authored PRs

Derived#

• Is Human Review of AI-Authored Code Still a Real Control, or Already Rubber-Stamping? — splits this page's "acceptance" into the three-way partition (affirmative adoption / reviewed non-reversion / bare non-reversion) and locates the oversight-erosion signal in the third class only

Open Questions#

• The 60% figure aggregates very different tools and modes (autocomplete acceptance vs. agent-applied diffs). What does "acceptance" mean when the agent applies the change directly and the human's "acceptance" is not reverting it? Sharpened by Review as the Control Point: on GitHub, agent PRs are most often examined only by the developer who invoked the agent (author-only review 40.1% vs 21.5% for human PRs). Whether that counts as review at all is a definitional choice (agent-as-author ⇒ a second set of eyes; agent-as-tool ⇒ self-review) that literally flips the sign of the trend — so "acceptance" and "review" blur into the same unresolved construct. Partially answered: Is Human Review of AI-Authored Code Still a Real Control, or Already Rubber-Stamping? — the construct resolves into a three-way partition by who acts and who looks: affirmative adoption (human applies a suggestion), reviewed non-reversion (agent applies, independent human examines), and bare non-reversion (agent applies, nobody looks — the only rubber-stamp class). The 60% blends all three, which is why it can't answer whether oversight is real; the proposed metric is the partition itself, with only bare non-reversion read as oversight erosion. Still unmeasured: the partition's actual shares in any dataset. Partially answered again, from below (2026-08-12): DECODE measures the affirmative adoption class — the one the partition treats as unambiguous — and finds it is not an endpoint. Of trajectories that begin with a developer accepting a completion, 31% contain a removal edit, retention is bimodal, and the median completion has lost roughly a third of itself within the hour. That does not supply the partition's shares, and it does not touch the two non-reversion classes at all (its unit is a suggestion a human applied, not a diff an agent applied). What it settles is narrower and useful: acceptance is a point on a trajectory, so any partition of it needs a time horizon attached, and the instrument that can see the trajectory is pre-commit editor telemetry rather than anything at PR level.
• If agentic authoring crosses from <1% toward double digits, does the whiplash become unmanageable before context-engine tooling matures — or does the tooling mature because of the pressure?

Sources#

• AI Engineering Report 2026: The Acceleration Whiplash — Executive Summary; Finding #1 (Adoption); "AI is the primary author now"
• The State of AI Impact in Engineering: Q2 2026 — Justin Reock, The State of AI Impact in Engineering: Q2 2026 (DX, Engineering Enablement newsletter, 2026-07-22), tier corrected empirical to vendor-claim at compile (see Sources). Finding 1 only — the self-reported 34%-to-52% code share across 500+ customer organizations. No methodology accompanies it: the report is gated, so the question wording, unit, respondent population and per-quarter n are all unavailable to the vault
• Characterizing the Quality Profile of AI-Generated C++ in Production — Tran et al. (Google, arXiv 2608.06640, 2026-08-06), empirical: §3.2 (authoring-time provenance and projection), §4.1 (adoption trends, organizational heterogeneity, interaction-mode context, the developer-filtering caveat) and Figure 3, viewed directly — the mode shares quoted above are read off the stacked-area panel and appear nowhere in the prose. Evidence note and COI at Efficiency Debt of AI-Generated Code