37,000 lines of code a day isn't a flex. It's a warning.
Garry Tan claimed that number across five concurrent projects. Tech press reported it as proof of AI's power. Scott Tolinski1 examined what actually happens when AI agents generate code at industrial scale without human review.
The Case Study
A developer going by Gregorian audited Tan's blog after observing the productivity claims. The results reveal the consequences of unconstrained AI code generation.
| Category | Finding |
|---|---|
| Test files | 28 test files bundled into production bundle, ~300KB sent to every visitor |
| Scaffolding | A literal Rails Hello World controller shipped in production |
| Images | One PNG at 2MB, another at 1.99MB, zero modern image handling |
| Editor | 520KB rich text editor speculatively shipped from backend to frontend |
| Accessibility | 47 images with zero alt tags |
| Rendering | Page content rendered twice - once mobile, once desktop |
The site loads. Scores 80 on Lighthouse. But "it works" is a dangerously low bar.
Users on constrained connections, screen readers, older devices - they bear the real cost. As Tolinski puts it: "The web should not be treated as a dumping ground for unreviewed AI output simply because the result is technically functional."
Line Count Is a Terrible Metric
Raw line counts are meaningless without context. 37,000 lines per day isn't 37,000 lines of validated, production-ready code. It's a river of text containing dead code, duplication, accessibility failures, architectural nonsense. Without human review, nobody knows what's actually in there.
You sure as hell don't know what is going into your code base if you're not reading it.
Lines of code has always been a poor productivity measure. AI just made it possible to generate meaningless lines at industrial scale.
The Real Risk
AI doesn't generate obviously wrong code. It generates code that looks plausible. Plausible is worse than wrong because it gets past first glance.
The code compiles. The tests pass. But hidden in those 37,000 lines:
- Test code shipping to production
- Scaffolding that should have been deleted
- Images without compression or alt tags
- Components rendered twice for responsive design
- Rich text editors shipped speculatively
Without review, these issues accumulate. The codebase becomes digital landfill - functional on the surface, broken underneath.
Machine Learning by Randall Munroe, CC BY-NC 2.5, via xkcd.
Slowing Down
Mario Zechner2, creator of the Pi agent framework, argues the answer isn't abandoning AI. It's using it deliberately.
His core argument: let the AI handle the boring, repetitive tasks that teach you nothing, then carefully evaluate what it produced.
Practical guidance from Zechner:
- Set self-imposed limits on how much AI-generated code is accepted per day, calibrated to your ability to genuinely review it
- Do not accept code that you cannot read and understand
- Use AI as a productivity multiplier for the mechanical parts of coding, not as an autonomous agent operating without oversight
Tooling for Hygiene
Tolinski has been exploring Fallow3 - a static analysis tool for TypeScript and JavaScript codebases that surfaces:
- Dead code
- Duplicate lines
- Circular dependencies
- Complexity hotspots
AI coding agents have a known tendency to solve problems locally dozens of times rather than globally once. Fallow helps identify where this pattern has contaminated a codebase.
Static analysis finds what humans miss in large generated outputs. Without it, near-identical utility functions proliferate, dead code accumulates, and architectural inconsistency grows.
The Core Philosophy
I'm not outsourcing my brain. I'm using my brain to outsource the work.
Outsourcing your brain = accepting AI output without understanding it. Using your brain to outsource work = directing AI toward mechanical tasks while you handle judgement, review, architecture.
First approach produces slop. Second produces leverage.
Summary
- Line count ≠ productivity. 37,000 unreviewed lines is liability, not achievement.
- "It works" is a low bar. Performance, accessibility, maintainability matter.
- Plausible is worse than wrong. Code that looks right gets past first glance.
- Set limits. Calibrate AI output to review capacity, not generation capacity.
- Use tools. Static analysis finds patterns humans overlook in large outputs.
- Understand every line. If you can't read it, don't ship it.
What's Next
Next time you see someone bragging about AI line counts, ask how many lines were reviewed by a human who understood them. The answer tells you whether they're building software or generating slop.