How are coding agents changing software engineering? Yapped for 15 minutes about new Cursor data we published, including: 1. Why lines of code is an imperfect measure of AI progress 2. Balancing intelligence/cost/speed for models 3. Code reviews with "Mega PRs" (1000+ lines)

holy shit the audio is so crisp also a good video

Mega PRs are a real bottleneck. AI makes code generation cheap, but review, architecture, and operational accountability become more valuable. The best teams will measure accepted changes, rollback rates, defects, and reviewer load more than raw LOC.

best yapper in town

more code shipped faster with less understanding that is not progress. that is just faster accumulation of future problems the new question is how much of what shipped did the engineer actually understand

This is very insightful Lee. Thank you 🙏🏻

i need to get a boom mic

goat's back with another banger

thanks for this!

🤌

Power user gap is very interesting!

This is a really valauble report! thanks @leerob for walking us through it. 100% Agree on the metric of "merged-PR's" being the true indicator for developer productivity gains. That is what we are seeing @coderabbitai too!

Thanks buddy

The Mega PR problem is real. Code review culture built around humans changing code incrementally. AI ships 1000 lines of coherent code that compiles but has subtle architectural issues nobody catches because the surface area is too large.

My latest PR has 14k LOC added… does that count as mega? 😅

Lines of code was always a weird scoreboard. The better metric is how often the agent gets you to a reviewed, working diff without babysitting.

might be wrong but 'mega PRs' kind of relies on LOC being meaningful. if it's imperfect as a metric, what actually makes 1000+ lines a signal worth tracking? does your data show those PRs having higher revision counts or worse merge rates?

love the video! really on par with what i’ve been seeing too and interesting to speculate what the future of the industry will look like … even bigger loc diffs? quality of code accepted? code actually reviewed/trust increase in agents?

merged-PRs beats LOC but it's still a throughput proxy. the thing that actually moves is the risk/maintainability delta per change, and almost nobody measures it. a mega-PR isn't bad because it's 1000 lines, it's bad because that delta becomes unreviewable

the Mega PR problem is real. 1000+ line diffs are basically unreviable. you're approving vibes, not code. the deeper issue is that agents don't have the same constraints humans do on keeping changes scoped

quality over quantity man speeding up the Ai progress isn’t the only thing we have to measure

One big shift: review becomes the bottleneck. Agents can generate 1,000 lines fast, but the hard part is still preserving architecture, invariants, and operability while diff size explodes.

the mega PR thing is real and honestly code review just gets harder when agents write 1000+ lines at once curious how teams are actually handling that in practice

The interesting metric for coding agents isn’t “how many lines got written” but “how much validated change landed with review confidence.” AI can make mega-PRs cheap, but teams still need smaller reviewable units and better evidence around intent/tests.

not sure anyone's cracked the ideal balance yet.

Awesome video!

LOC is the WPM of programming. Easy to game, hard to interpret. The metric I want to see is rework rate inside 30 days of merge. That's where agent code shows its real seams.

the mega PR framing is where i get nervous. nobody actually reviews 1000 lines, they skim and approve.

"Balancing intelligence/cost/speed" solves the engineering side — but if agents absorb coding, the bottleneck shifts upstream to requirements. Nobody's building agents for product specs yet. Does Cursor's data show any scope-creep signal from devs?

"Lines of code is an imperfect measure" is the tech equivalent of saying the economy is complicated — technically true, practically ignored by everyone writing job postings

A lot of my PRs are crossing a thousand lines lately

we basically went from writing code to proofreading a robot's homework

I am thinking about how in the future every engineering decision will be shaped by ai And that different engineering endeavors will need different models It's hard not to imagine the best teams have very sophisticated use of many different models

Code complexity becomes a problem with repeated edits. The LLMs are good at controlling it, though, if you just tell them how complex the code is: how many lines in a function or file, how many levels of indentation, size of a dependency cycle, etc. Try `cargo install kiss-ai`. It's a linter that gives complexity-metric feedback.

A lot to think about in this analysis. Any recommendation on how to manage code quality at scale, as the number of PR and lines of code gets too much for humans to review? I would like automate quality gates that go beyond catching bugs: how much cognitive load is added by this PR? Can it be simplified if we drop some requirements? Is it overly defensive or unnecessarily back-compatible, etc.