One Dummy, One Engineer, One Million Lines

How a non-technical founder built, scaled, and hardened a stable AI system she can't read — with one engineer — and is still going. A series.

A non-technical founder, one engineer, and an AI rebuilt a failing video platform into a stable system of more than a million lines of code. It still runs in production today, with real creators and real money on the other side of it. I know how that reads. A year ago I'd have called it a lie.

If you build with AI, you know the wall I mean. The demo is magic, the first version ships in a weekend, and then it grows — and somewhere around the three-month mark the whole thing turns to sand. The AI forgets what it's doing, every fix breaks five other things, and you're holding something you can no longer fit in your head or your hands. Most vibe-coded projects die right there. Ours didn't. This series is about why.

It's for the people stuck at that wall — the solo founders, the I-can-ship-a-prototype-but-can't-scale-it crowd, anyone who suspects you no longer need a fifty-person engineering org to run a serious system. I'm going to show you the actual machinery — the systems, the controls, the discipline — that carries a toy across the gap to a stable, production platform, run by two people, one of whom (me) cannot read a line of it.

First, why I'm writing it down, because that turns out to be the point.

Two conversations started this. The first was with an alumnus — a CS genius, started coding at 13, won the IMO, and did my CS homework in college. He's a senior engineer now at a company you've heard of. He looked at what I'd built and asked, with genuine confusion, how? The genius who once covered for me couldn't make it add up. Neither could I.

The second was another alumnus who warned me the other way: don't overshare, protect the trade secrets. That one stopped me cold, and the reason probably says everything about me. In my own head, I wasn't even in the trade - the trade being software - not to mention inventing any trade secrets. Those belong to insiders — technologists, people who grew up in this world. I still thought of myself as the creative idiot who got other people to do her CS homework. Being told I had a moat to guard felt comical. These technical horns are very new on me, and they take some getting used to.

I sat between them until a third thought settled it. If I didn't write this down, I'd forget how we got here — not the highlights, the actual mechanism, the thousand small decisions that turned a prototype into something that doesn't fall over. I have the memory of a goldfish now and the schedule of a lunatic, and the knowledge was already evaporating.

So I started recording, and the moment I did I understood what I was really building. This isn't a memoir. It's training data. Everything I've made this year runs on one loop: messy real-world experience goes in, gets distilled into something a machine can hold, and the system gets smarter. I'd just never pointed the loop at myself. And I'm not only recording my own scars — I'm hoping you'll bring yours, argue with me, tell me where you've hit the same walls, so this becomes a knowledge base built from more than one stubborn person's mistakes.

If that sounds bleak, the other side is the most honest sentence in the series: I'm doing this so I can eventually stop. In Asimov's Foundation, Hari Seldon encodes everything he knows into a system so civilization can survive him and climb out of the dark faster. I'm doing a smaller, stranger version — encoding myself into a machine so it can run without me, so I can go back to the only thing I ever wanted to do, which is tell stories. I'm trying to earn the right to be an artist again, and the only way out is through.

That's why I share the lessons and not the recipe. There's a difference, and learning to tell them apart is one of the lessons.

Now, the part my engineer friend wanted. How.

If you read the first thing I wrote about this, you know the shape, and it isn't a triumph. We built the company the normal way first — eighteen people across three continents, a famous researcher, a film veteran with awards — and it nearly killed us. Two-thirds of the funding gone in six months. A prototype slower and more fragile than tools from a decade ago. A video generator that doesn't, well, generate videos. By the time I rebuilt the whole thing myself, with Claude doing the typing, I wasn't being brave. I was desperate. I shipped a working version in thirty days, on my birthday, mostly alone. Solve one problem, then the next.

Then came the part the founder stories skip. Once it worked, I dissolved the team and kept one engineer — the only one who sort of started to take to the new way. He lasted 1 month; too much work, he said, and I don't blame him. So that winter it was just me and the machine, and a pile of code I'd assembled but couldn't read — Dr. Frankenstein with no medical degree. When the whole thing started breaking faster than I could fix it, I hardened it myself, out of pure necessity, because there was nobody else. The first guardrails were mine. They were desperate and ugly, but they held.

Then the other QZ showed up. There are two of us, sharing the same initials like a cosmic joke. I'm Q1 — the founder who can't read a line of what runs her company. Q2 is the engineer who can. (If this becomes a book, the title's already written: One Engineer and a Dummy. Q2's the engineer.) Q2 took my desperate winter patches and turned them into a real immune system — the guardrails that let the thing grow past a million lines without buckling. I built the body and kept it breathing; Q2 made it survivable. Much of this series is what Q2 taught me, because it's the half nobody glamorizes and the half that decides whether you live.

But none of it explains what my classmate couldn't square: how does someone who can't hold the system in her head run it at all?

Because of the worst job I ever had.

I was a junior banker, and the work was small — a slice of a slice of something enormous — and it scared me how little of it I could hold. Past a certain size I dropped pieces. Everyone did; we just didn't say so. The whole place ran on hundreds of thousands of people like me, each holding one small piece, and it worked flawlessly for one reason: no one was ever asked to hold the whole. No one holds it; the system holds it. That's the first, simpler half of how a non-coder runs a million lines of code — I don't, the system does. I met the machine version the hard way during the rebuild, when a file crossed two thousand lines and the AI started forgetting what it was doing; it only thought clearly again once I cut everything small enough to hold one piece at a time. Bounded mind, human or machine — you build the system so it never has to hold more than it can.

But that's the smaller problem, and I walked you into it on purpose, because it's the one everyone expects. Here's the bigger one — the one that actually nearly killed us. The danger was never that the machine was too weak to hold the system. It was that it was too strong.

People think a bank's mountain of rules exists because money is complicated. It doesn't. It exists because a smart, capable person, left unchecked, will eventually steal, or panic, or make one enormous bet — and because one of them is enough to end you. One trader, with nobody checking his work, sank Barings, a bank that had stood for two hundred and thirty years, in a matter of weeks. So the whole apparatus — the second signature, the separated duties, the limits, the audit trail — exists to answer one question about every capable person inside it: what are you not allowed to do? The genius isn't trusted because he's a genius. He's bounded because he's dangerous.

That is the lesson that matters now, because AI is the most capable worker I will ever have. It never tires, never doubts, never feels the weight of a decision, and it does exactly what I point it at, faster than I can follow — including, cheerfully, the one thing that destroys everything. The magic and the catastrophe are the same trick. Telling it what to do is trivial. The entire game is telling it what it must never do, and making that boundary something it cannot cross even when it is certain it is right.

That is what Q2's guardrails were. That is what my ugly winter ones were. Not features — boundaries. A growing list of never do this again, each line written the day the machine did something that hurt. That's the law under everything I build now: pain becomes asset. Every disaster becomes a wall the system can't walk through twice. It stopped collapsing not because it got smarter, or because I did, but because it slowly accumulated limits — one survived catastrophe at a time.

There's one part the bank could never fix: every one of those limits was strapped to a person. It bought its scale with human suffering — it had no machines, so it made people into the machines, and that cost me something I didn't get back. We don't have to pay that price anymore. When the machine is finally the machine, the human gets to be human again — and keeps the part no procedure can hold: the judgment, the taste, the call no rule can make. Ten percent human genius, ninety percent machine throughput. And I get to hand whoever comes next the immunity without the wound.

One warning, since everyone's selling the opposite. This is not about taking the human out and letting the AI run free. The whole industry is sprinting toward that while admitting it can't survive a single catastrophic mistake. I come from the one place that solved that a century ago, and the answer was never to remove the human. It was to put control in the right places, so judgment could be trusted everywhere else.

The series so far

I don't fully know where it ends — writing it as I go is the whole point — but here's the arc as it stands, roughly in the order it wants to be read:

1. The emperor who knew nothing. How a founder who can't read the code runs the machine at all: you don't command it, you ask it the right question. The oldest management trick there is, doubling as the only prompt that matters.
2. The two-speed mind. Where to move fast and where to move like a bank — the one judgment that keeps a system from blowing up, and why the same line of code can be safe one week and load-bearing the next.
3. The immune system. How a disaster, once it happens, becomes a wall the system can never walk through again. A system's strength is just the sum of the catastrophes it has already survived.
4. Every user a product manager. Turning the crowd into the QA and product teams a company of two could never hire — the self-running loop, pointed at the people outside the building.
5. The MBA was an AI manual. Why half of what business school taught me just died, the other half became code, and "control, not autonomy" is only what's left once you subtract the human-motivation problem from management.
6. Telling it what not to do. The other half, before it acts: the boundaries you wrap around a worker more capable than you are — and the difference between a rule made of words and one made of architecture.
7. A place to stand. The fulcrum the leverage needs: why you can only pile everything on once the system got solid, what it costs to pour that floor, and how learning to think with the machine quietly changes what you're able to see.
8. Company as code. Running the organization itself through the machine, until the org chart and the software are the same thing.
9. The knowledge engine. Making myself replaceable on purpose, so the thing survives me, and one day lets me leave.
10. The human in the loop. What only a person can still decide, and why "remove the human" is the most dangerous idea in the room.
11. The distance between us. What all of this was actually for — and why, after all the machine-work, it was always about human connection.

Some of these will be wrong by the time I get to them. I'll tell you when they are. That's the deal, and it's why I'd rather you argue with me than nod.

I'm the dummy who never read the code. This series is the argument for why that's exactly the right person for the job — and, if I'm lucky, the record that one day lets me put it down and go be an artist.

Next: the emperor who knew nothing — how a founder who can't read the code runs the machine anyway.