One person.
An agent fleet.
I'm the only human on this team. Everything else — the orchestration, the grunt work, the parallel builds, the review — runs through an agent fleet I built and keep tuning. This is what that actually looks like, not the pitch version.
The shape of it
Claude Code runs as an orchestrator. It doesn't write every line itself — it plans the work, then delegates pieces to subagents that each get a narrow, well-scoped job: research a pattern, draft a component, run a check, write a test. Parallel work happens in separate git worktrees, so multiple agents can build on the same repo at once without stepping on each other's changes.
- Always-on infrastructure. A VPS runs the parts that shouldn't stop when I close my laptop. At the time of writing it has been up 181 days without a restart, running an agent orchestrator and a memory server that have each been resident for months rather than spun up on demand, plus 13 scheduled jobs and 10 cron jobs across 46 tracked projects. Work in flight gets its own environment: a branch can run as its own service with its own database container, so two versions of a product can be live locally at once.
- Memory across sessions. Decisions and context persist, so a session picking up a thread three weeks later isn't starting from zero.
- A compounding post-mortem loop. When something breaks in production, the fix and its root cause get written up as a doc under
docs/solutions/. Future sessions read those before touching similar code, so the same mistake doesn't get shipped twice. - Enforcement hooks, not good intentions. Hooks audit sessions and block deploy claims that don't have a verification artifact attached — a file, a log line, a screenshot. "Trust me, it works" isn't a valid commit message here.
The pipeline, drawn plainly
Orchestrator plans, subagents build in parallel worktrees, review gates check the work, and only checked work ships.
How one of them got chosen
Motion can't be judged from a description, so the Crystal Field hero was decided by building the candidates rather than arguing about them. Twelve directions, each a self-contained page with real copy and working CTAs so they were comparable; then feedback rounds against the published set; then a winner that combined two of them. The candidate files were never committed and no longer exist — this is the decision, not a gallery.
The experiment engine
66 repos in 18 months.
Experiments are cheap on purpose. AI made starting so cheap I could try almost anything — a gold-mining simulation, pitch-deck agents, property tools, trading experiments — and every one that didn't ship became feedback the next build inherited. That loop is why a month of work now fits in a day, and why what ships survives the last 20%: the edge cases, the accessibility pass, the failure states.
“The first version is intoxicating… Usually, it is about 20% done.”
The Last 20% Takes 80% of the Work
“Each one bought knowledge the next build inherited.”
66 Repos in 18 Months: The Experiment Engine
This site is the portfolio piece
The site you're reading was built exactly the way I've just described — orchestrator, scoped subagents, parallel worktrees, and a review gate that blocks a claim without an artifact behind it. That's checkable without my say-so: every piece in the work carries its shipped-or-prototype state marker in the open content files, and the homepage receipts land on the case files that substantiate them. Behind it sits a DESIGN.md the system is held to and a docs/solutions/ post-mortem archive that feeds fixes back into later sessions — those live in a private repo, so take them as context for the working method rather than as something I'm asking you to verify. It isn't a case study written afterwards. It's the working artifact.
That's the machine.
This is the workflow every piece on the site came through. Hire the person, or hire the machine.