AI-Written C++ Carries a Runtime Tax • The Weighted Average

A yearlong production study covering 3.52 million code changes found AI-heavy C++ functions accumulated roughly 5% more compute growth and 8% more memory growth than mostly human-written peers. If the observed 5% compute delta translated one-for-one into provisioned time on Google Cloud’s $4.74408-per-hour 96-vCPU C4 instance, it would add about $237 per 1,000 instance-hours—$4.74408 × 1,000 × 5%—before review cost; that is a conditional scale illustration, not the study company’s bill.

The bill arrives after the code lands

The production C++ preprint follows code from authoring into review and deployment. Its anonymous enterprise operates global products serving billions of users and records byte-level authorship provenance. The organization-wide sample spans April 2025 through April 2026; the focused C++ analysis covers 10.46 million lines with informative provenance, about 350,000 reviewable static-analysis changes, and roughly 70,000 function-level compute observations.

Adoption moved faster than quality controls. The paper’s full results trace that change through five observation levels. Across major languages, AI-generated code rose from 28.99% in April 2025 to 68.62% in March 2026—a 39.63-point increase, or about 2.37× the starting share. This is an early view of what survives developers and reaches a mature brownfield codebase.

The excess burden was patterned rather than universal. Efficiency and resource-use findings ran at 1.23× the human rate, while maintainability and readability reached 1.08×. Interface and coupling burden plus copy and allocation overhead accounted for 82.21% of the positive absolute static-finding gap. Correctness and safety findings were slightly lower for AI-generated code, reminding readers that “worse” is not one dimension.

Source structure supplies a mechanism. The study says AI-generated C++ authored loops nearly twice as often and used standard-library or internal API calls 30–40% less often. Missing move semantics, map access, and container insertion appeared more frequently. In production profiles, AI-heavy functions shifted 3.46% toward direct on-CPU work and 1.08% away from declarative libraries. The code often did locally what optimized shared implementations already knew how to do.

That pattern reached the operating bill. By early 2026, normalized compute growth was about 1.31× baseline for AI-heavy functions versus 1.25× for human functions, an approximate 5% relative gap. Memory growth reached roughly 1.36× versus 1.25×, about 8%. The comparison is observational, not causal: task mix, model generation, developer experience, and repository context can confound it. Still, resource telemetry observed after deployment is harder to dismiss than a style preference.

To make the scale tangible, the Google Cloud C4 price sheet lists a 96-vCPU Iowa instance at $4.74408 per hour. One thousand on-demand instance-hours cost $4,744.08 before storage and network. Applying only the observed 5% compute gap, and explicitly assuming it maps one-for-one to provisioned instance-hours, yields $237.20. The separate 8% memory-growth observation is not priced as compute. This is not the anonymous company’s bill or a fleet forecast; it is a reproducible scale scenario.

Review pays another toll. AI-generated changes received 1.92× as many blocking threads, 1.39× as many total comments, 1.24× the reviewer iterations, and 1.19× the merge time in descriptive comparisons. Build failures and sanitizer findings ran near 1.3×, although reverts stayed below parity around 0.9×. Existing review gates caught acute failures; they did not fully erase chronic compute and maintenance cost.

This evidence gives a quality denominator to the archive’s Airbnb AI-speed scorecard. Shipping faster can be real while total cost rises elsewhere. It also strengthens today’s Claude Code auto-mode argument: removing low-value approval clicks should buy attention for architecture, tests, and performance—not simply increase merge volume.

Turn the taxonomy into a merge gate

The paper’s intervention is more useful than its diagnosis. Researchers selected 50 C++ functions with targeted efficiency findings and generated implementations under three prompt stages. Category-specific feedback reduced static efficiency findings from 1.26 to 1.12, an 11.1% drop, while the benchmark efficiency score improved 31%. The weaknesses were not a hard capability ceiling; the default context failed to name the local performance contract.

Performance-sensitive teams should encode that contract where agents can see and tests can enforce it. Put preferred containers, move semantics, allocation rules, internal libraries, concurrency primitives, and prohibited patterns in repository guidance. Retrieve nearby optimized examples. Run clang-tidy or equivalent checks on generated diffs. Benchmark hot functions before merge, not after aggregate cloud spend drifts.

Provenance helps prioritize without becoming a stigma. Mark AI-touched regions at authoring time, then use the marker to trigger additional checks for performance-critical files. Do not infer authorship from source style; the paper explicitly avoids unreliable post-hoc detectors. Do not reject generated code automatically. Apply evidence-based checks to the failure classes the organization actually observes.

The economic gate should compare fully loaded outcomes. Track accepted changes, review minutes, build retries, escaped defects, CPU and heap deltas, and cloud cost. GitHub’s Copilot impact dashboard now places AI-credit spend beside pull requests, but PR output alone cannot see an 8% memory tail. Add production efficiency to the scorecard for services where one regression multiplies across billions of requests.

The strongest counterpoint is external validity. This is one unnamed enterprise, one performance-sensitive language, one monorepo culture, and a changing mix of models and interaction modes. A METR randomized trial found experienced open-source developers took 19% longer with early-2025 AI tools, a different setting that reinforces how sharply outcomes can vary by task and workflow rather than serving as a direct comparison. The raw data cannot be released. The study cannot isolate a single assistant or prove that AI authorship caused the resource gap. Rust, Go, Java, TypeScript, and greenfield services may show different taxonomies.

The cloud-price scenario is bounded. Discounts, autoscaling, utilization, hardware, region, and workload shape real cost. A 5% function-level difference does not mean a 5% whole-fleet bill; apply the measurement design, not the percentage.

Evidence that would change the verdict includes multi-company replication, language-specific results, randomized tooling interventions, and matched workloads under current models. If targeted guidance erases the production gap, the answer is better context rather than less AI. If the gap persists after controls, organizations should price generated code as a workload class with its own performance budget.

The quarter-level move is practical:

C++ and systems teams should switch first from generic generation to repository-specific guidance plus mandatory static and microbenchmark checks in hot paths.
Engineering leaders should budget the whole funnel: model cost, review, retries, CPU, heap, and regressions—not accepted lines or PRs.
Platform teams should preserve provenance at authoring time and use it to trigger checks, never as a substitute for code-level evidence.
Reviewers should focus on the concentrated classes: coupling, copies, allocations, explicit loops, and missed optimized APIs.
Change the verdict with telemetry: if generated functions match human cohorts on resource growth after guidance, relax the gate; if not, tighten it.

The archive’s agentic-engineering thesis argued that developers would orchestrate more work than they type. This study adds the invoice. Orchestration creates leverage only when the generated artifact inherits the codebase’s performance wisdom. Otherwise, speed at the keyboard becomes interest paid by the fleet.