Complete AI Training
Start for Free

Your job's AI kit

Get your AI kit

Tell us who you are and what you do. We show you your kit right away and email you the link: skills, prompts, AI agents, MCP servers and courses for your job.

500+ jobs ready, and we make a kit for any other job. No payment needed to look.

Share

AI news ·

Amodei's 90% AI Coding Prediction Falls Short as Enterprises Ramp Up and Developers Stay Wary

AI coding is growing, but nowhere near 90%. Big tech reports ~20-30% AI-generated code as teams wrestle with trust, quality, and security; use guardrails and measure real gains.

AI isn't writing 90% of your code - yet

In March, Dario Amodei said AI would write 90% of the code developers write today within three to six months, and essentially all code within a year. We've passed the six-month mark. The industry isn't there. Adoption is rising, but the gap between hype and day-to-day delivery remains clear.

What we see on the ground

Big tech reports meaningful gains, but not a takeover. Google said in November 2024 that more than 25% of its internal source code was AI-generated. Microsoft put its figure at roughly 20-30%, depending on the repo. That's progress, not 90%.

Across the wider industry, developers are using AI tools more, but trust and security concerns are slowing full automation. In the 2025 Stack Overflow Developer Survey, 46% of developers said they don't trust the accuracy of AI outputs and 61.7% cited ethical and security concerns.

Quality and rework are real friction. Fastly reported that engineers frequently fix AI-generated code and that the time spent on corrections often offsets initial speed gains. Google's own research notes ongoing enterprise concerns about AI-generated code quality. Cloudsmith found 42% of developers have AI-filled codebases, but only 20% "completely" trust AI-generated code.

Why the gap persists

  • Quality variance: Models produce plausible code that fails edge cases, standards, or performance budgets.
  • Context limits: Architecture, domain rules, and legacy quirks aren't fully captured in prompts.
  • Toolchain friction: Integrations with CI/CD, SAST/DAST, and policy controls add overhead.
  • Governance and licensing: Provenance, IP hygiene, and license scanning aren't optional.
  • Data and security risk: Secrets exposure and unsafe dependencies creep in without guardrails.
  • Measurement gaps: Many teams don't track acceptance, defect density, or rework by code origin.

What this means for engineering leaders

  • Set policy for AI-authored code: Require commit provenance (model, version, prompt link), coding standards, and review gates.
  • Upgrade your gates: Enforce SAST/DAST, license and secret scanning, and min test coverage; add fuzzing for critical paths.
  • Human-in-the-loop rules: Mandate human review for AI diffs above a LOC threshold or touching sensitive areas.
  • Centralize context: Provide repo-aware context (embeddings/RAG), golden prompts, and snippets for common tasks.
  • Right-size model use: Use smaller, cheaper models for boilerplate and tests; reserve larger models for complex logic.
  • Secure by default: Prefer on-prem or VPC endpoints, scrub PII, and ban secret/code uploads to unmanaged tools.
  • Track the economics: Measure suggestion acceptance, rework time, defect density (AI vs human), MTTR, and vulns per KLOC.
  • Invest in skills: Train teams on prompt patterns, code review of AI output, and common failure modes.

If you want a structured path to upskill your team on safe, high-leverage AI coding, consider an AI certification for coding.

For individual developers

  • Use AI for boilerplate, tests, migrations, docs, and data-access code; handcraft core logic and critical paths.
  • Interrogate outputs: ask "why this approach," request alternatives, and run quick benchmarks where relevant.
  • Build a personal prompt library and code patterns; keep context tight and reference local interfaces/types.
  • Develop "AI QA" skills: read diffs like a security engineer; look for silent logic errors, race conditions, and unsafe defaults.
  • Track your own metrics: acceptance rate, bugs per week from AI changes, time saved vs fix time.

Signals to watch over the next 12 months

  • Repo-aware assistants that reason over entire codebases with reliable context windows.
  • Agentic workflows in CI that write code, run tests, and propose fixes under strict policies.
  • Vendor liability, provenance tagging, and emerging "AI-BOM" standards for generated artifacts.
  • Lower inference costs enabling broader adoption in test generation, refactoring, and legacy modernization.

Bottom line: AI is rewriting how we ship, but the six-month "90% of code" call overshot. Treat AI as a force multiplier, set guardrails, measure outcomes, and expand its footprint where it proves itself.

Share