I'm a corporate lawyer. My day job is reading contracts and arguing about what happens when someone breaks them. I still can't read code. If you open a Python file in front of me I can pick out the strings, the comments, and roughly where the sentences end.

Three months ago I decided to build myself an information system anyway, with AI writing all of it. Today it runs my mornings. It collects market data and news on a schedule, files everything into a local database, runs thirteen property tests against the live system every Saturday, pushes an encrypted backup offsite every night, and writes itself a weekly health report with five service-level objectives. If a metric fails two weeks in a row, a rule freezes new features for that part of the system until it recovers. Last weekend I pointed the same machinery at a research question: how do people my age actually work and live, across thirteen countries. Two AI systems, from different companies, working blind from each other, then compared.

I wrote none of that code. I am responsible for all of it.

People ask how that's possible without it being a house of cards. This is the honest answer.

Define "production-grade" first, or the argument never starts

I stole my definition from my day job. A contract isn't good because no one will ever breach it. It's good if breach is detectable, the damage is bounded, and the file explains itself to a stranger two years later. So before building anything I wrote down what I wanted from the system:

  • if something breaks, my own monitoring finds it before luck does
  • if the machine dies, the data survives, and recovery is rehearsed rather than assumed
  • promises get written down and measured weekly
  • decisions get written down so future me doesn't have to guess
  • failures leave a record, and the record has a closure rule

None of that requires me to understand the implementation. That was deliberate. It's the only definition a non-coder can actually enforce, because it's all behavior and no internals.

The part I actually do

The AI writes. What I do is closer to what I do at work.

I ask code the questions I'd ask a witness.

If this failed silently, how would I know? Most components fail quietly. My offsite backups uploaded empty files for about two weeks once. The API returns a zero-byte file and an error message dressed up as a login problem. Reading the code would not have caught this; the code looks correct. What caught it was a test that downloads the remote backup and decompresses it, every single run. "The script ran" and "the artifact exists" are different claims. I've stopped confusing them, mostly because I did, once, for two weeks.

Who else checked? I run two AI systems from different providers. They research the same questions without seeing each other's work, then I compare. On the thirteen-country project, one engine gave me a youth unemployment figure for Korea: 15%. Verification against the original statistical release said 18.3%. The two engines had blended different baseline years. I nearly published the wrong one into an article. The correction is in my records now, with a date on it, which is where I want corrections to live.

Where's the paper trail? Six one-page records, one per major architecture decision. One of them says, in effect, that rebuildable data doesn't board the lifeboat: search indexes don't go into the backups because they can be regenerated. That decision exists because the naive version kept crashing on a bug in someone else's database extension. The bug is theirs. The decision not to touch that code path is mine, and it's on paper.

There's also an incident log. Eight entries so far, each with what happened, the root cause, the blast radius, and the fix. I borrowed the closure standard from audit work: an incident isn't closed when it's fixed, it's closed when something exists that would catch the same failure coming back. Four of the eight still owe me their probe. I know which ones. The health report knows too.

What went wrong that no test caught

Me. Twice.

For a while I was writing event timestamps into logs from memory. Three turned out wrong. I went hunting for the bug in the machine and checked the system clock against an atomic reference. The machine was fine. I was the unreliable component. The fix is a rule now pasted into my operations manual: every timestamp gets copied from the system clock, never typed. A rule for me, about me, in a system that is otherwise entirely software. It's in bold, which I find embarrassing, which is why it works.

The other one: an early monitor watched whether a file had changed. Git rewrote the file one night without changing its content, and the monitor announced new mail that didn't exist. It now triggers on growth rather than modification.

The first disaster drill — you rehearse total machine loss, the way buildings rehearse fires — restored everything in about five minutes except one component that needs a password typed by a human hand. That exclusion is by design, and the drill confirmed it works as designed, which is what drills are for.

I should be honest about the texture of this work. Most of it isn't clever. It's a lawyer at 1am asking a model to explain, again, the difference between two claims, and not going to bed until there's a test that knows the difference too.

What the human does

I set the requirements. I decide which risks to accept and what stays private. I read the weekly report and act on it, or decide not to, and both get logged. I pay the subscriptions; that's the entire capital expenditure side of this company. And I supply the judgment the models shouldn't have. On the thirteen-country research the rules were: primary sources, multiple languages, every country shown with its strengths and its failures, no rankings, no cheerleading from any direction. The engines execute that policy. The policy is mine.

The leverage is real but narrower than the noise suggests. The system doesn't judge anything. It makes me harder to fool and slower to panic, and it does at 2am the checking I used to not do at all, because I was tired.

If you take one thing from this, take the three questions I ask before accepting anything an AI built, including my own:

  1. If it failed silently, how would I know? No answer means build the detector first.
  2. If it died completely, what survives, and when did you last actually restore it?
  3. Why does it exist in this exact shape, and where is that written down?

Then be stubborn about the answers, the way you would be with any other witness.

I still can't read the code. I've stopped thinking of that as the gap. The gap I watch now is whether my verification stack would tell me if I were wrong. So far it has, every time, including once about my own memory.