Marc Andreessen: Devin Writes 90% of Cognition's Production Code

On September 9, 2026, Marc Andreessen published Investing in Cognition on Andreessen Horowitz's site — a second bet on Scott Wu's team behind Devin, framed as the next chapter of his 2011 essay Why Software Is Eating the World. The line that hit engineering Twitter immediately: Devin went from writing 13% of Cognition's production code to more than 90% in the past year.

Andreessen's broader claim is not a incremental copilot upgrade. It is a speed limit change: software has been eating the world at the speed of human hands — only 1 in 300 people on earth write code, and every line was artisanal — and it is about to eat the world at the speed of compute. If that sounds familiar, it rhymes with OpenAI's research-acceleration post three days earlier: frontier labs treating coding agents as production R&D infrastructure, not autocomplete toys.

This post maps what Andreessen actually cited, what Cognition has shown before, and what explainx.ai thinks builders should verify before rewriting hiring plans.

TL;DR — Andreessen's Cognition claims

"Software is about to eat the world much faster"

Andreessen opens by revisiting his 2011 thesis — controversial then, conventional now — and adds a constraint nobody priced in back then: human typing speed. Trillions of dollars of market cap migrated to technology companies while almost nobody could write software. The bottleneck was never demand for software; it was the cost of producing it.

His September 2026 pivot:

Software has been eating the world at the speed of human hands. It is about to eat the world at the speed of compute.

That is the same structural argument Fei-Fei Li and others made in the token-abundant vs token-starved research fork — labs with agent fleets iterate faster — but Andreessen applies it to every industry that runs on software, not just model training shops.

If agents automate software production itself, the multiplier lands on healthcare systems, banks, automakers, and logistics networks — anywhere COBOL, Java 8, and bespoke ETL still block modernization.

The 13% → 90% dogfooding number

The most quoted stat in the post:

In the past year, Devin has gone from writing 13% of Cognition's production code to more than 90%.

Read this carefully:

What it likely measures. Cognition builds Devin — they are the most motivated customer on earth to route work through their own agent. "Production code" here almost certainly means merged commits attributed to Devin runs in Cognition's own repos, not the global average across Goldman Sachs, Mercedes, and a hundred YC startups.

What it does not prove. That your team, on your legacy monolith, with your review culture, hits 90% next quarter. OpenAI's transparency post is the useful counterweight: even at the frontier, more than half of successful 4–8 hour agent tasks still needed human intervention in the last six months.

Why it still matters. Vendor dogfooding at 90% is a existence proof — the company betting its valuation on agents trusts agents to build agents. That is stronger than a benchmark press release, weaker than an independent audit.

For harness context on what "Devin writing code" actually means operationally, see explainx.ai's SWE-1.7 launch coverage — Cognition's RL-trained coding model served at 1000 tokens/sec inside Devin's cloud VM scaffold.

Enterprise proof points — Mercedes, Rivian, Itau

Andreessen lists three customer shapes that map to how Cognition sells projects, not seats:

Mercedes-Benz — COBOL modernization in eight days

At Mercedes Benz, engineers turned what would have been an eight month long COBOL migration into 8 days of work with Devin.

Legacy modernization is Cognition's enterprise wedge — the Bessemer investment memo similarly highlighted autonomous cloud VMs that take a spec and return reviewable work. Eight months to eight days is a 90%+ calendar compression narrative; the missing public detail is lines migrated, human review hours, and production cutover risk. Treat it as a flagship story until Mercedes publishes primary numbers.

Rivian — 10x test generation

Rivian teams increased their test generation velocity by 10x.

This aligns with Cognition's own 2025 performance review themes: Devin writing first-pass tests from human-authored playbooks across hundreds of repos, with code owners verifying logic coverage. Test generation is a sweet spot for agents — clear success criteria, executable verification, bounded scope — similar to why FrogNano chases SWE-bench rather than open-ended product design.

Itau — 70% vulnerability auto-remediation

Devin triages and patches vulnerabilities across thousands of repos at some of the world's largest financial institutions like Itau, where 70% of security vulnerabilities are automatically remediated by Devin.

Security remediation at bank scale is the trust-barrier use case: sandboxed agents, audit trails, policy gates. "Automatically remediated" needs definition — patch proposed vs merged vs deployed vs verified in prod. Still, if even proposal-quality fixes hit 70% on thousands of repos, that is a meaningful shift in AppSec throughput, not just developer convenience.

Self-driving software vs copilot — why architecture matters

Cognition's differentiation — repeated in VC memos and Cognition blog posts — is autonomy as architecture:

That is why Andreessen can cite Goldman Sachs, Santander, Nubank in the same breath as automakers — the product is sold top-down on modernization and security projects, not bottom-up on individual developer subscriptions alone.

explainx.ai's what are AI agents guide and loop engineering primer both stress the same builder lesson: the harness defines the unit of work. Devin's unit is a ticket; Copilot's unit is a token suggestion. Comparing them on raw benchmark scores misses the product shape.

The 10x → 100x → 1000x engineer framing

Andreessen's labor thesis:

When agents write 90% of the code, engineers can literally do ten times as much. The 10x engineer becomes the 100x engineer… The 1000x engineer isn't too far behind.

Scott Wu's quoted version:

Within our lifetime, engineers will go from bricklayers to architects, focusing on the creativity of designing systems rather than the manual labor of putting them together.

This is the optimistic supply-side story. The demand-side story from Zhenfeng Cao's agentic engineering essay on explainx.ai is compatible but sharper: complexity ceilings move with model capacity, so architecture and verification absorb the human share that implementation loses.

Practical split for 2026 teams:

1. Implementers — increasingly agent supervisors reviewing diffs, tests, and rollout plans
2. Architects — own interfaces, failure modes, and agent permission boundaries
3. Harness engineers — own sandboxes, evals, and ticket templates that make 90% merges safe

If your org has no third bucket, 90% agent code is a liability, not leverage.

Historical pattern — why Andreessen dismisses doomers

Andreessen runs the same argument he has used for decades:

• Compilers were supposed to kill programming jobs
• Open source was supposed to shrink teams
• Cloud was supposed to eliminate ops hiring

Each wave lowered marginal cost; software demand expanded. He cites Milton Friedman via the Techno-Optimist Manifesto — human wants are infinite, so economic demand can grow without bound when technology creates new affordances.

explainx.ai's read: the macro story can be true while micro pain is real. Junior implementation hiring may compress in some firms even as total software output rises — the transition is uneven, not instant universal abundance.

a16z's second bet on Scott Wu

The post is partly investor narrative. Andreessen emphasizes knowing Wu seven years, backing him at Lunchclub, and watching IOI gold-medalist competitiveness translate into "every second counts" culture.

Technical pedigree matters here because Cognition also ships models, not just harnesses — SWE-1.7 RL-trained on Kimi K2.7, competitive on FrontierCode at lower rollout cost. Devin is product + model + infra vertically integrated, closer to OpenAI's Codex-inside-the-lab story than to a thin wrapper on public APIs.

Second investment language signals conviction through market volatility — when every fund publishes an agent thesis, Andreessen is anchoring on a team claiming 90% self-production plus Mercedes-scale logos.

What to verify before you forward this to your CTO

1. Define "production code." Commits merged? Lines shipped? Excluding config/docs/tests?
2. Human hours per agent hour. 90% lines with 200% review time is not a free lunch.
3. Customer-primary sources. Mercedes, Rivian, Itau outcomes are cited through a16z/Cognition — look for customer case studies with scope.
4. Security remediation definition. Proposed patch vs merged vs validated exploit closure.
5. Your codebase shape. COBOL migrations and test-playbook generation are not greenfield React features.
6. Intervention rates. Compare against OpenAI's more-than-half intervention rate on long agent tasks — internal frontier labs still babysit.

None of this makes Andreessen's post irrelevant. It makes the correct internal takeaway narrower: agent tickets work at scale for modernization, tests, and security toil — and Cognition dogfoods harder than almost anyone — not your repo is 90% automatable tomorrow.

How this connects to September's agent-training research

Same week, academic and industry labs argue about where gains come from:

Devin sits at the deployment and revenue end of that stack — proof that banks and automakers pay for outcomes, not leaderboard points. The research papers explain how to train the next checkpoint; Andreessen explains why capital keeps flowing to the harness that merges PRs.

Practical takeaways for builders

1. Spec quality becomes the bottleneck. If Devin takes tickets, engineers who write precise specs and acceptance tests become the scarce skill — see how to work with AI agents.
2. Start with toil, not greenfield. COBOL, test gaps, and CVE backlogs match Cognition's cited wins — not "build me a new product from scratch unsupervised."
3. Invest in review infrastructure. 90% agent code with 10% review discipline produces incidents, not velocity.
4. Compare harnesses, not vibes. Devin VM tickets vs Claude Code loops vs Cursor cloud agents — loop engineering is how you evaluate fit.
5. Watch dogfooding metrics from vendors skeptically — but do not ignore them. 13% → 90% at Cognition is a North Star for what aggressive routing looks like.

The bottom line

Marc Andreessen's September 9, 2026 Investing in Cognition post is the week's clearest venture-capital statement that coding agents crossed from assistive to production-default inside at least one highly motivated shop — and that enterprise logos validate project-scale automation (COBOL, tests, vulnerabilities), not just tab completion.

Read the primary post at a16z.com/announcement/investing-in-cognition. Pair it with Cognition's Devin performance review, explainx.ai's SWE-1.7 coverage, and OpenAI's research-acceleration data for a balanced picture: agents are eating internal R&D and selective enterprise backlogs fast — humans still own architecture, verification, and the harness.

Related on explainx.ai

• SWE-1.7: Cognition's frontier coding model in Devin
• OpenAI research acceleration: 3.1 agent-workdays per human
• NeoHorse-1: routing harness and agentic post-training
• FrogNano: 4B coding agent without frontier distillation
• End of software engineering? Agentic engineering essay
• Loop engineering for coding agents
• What are AI agents? Complete guide
• How to work with AI agents: communication guide

Customer metrics and dogfooding percentages reflect Marc Andreessen's a16z announcement and Cognition public materials as of September 10, 2026. Verify enterprise claims against primary customer disclosures before procurement decisions.