Weekly Video Notes — a short article distilling one talk from the weekly digest. Source video and key frames embedded throughout.

Cursor just published the 2026 edition of its Developer Habits report, drawing on aggregate data from millions of Cursor users. In this 16-minute walkthrough, a Cursor engineer reads the report live and annotates it with personal commentary from 10+ years building software. It’s the closest thing the industry has to a quantitative snapshot of how coding agents are reshaping day-to-day engineering work.

Five headline findings

The report is structured around five trends:

  1. Coding speed is doubling year over year. Lines of code added per developer per week have accelerated since the start of 2026.
  2. PRs are getting larger — and “mega-PRs” (1,000+ lines changed) are no longer rare.
  3. AI-generated code is sticking around — agent-authored lines are still present in the codebase 60+ minutes after acceptance, suggesting they’re not just disposable scaffolding.
  4. The top 1% of users are pulling away. A widening gap is opening between power users and everyone else.
  5. Context is exploding. Input tokens are climbing dramatically, and the industry is moving aggressively toward prompt caching.

Five headline findings from Cursor’s 2026 Developer Habits report

Lines-of-code is a flawed metric — but the trend is real

The engineer caveats the headline finding immediately: lines of code is an imperfect signal. Plenty of bad code can be added, and minimizing surface area is generally a virtue. But in aggregate, the trend points to more developers building more projects, prototyping more ideas, and inviting more non-traditional contributors (PMs, designers, domain experts) into the build pipeline.

The flip side: mega-PRs are a real quality risk. He notes how easy it is for a vibing-out session to add thousands of lines that should have been ignored in Git (a misconfigured lock file, generated artifacts), and warns that “an agent without supervision will happily produce code that becomes a liability.”

AI lines survive — and that changes how you should think about review

AI-generated code surviving longer in the codebase

One of the more striking stats: AI-authored lines are still present in the codebase well past the 60-minute mark after acceptance. They aren’t being reverted out. That makes upstream review and acceptance criteria more important, not less — once those lines land, they stay.

Model benchmarks, with grains of salt

Cursor reports its own internal benchmarks side-by-side with external ones (TerminalBench, SWE-Bench Multilingual, artificial analysis). The recommendation is to triangulate — Cursor’s numbers are roughly consistent with the artificial-analysis leaderboard, but each benchmark has blind spots.

Cross-referencing benchmarks across providers

Context is the new battleground

The growth in input tokens per request

“You give the models a relatively simple prompt and then they go and do a lot of work for you.”

Input tokens per request keep climbing because agents and harnesses are silently loading more context — relevant files, tool definitions, prior turns, scratchpads. That’s why prompt caching has become table-stakes: without it, the economics of agentic coding fall apart fast.

From prompts to factories

The final trend: developers are no longer writing one-off prompts. The most productive users are building systems — repeatable scaffolds, rules files, project-level instructions, custom agents — that act as a factory for producing high-quality software. This is the same shift the talk attributes to the top 1% pulling away from the rest.

Key takeaways

  1. Speed has roughly doubled YoY. Whatever your baseline was 12 months ago, you’re probably already behind.
  2. Mega-PRs are now common. Plan for review tooling and acceptance gates that can handle 1,000+ line changes without falling over.
  3. AI-authored code stays. Treat the moment of acceptance as a real commit, not a draft.
  4. Power users are getting dramatically more leverage through tooling, prompts, and repeatable systems — not just by typing into the chat box.
  5. Context engineering is the work. Input-token growth and the rush to caching reflect that the prompt isn’t a question; it’s a payload.
  6. Triangulate benchmarks. Don’t trust any single number, including Cursor’s own.
  7. Lines of code is directional, not dispositive. Pair quantity stats with quality and longevity signals.

Source