00 a one-operator AI studio
I had more ideas than hours.
So I cloned the part of me that builds.
I've got a full-time job and a head full of products I'll never get to. AJ AI is my answer — I copied my own context and judgment into an operator that works while I sleep, and called it Agent AJ. It builds real software and audits its own work. And it doesn't ship anything that matters until I've signed off.
01 the why
The bottleneck was never the ideas. It was me.
I keep a running list of things worth building. It grows faster than I can touch it. I'm not short on ambition or a plan — I'm short on the one thing nobody sells more of, which is hours. Nights and weekends weren't enough, and standing up a team for side bets I hadn't proven made no sense. So I asked a different question: what if the bottleneck, me, could be in two places at once?
one person · a list that never shrinks
02 the bet
So I stopped trying to use AI and started trying to clone myself.
A tool waits for instructions. I didn't want another tool — I wanted a second me. So I poured in the context: my projects, my decisions, the way I weigh a trade-off, even the dead ends I'd already walked into.
The system
AJ AI
The system. One machine running one loop I'd recognize anywhere — classify → route → execute → persist — over real tools: Claude as the kernel, a vault as its memory, executors that write actual code, and a scheduler that takes the night shift.
engine · vault · router · audit pipeline
The operator
Agent AJ
AJ, cloned into an AI operator. It carries my context, my projects and my judgment — does the building, runs the audits, drafts the calls — and leaves anything irreversible for the human me to sign.
the clone builds · the human signs
03 the fear
An operator that never sleeps is only worth it if it's never reckless.
Here's the part that actually kept me up. An autonomous version of you, writing real code and reaching into real systems, is a gift right until it's wrong and sure of itself. Speed I could build in a weekend. The hard part, the part I had to engineer on purpose, was a conscience: a way for it to move fast all night and still never do the one thing I'd regret in the morning.
Most AI sounds sure of itself. That's the problem I had to solve before I could trust a copy of me.
04 how it works
Every job I hand it takes the same honest path.
A build, a brief, an audit — all of it runs one loop. Read the request, route it with a deterministic router that adds zero LLM cost, do the real work with real tools, then write down what happened. The last step is the one most systems skip: it remembers, in writing. Here it is running right now.
classify
Read the request. Decide what kind of work it is.
route
Deterministic router picks the model + tool — zero added LLM cost.
execute
Real executors do the work — code, research, audits.
persist
Everything written down — vault is memory, ledger is audit.
05 the conscience
Nothing that matters ships until it's survived four checks — and the last one is me.
Every build, every deploy, anything that touches money runs a gauntlet before it goes anywhere. Deterministic lints catch the dumb stuff. One model reviews the logic. A second, independent model tries to tear it apart — one model never grades its own work. Then it stops. At me. A human signs, or it doesn't ship.
I also made it write the failures down. Most of building real AI is paths that go nowhere — they live in the vault instead of getting quietly buried, because an honest record of what didn't work is the whole reason to trust what did.
06 what it ships
It acts in your real tools. It opens PRs and files issues, it doesn't just advise.
This is where it stops being a clever idea and starts being a studio. Agent AJ reaches into the same tools I do, through the same connectors a developer uses (MCP) — so it acts instead of advising.
opens PRs · files issues · drives a browser · pulls live docs
It built receptr — an AI receptionist that answers texts for local businesses when they can't pick up — and it's at work on the next ones. The studio does this work done-for-you. receptr is built, tested, and launching with its first businesses.
~1,668 tests · ~2,002 notes in the vault · one machine · ~$400/mo — not projections, the current state of the thing you've been reading about.
07 what's next
The clone was step one.
The point is everything I can aim it at next.
Proving I could clone the build was the hard part, and that's done. Now the same engine points outward — done-for-you AI for people who have the problem I had: more worth doing than hours to do it. Today it runs one loop on one machine and audits its own work before anything ships. Where it's headed: wired into the rest of your stack, working around the clock, a goal handed in and finished work handed back.
The full deep-dive — the architecture, the vault, the deterministic router, the model lineup and the audit pipeline, laid out the way an engineer would want it.
Or, if you've got something worth building, that's a better conversation. Either way — I'm still the one signing off.