Near-100% AI-Generated Code, Agent PRs Up 10x: The Pragmatic Engineer's 2026 State-of-Tech Report

Gergely Orosz spent the last few weeks doing something luxurious: visiting OpenAI, Anthropic, Cursor, and Ramp one by one — not to attend launch events, but to watch how engineers inside these companies actually work. He wrote up what he saw in The Pragmatic Engineer's 2026 state-of-the-tech-industry report.

The conclusion is a single sentence with enormous weight: the software industry has crossed a threshold — writing code is no longer the bottleneck; trusting code is.

This report deserves a careful read from every vibe coder, because it describes not "the future" but the "present" already happening inside the most advanced teams. And the vibe coding community happens to be the group standing closest to that present.

The watershed was January 2026: near-100% AI-generated code becomes normal

Orosz records a date that kept coming up: January 2026. Engineers came back from winter break to find that new models — Opus 4.5, GPT 5.2 — paired with their harnesses, were "really, really good." Almost overnight, startups tracking the metric went from "using AI to help write code" to "close to 100% of code generated by AI."

Note the precise meaning: not "programmers writing code with AI," but "code generated by AI." The human role shifted from authoring to instructing, choosing, and merging. Writing code, as an activity, is statistically no longer human work.

The harder number comes from GitHub: between January and August 2026, agent-only pull requests grew nearly 10x. AI-opened PRs in your repos may already outnumber human ones — you just haven't noticed.

Code review is degrading into "theater"

After the code-volume explosion, the first thing to break was code review. Orosz writes that review is degrading into what engineers privately call "theater": too many PRs, diffs too large, humans can't actually read them, so approval becomes a ritual click.

Ramp has begun allowing engineers to skip reviews for non-critical code, and Orosz expects others to follow. It's a dangerous signal: the validation layer that once made years-long migrations safe is being quietly abandoned. Migrations shrank from years to months, but the thing that made them safe is gone.

For vibe coders, that sentence deserves framing: you alone are the entire "validation layer." While big companies cut corners on review, the indie developer's edge is precisely this — you must own every line that ships, and you have the chance to do it well.

The IDE is becoming a "legacy product"

The most striking line in the report: inside Cursor, their own IDE is called a legacy product. A company built on an IDE, saying out loud that the IDE is the past.

What's replacing it is cloud coding agents plus homegrown harnesses. Ramp's cloud agent "Inspect" is held up as the blueprint: ambitious tech companies are all building their own cloud agent scaffolding. Orosz predicts vendors like Anthropic, OpenAI, and SpaceX will push their cloud coding-agent offerings hard, and more startups will build their own harnesses.

That's a clear signal for tool choices: the local-IDE-plugin war is over; the next battlefield is in the cloud. If you're still agonizing over which editor plugin to use, shift your attention to cloud-agent workflows — that's the main storyline for the next two years.

How people work: from "one mouse" to "ten agents in parallel"

Former Uber engineer Dima Zatchev, now at Linear, gave Orosz the report's most vivid quote: "It used to be a simple world, one mouse, one keyboard, one screen. You physically couldn't work on more than one thing, but we no longer have that limitation." He now runs five to ten worktrees with five to ten agents simultaneously.

That is the 2026 senior engineer's daily reality: no longer writing code personally, but commanding a squad of agents in parallel. The productivity paradox follows — more gets shipped, but the erosion of reliability is visible to the naked eye. Faster, but more fragile.

Rails creator DHH went further in his Rails World keynote, declaring that at his company 37signals, "coding by hand is dead." A 27-year-old profitable company famous for software craftsmanship made that call. Orosz's newsletter even ran a dedicated Pulse issue on the debate it sparked among developers.

The surprising comeback: decades-old practices are rescuing agents

The most interesting finding hides in the details. Educator Matt Pocock noticed agents love building software layer by layer, producing bugs between the layers. He dug out The Pragmatic Programmer, instructed the agent to build with "tracer bullets" — implementing a "golden path" first — and the agent started producing better code.

Orosz's takeaway: we're rediscovering "old" patterns that work great with AI — writing unit tests, building the golden path first, architecting upfront, even using design patterns. The irony is these are decades-old best practices. Agents don't lack new knowledge; they lack "leading words": one term from classical software engineering beats ten sentences of prompt engineering.

That's actionable advice for vibe coders: next time you have an agent scaffold a project from zero, have it skim the table of contents of The Pragmatic Programmer first — or just write "implement the golden path first, then fill in the edges" in your requirements. The effect is immediate.

The overlooked flip side: engineering leaders are burning out

Orosz also records a less glamorous trend: a wave of engineering leaders quitting or taking career breaks, crushed by founders' unrealistic expectations of AI. "AI lets 10 people do the work of 100" — when that narrative becomes the KPI, the engineering managers in the middle get squeezed first.

That's a warning for indie developers too: AI amplifies output, and it amplifies expectations. The day your agent ships a week's worth of work in a day, your expectation of yourself becomes "a week's worth every day." Vibe coders face no less burnout risk than big-company leaders — there's just nobody sending you a warning email. Set yourself a hard cap (say, max three parallel tasks a day); it matters as much as capping your cloud bill.

The harness is temporary: the OpenAI Codex lead's verdict

Orosz's podcast also features Thibault "Tibo" Sottiaux, who leads the Codex team at OpenAI, with three first-hand structural claims worth pulling out:

• The harness is deliberately temporary. Scaffolding exists to paper over today's model deficiencies, and it's designed to shrink as models improve. Harness builders face one question daily: build this now, or wait until stronger models make it unnecessary.
• Code review inside OpenAI is already automated, with security review mandatory and merge-blocking. Even the most advanced AI company no longer relies on humans reading diffs.
• Execution is moving from the laptop to cloud VMs. A "free" local resource is becoming metered cloud compute — echoing the old cost-control conversation.

The first point hits vibe coders hardest: the workflows you tune, the skills you write, the harness you build today may be casually absorbed by a stronger model six months from now. Over-investing in harness is risky; investing in "knowing what's right" is the asset. The former depreciates; the latter doesn't.

It also explains why Cursor dares to call its IDE legacy: when execution and intelligence both move to the cloud, the heavy local editor is left as a mere habit. And habit is the cheapest moat there is.

Four things indie developers can do this week

The report is grand, but for a team of one, it lands as four small things:

• Write down your review process. Never merge an agent's PR blind, however small: run the tests, glance at the key diff, ask "if this line is wrong, what's the worst case?" You are the entire QA department.
• Feed the agent "old words." Put "tracer bullet first," "write the failing test first," "define module interfaces before implementing" in your requirements. Classical vocabulary is the instruction language agents understand best.
• Try a cloud agent once. Throw a small task at a cloud agent and go get coffee. Get used to "async commanding" instead of welding yourself to the screen watching it type.
• Accept that harnesses depreciate. Review your skills and workflows quarterly: which ones have new models absorbed natively? Delete them, don't get attached.

The 2026 software industry is flipping from "humans write code, AI assists" to "AI writes code, humans own it." Orosz's report simply puts numbers and interviews around the life the most advanced teams are already living. Vibe coders don't need to catch up with this shift — you're already inside it.