I Let AI Write 10,000 Lines of Code a Day — Here’s What Broke Me

Evan Harris pushed his third cold brew off to the side of the monitor just as the Slack notification from a marketing account slid into view: “Two‑person garage team uses AI to crush a 200‑person outsourced team in three days.” He swiped open his phone, screenshotted it, and sent it to Maria with the caption: We could do that too.

Maria replied with a single emoji: 🙄.

But the seed had already been planted. Evan had spent four years at the company doing middleware — interface docs, compatibility matrices, test‑case checklists, day in and day out. He knew exactly how much unglamorous work was stuffed between a piece of code and something you could actually sell. Still, that weekend he cleared out the garage, hauled a folding table home from Costco, propped his old MacBook Pro on it, and opened Cursor.

Just a lightweight project‑management tool, he told himself. Gantt charts, permission controls, a plugin interface. AI can handle it. And at first, it really could. He described a data model in three lines of English, and the AI spat out an entire migration, TypeScript type definitions, even auto‑generated unit tests. Evan grinned at the screen — the kind of grin he’d later remember as the one you see on a first‑time roller‑coaster rider who mistakes freefall for flight.

Week one, he had a demoable prototype running. Maria came by the garage, took one look, and said, “You know that modal for creating a project after login — hitting ‘Cancel’ wipes the whole session, right?” Evan said, “Edge case. I’ll fix it tomorrow.” He didn’t. That same night he had the AI generate a notification module and a real‑time collaboration websocket skeleton. The line count had already surpassed what he’d written at the company in half a year. He started to believe the number: 1,000 lines per person‑year was a joke; he was doing 10,000 lines a day.

Week two, he demoed the prototype to the CTO and two product directors. Nothing crashed. Gantt‑chart drag‑and‑drop was smooth. The AI‑assisted dark mode even made one of the designers raise an eyebrow. The CTO said, “Give you a month — can you wire the permission system into our LDAP?” Evan said, “Two weeks.”

That was the last easy thing he said.

Week three, after the permission system was integrated, the notification module started silently dropping messages. Not every time — about 3% of requests lost their subscription state after a websocket reconnect, and only on certain Android models running Chrome. Evan had the AI generate a test suite; the AI’s cases covered login, logout, token expiry, concurrent connections — all passing. But not a single test simulated the noise of “user steps into an elevator, switches from 5G to Wi‑Fi, and immediately taps a notification.” A stranger in a Hacker News comment thread found that bug for him.

He began spending whole nights reading code he’d never laid eyes on. AI‑generated code read like an email with perfect grammar that somehow dodged every real question: interfaces were vague, error handling was catch‑all, and buried in the dependency tree was a three‑month‑stale fork of a library — a fork that fixed a bug he hadn’t even known existed. One afternoon Maria brought him a burrito, stood at the garage door, and said, “You know what your test coverage is right now?” Without looking up, he said, “Eighty‑two percent.” Maria said, “I’m asking about the percentage of your test cases that contain meaningful assertions.” He didn’t answer.

Week four, he tried to “cram ten days of work into one with AI.” The task was to extract a reporting module that had run inside a monolith for two years into a standalone service — same API, no added latency, consistent error‑log format. The AI’s first draft ran perfectly on his machine. Deployed to staging, it leaked memory within three hours. Two days of digging led to a pointer wrapper the AI had used — marked deprecated but still referenced — that double‑freed under a specific GC timing sequence. Staring at a perf flame graph, he remembered a line from The Mythical Man‑Month, something he’d read back in Professor Brooks’s class and dismissed as old‑world caution: “The cost of a programming product is three times that of a debugged program, and the cost of a programming system product is three times that of the product.”

He screenshotted the flame graph and sent it to Maria with the caption: 9x.

This time Maria didn’t send an emoji. She called. “You get it now?”

He said nothing. The garage filled with the creak of the folding table under his wrists and the full‑throttle whir of the MacBook’s fans. It hit him then: what he’d built over the past month wasn’t a product, wasn’t even a component. It was a stand‑alone program running under ideal conditions — the very thing whose 1,000‑lines‑per‑person‑year figure he’d once thought was an insult.

Week five, he didn’t give the CTO a demo. He changed the repo’s README to “Experimental — do not use in production,” and switched off the garage light.

On a Wednesday after that, Evan was back at his desk, opening Jira, writing an API compatibility test plan. Halfway through, Maria dropped a link into Slack, the same kind of headline: “AI gives indie devs 10x productivity.” He typed back: 10x of what?

Then he flipped his phone face down on the desk and kept writing section 4.3 of the test plan: When the upstream service sends an RST immediately after the TCP handshake completes, does the client’s retry queue leak file descriptors?

The copy of The Mythical Man‑Month on his desk was the one Professor Brooks had given him before retiring. In the margin of the first chapter, “The Tar Pit,” there was a small dried coffee stain, and next to it a penciled note from his college days, only half a sentence: “The beast rarely notices the — ” He’d never finished it. He picked up the book, turned to that page, and completed the thought. In ink this time. He closed the book without waiting for it to dry.