Shipping solo with AI: who owns the architecture when the AI writes the code

Let me be honest about how I work, because the honest version is more useful than the flattering one.

AI writes most of my code. Claude Code, Codex, Aider — they generate the implementations across my projects. I'm not going to pretend I hand-typed every line of Mnemix to sound more like a "real" engineer. That would be a lie, and anyone who interviewed me on the code would catch it in five minutes.

But here's the distinction that actually matters: writing the code and owning the system are not the same job.

What "owning it" means in practice

The AI produces an implementation. My job is everything around that:

• Deciding the architecture before a line gets generated — what the memory path looks like, why Redis at the edge instead of a database call to origin, what the failure modes are.
• Defining what "correct" means. The model will happily generate something that runs and is wrong. The eval, the test, the "does this actually return the right caller context in under 300ms" — that's mine.
• Debugging when it breaks. When the orchestrator was burning $14/day idle, no AI flagged that. I traced it. The model wrote the code; it didn't notice the code was bleeding money.
• Redirecting. Most of the real work is rejecting the first answer, knowing why it's wrong, and steering toward the version that fits the system I'm holding in my head.

The AI is fast hands. The architecture, the judgment, the taste, the "this is the wrong abstraction and here's why" — that doesn't come from the model. If it did, the model could do my whole job and wouldn't need me to drive it.

The test that separates the two

Here's how you tell whether someone owns AI-generated work or just prompted it: ask them to explain a decision and then change it.

"Why this vector DB over that one? What breaks if traffic 10x's? Walk me through what happens when the retrieval misses." If the answer is "the AI chose it," that person doesn't own the system — they're a passenger. If they can defend every decision and tell you what they'd do differently at scale, the code being AI-generated is irrelevant. They own it.

I hold myself to the second standard. Not because it sounds good, but because the moment something goes down in production at 2am, the AI isn't on call. I am.

Why this is the actual job now

The frontier labs already know this. Their own engineers use these tools heavily. The skill that's becoming scarce isn't typing code — it's the judgment to direct a system that can generate infinite code, knowing which version is right, which is subtly broken, and when the simplest non-AI answer beats all of it.

That's the job I'm training for and the job I already do solo. AI writes the code. I own the system. If you can't tell the difference, you've never had to debug something a model confidently got wrong.