What one person can build now

AutonomousAJ is that bet and, at the same time, the proof of it. The thesis is easy to say out loud: you can own your digital infrastructure now — your identity, your tools, the agents that do the work — instead of renting all of it from other people's platforms. And if you own it, one person really can operate like a team. Behind the public name there's a command center that plans and ships the projects, and a fleet of agents that runs them. I keep the machine itself private; what I can show you is what it produces. This portfolio is, in a real sense, its output.

I want to be honest about what that actually feels like day to day, because “autonomous agent fleet” sounds more like science fiction than it is. In practice it's three quieter things. It's scale — I ship far more than one person reasonably should be able to. It's continuity — work moves even when I'm away from the keyboard, so I come back to progress instead of a cold start. And it's focus — the system absorbs the sprawl of a dozen projects so my own attention can go to the decisions that actually need a human. Less robot army, more a very capable collaborator that never sleeps and doesn't mind the boring parts.

If I lift the lid, the machine is less exotic than the word “fleet” makes it sound. At the center is a command center — a Django application that holds the system of record, with a fast read layer bolted on beside it so the public side can read from the truth without ever being able to write back to it. Around that runs the fleet itself: agents I point at problems, and when two of them need to work the same repository at the same time, each one gets its own git worktree so neither edits a file out from under the other. When one project needs something from another, it doesn't wait for me to carry the message by hand — it files a request onto a single shared list that every project reads from. One person operating like a team turns out to be mostly this: a lot of small, unglamorous plumbing that lets work happen in parallel without collisions.

The agents don't run loose. I write their instructions in a deliberately narrow subset of English — short active sentences, one idea to a sentence, the same word for the same thing every time — so that an instruction means exactly one thing to the agent that reads it. And before an agent builds anything substantial, the ritual is the same: plan it, then adversarially attack the plan, then build — because the cheapest place to kill a bad idea is on paper, before it becomes code I have to unwind. None of this is magic. It's a small number of disciplines applied relentlessly, which is a very different thing from a machine that thinks for me.

I keep coming back to how improbable it is that I'm the one doing this. A former medical-device rep who taught himself to program a few years ago. That's not false modesty — it's the whole point. If the barrier dropped far enough for me to build this, it has dropped for an enormous number of people who haven't noticed yet.

Which is why the part I actually care about isn't the machine. It's giving the pieces of it away. I've been pulling reusable components out of my command center and open-sourcing them, so other people can assemble their own version — one shaped to their life, not a copy of mine. The private system stays private; the building blocks become public. I would much rather be early to a pattern other people can use than sit on a clever thing only I have.

Because the thesis only means anything if it's true for more than one person. “Own your infrastructure” is a hollow slogan if the single way to do it is to be me. The open-source pieces are the argument made concrete — here, literally, are some of the parts. Build the thing that works for you.

I also want to be straight about the uneasy part, because a system like this has a genuine double edge. The hard question isn't capability — it's control. How much do you let run unattended? A system that ships work while you sleep is wonderful right up until it does something you didn't intend, quietly, at scale. So a surprising amount of the real work is the unglamorous kind: guardrails, checks, keeping a system I increasingly lean on legible and honest to myself. Owning your infrastructure means owning its failures too, and I think anyone who tells you otherwise hasn't run one for very long.

Concretely, that caution is built into the tools, not into my willpower. Anything that overwrites live state takes a snapshot of what it's about to replace first, so the undo exists the same instant the change does. My production deploy validates its own configuration and rolls itself back to the last-known-good version the moment a health check fails, so a bad push is a non-event instead of an outage. And the one genuinely irreversible step in the pipeline — the reload that puts a change in front of real people — sits behind a deliberate human gate that only I can clear. The machine runs freely everywhere the cost of being wrong is a log line, and it stops to ask everywhere the cost is real.

I'll also say plainly that the public face of all this is early. Today the site is closer to a working notebook than a finished statement of the idea — and I'd rather the machine behind it be real and the storefront be honest about itself than the other way around.

Where I want to take it next is selective openness. Right now the command center is all-or-nothing private, and that's the wrong shape long term. The thing I want to build is a way to open scoped, read-only windows into it — to let a person see the parts I choose to show, while everything that needs to stay private stays private, and nobody can touch or change what's underneath. This is why the read layer is a one-way seam in the first place: a window I can open is only safe if looking through it can never reach back and write. Owned infrastructure I can open a door into, on my own terms. That's the next real piece of the puzzle.

Mostly, though, I think of myself as a guinea pig. This is a personal experiment in something I suspect is coming for a lot of people: the slow shift from renting your digital life to owning it. I could be wrong about the details — probably am, about some of them. But I'd rather run the experiment in the open, share what works, and find out than theorize about it from a safe distance.

The name is a little on-the-nose — my own initials, “autonomous,” as if the goal were to automate myself out of the picture. But that's not quite the idea. The point was never to remove the person. It's to give one person more reach than one person used to have — and then to leave the blueprint where the next person can find it. I'm not trying to build a machine that runs without me. I'm trying to find out how much a single, well-equipped person can do now, and to hold the door open behind me.