Why 70% of Our Code Is AI‑Generated: Insights, Pitfalls, and New Engineer Roles

Introduction

In October 2024 Google’s CEO Sundar Pichai announced that more than a quarter of new code at Google was generated by AI and reviewed by engineers; six months later the figure rose to 50%, and by April 2025 it reached 75%.

The author shared a similar internal metric: 70% of the team’s commits are AI‑assisted, identified by a [AI] tag in commit messages.

Industry Trends

Google: 75% AI‑generated (April 2025, CEO blog)

Google: 50% AI‑generated (Fall 2024, earnings call)

Google: 25% AI‑generated (Q3 2024, earnings call)

GitHub Copilot average usage: 46% (Q1 2025, official data)

Java developers using Copilot: 61% (2025, GitHub research)

Global AI‑generated or assisted code: 50% (early 2026, multiple agencies)

2026 industry surveys show that 84% of developers use or plan to use AI coding tools, 51% use them daily, and AI‑generated code saves developers about 3.6 hours per week.

Our 70% Figure

We added a non‑mandatory rule to label any commit where AI contributed more than 50% with [AI]. Over two quarters, AI‑tagged commits accounted for 71.3% of total commits, acknowledging a margin of error due to the binary threshold.

Pitfalls

Pitfall 1: Happy‑path success, boundary‑condition failures

Example: an AI‑generated file‑upload service worked locally but caused data corruption under high concurrency because the generated code lacked proper locking.

Root cause: the AI model assumes single‑user, sequential execution.

Solution: a dedicated AI Code Review Checklist covering concurrency, exception handling, boundary conditions, resource cleanup, security risks, and performance hazards.

GitClear analysis of 1.53 billion lines of code found AI‑assisted programming reduced code reuse from 25% to under 10% while copy‑paste increased from 8.3% to 12.3%.

Pitfall 2: AI ignores project‑specific conventions

AI does not know naming conventions, error‑handling styles, logging formats, directory structures, or shared utility functions, leading to inconsistent code across modules.

Solution: an AI Context Document (≈600 words) that records tech stack, naming rules, error‑handling standards, prohibited patterns, and common utilities, pasted before each AI‑driven task.

Pitfall 3: New hires rely on AI without understanding the code

A newcomer produced large amounts of AI‑generated code but could not explain the logic when debugging, turning the code into a black box.

Data: Stack Overflow 2026 survey shows only 29% of developers trust AI output accuracy, a drop of 11 percentage points from 2024; 46% actively distrust AI tools, and 66% cite “almost correct but not right” as the biggest frustration.

Solution: a team rule requiring the author to explain every AI‑generated segment in their own words, with random checks during code review.

Pitfall 4: Systemic security risks

Sherlock Forensics 2026: 92% of 50 audited AI‑built apps contain severe vulnerabilities; 78% store keys in plaintext.

Opsera 2026 benchmark (250 k developers): AI‑generated code introduces 15‑18% more security bugs than manual code.

57% of AI‑generated APIs are publicly accessible, 89% use insecure authentication.

CodeRabbit 2025: AI‑assisted PRs contain 1.7 × more issues than manual PRs.

71% of developers refuse to merge AI code without review, yet 30% still commit it directly.

Conclusion: security review cannot be automated by AI and must remain a human responsibility.

Engineer Role Changes

Writing runnable code is shifting from a core competency to a baseline skill, similar to how Excel proficiency became a basic requirement for finance professionals.

Four capabilities become more valuable in the AI era:

Requirement translation : converting vague product needs into precise, AI‑friendly technical instructions.

Quality judgment : deeply evaluating AI‑generated code for correctness beyond superficial correctness.

Workflow design : breaking tasks into AI‑friendly granules, designing review processes, and maintaining context.

Global architecture : crafting overall system architecture that AI cannot autonomously design.

Data comparison (8‑month before vs. after AI adoption at 70% AI assistance):

Before AI (8 months ago):
- Team: 4 engineers
- Feature cycle: 5‑7 working days
- Test coverage: ~35%
- Production bugs: ~8%

After AI (70% AI):
- Team: 4 engineers (no expansion)
- Feature cycle: 2‑3 working days (≈55% faster)
- Test coverage: ~68% (AI‑generated tests)
- Production bugs: ~5% (slight improvement)

AI dramatically reduced development time (average 55‑60% per feature) and boosted test coverage because writing tests became near‑zero cost.

Complete AI‑Assisted Workflow

┌─────────────────────────────────────────────────────────────────┐
│                Team AI Programming Full Workflow                 │
└─────────────────────────────────────────────────────────────────┘

Step 1: Requirement breakdown (human)
  └─ Product need → technical task card → AI‑readable granularity

Step 2: Solution design (human + AI)
  └─ Human defines architecture direction
  └─ AI suggests implementation details and edge cases
  └─ Human makes final decisions

Step 3: Context preparation (human)
  └─ Paste "AI Context Document"
  └─ Add task‑specific constraints

Step 4: Code generation (AI‑lead)
  └─ Split into small tasks, generate incrementally, verify each step

Step 5: Test generation (AI‑lead)
  └─ Generate unit tests covering main branches and edge cases

Step 6: Code Review (human)
  └─ Follow AI Code Review Checklist
  └─ Author explains key logic
  └─ Extra review for security‑sensitive code

Step 7: CI/CD merge (automation + human confirmation)
  └─ Automated tests pass
  └─ Human approves before deployment

Average development time per feature module shrank by roughly 55‑60%.

Open Questions

The author does not claim to provide a definitive AI‑coding guide; several issues remain unresolved:

Will engineers’ skills degrade as AI handles more code? GitHub Copilot research shows faster PR merges, but GitClear’s analysis of 2.11 billion lines indicates a drop in refactoring from 25% to under 10%.

How should technical debt from AI‑generated code be measured? Rapid production can increase mental load if documentation and testing are lacking.

What is the optimal AI‑generated code proportion? Google’s 75% and the team’s 70% are not necessarily targets; the right balance depends on business complexity, team capability, and quality requirements.

Conclusion

Pichai’s latest blog states that Google is moving from "AI‑assisted coding" to "AI agents autonomously completing tasks," accelerating faster than most expected.

While the future engineer role is uncertain, those who start thinking seriously about AI‑augmented development today will have a decisive advantage.