A year of building SKU.io with AI agents. Every time one constraint disappeared, the next one showed up. This is the list, in order, with what removed each one.
Every number on this page comes from my own session logs, commit history and recorded calls.
Prompts I typed to agents each month, and how many sessions I usually had running at once. From September the typing flattens while automated runs climb: more of the work happens without me.
Claude Code took over the typing. The real change was running several at once: three terminals, then five, each in its own copy of the codebase so they could not collide.
▸ First session: Sep 2, 2025, 9:55 pm. First co-written commit four days later. 2,480 prompts in the first full month.
“The new thing to master is parallelization… managing the many AI workers that you could have running in parallel.”Oct 2025, a talk to a consultancy’s team
When execution is cheap, the spec is the work. Every feature starts as a PRD written into the repo, where every agent can read it; today a /prd command does the research and writes it. Agents implement from the file, not from a chat.
▸ First spec written into the repo: Oct 13, 2025. The /prd command followed in Feb 2026, and has run 331 times since.
“Natural language is the new UI.”Oct 2025, a workshop for CTOs
Reviewing every line of five parallel agents is its own bottleneck. I stopped reading code and started reading outcomes: the tests, the diff summary, and the pull request.
“I stopped writing code in July or August of last year and then I stopped reading code in November… the only thing you need to read is the PR.”Aug 2026, interviewing a developer
More features meant more to check. QA became a team of specialist sub-agents that drive a real browser and record a narrated video of the feature working. Then /confidence: an audit that pushes a task from 80% to 100% against its own spec.
▸ “Don’t stop until 100%” prompts rose from 17 a month to 46, then fell to under 10 once /confidence did that job.
“You should rely 100% on AI, but just have checks and balances in place. And that’s where the QA element comes in.”Aug 2026, interviewing a developer
One model grading its own work is not enough. A Codex review loop reads the branch, Claude applies only the findings it agrees with, and it repeats until the reviewer has nothing left. Three rounds minimum.
▸ First /codex-review-loop: Jun 6, 2026. 214 runs since.
Two dozen sessions are cheap; their builds, tests and browsers are not. A 32-thread Linux box now runs every heavy job, and live sessions can be handed to it from my phone. The laptop is for thinking, the server is for doing.
▸ Full test suite: 90 minutes → about 10. Busiest day ever: 622 prompts (Jul 7).
Features started shipping faster than customers could absorb them. Every release now carries a changelog entry that agents read, an AI-made walkthrough video, and updated docs. Writing the docs is the final QA pass: if it cannot be explained, it is not done.
“Now I actually publish YouTube videos that are AI created that go through the documentation. That’s the ultimate test… that’s like the final user acceptance testing.”Sep 2026, an operator redesigning his company around AI
This is the wall I am in now. Machines and model capacity are the limit again. Three computers already act as one fleet (every test, build and browser routes to whichever has room), which keeps work moving but does not remove the wall. Automated runs now outnumber the sessions I type into.
▸ Sep 2026: about 5,000 automated agent runs on the server, against 655 sessions I typed into.
Still standing · the plan to break it See my ideal setup → A 3D walkthrough of the machines I would add, what each costs, and which constraint it removes. Not what I run today.“Through the past year, the bottlenecks have changed every month or two.”Sep 2026
Compute is the bottleneck again. This is the plan for removing it, if money were no object: what each machine would be, what it costs and which constraint it removes. Toggle Today to see what I actually run.
loading the 3D plan…
It is the question every audience asks. The answer is that nothing reaches me until it has passed six gates I don’t have to run, and the seventh is me.
Scoped tests for the change while working; the full suite on every pull request in CI.
About ten specialist sub-agents: browser flows, UX, security, performance, migrations.
Codex reviews the branch; Claude fixes what it agrees with; repeat until clean.
Is this 100% done against the spec? If not, keep going before a human looks.
An evidence page and a narrated video of the feature working. I review it on my phone.
Writing the user documentation is the last QA pass.
I do acceptance testing and merge every pull request. Production changes need my click on the exact command.
Top to bottom: an idea comes in, gets planned, goes to isolated agents, runs on whichever machine has room, gets verified, passes the guardrails, and leaves memory behind for the next session. Hover a layer.
A skill is a written playbook an agent loads before it starts work. The ones that matter most in SKU.io come in sets: a standard, a skill that builds to it and a skill that audits against it, all written by a skill that builds skills. The example here is shipping providers, the warehouses that pick, pack and ship our customers’ orders. Each one we connect is a backend module, a fulfillment contract and about a dozen pages, and the first few took weeks of follow-up fixes after they “worked”.
drag to turn · tap a label
loading the 3D view…
Point it at a topic and it reads the git history and every past session for it, looking for fix commits and the moments I said “no, like this”. Each one is a rule that should have existed. The sync-modal spec I had retyped in at least five sessions became one.
Rules land in a single document: an exact snippet, a pattern you can grep for, a file to copy, or a command that must pass. “Be careful about X” is not a rule. Decisions that flip-flopped are written down with their evidence so nobody reopens them.
The build skill runs eight phases, from reading the provider’s API docs to visual QA, and reads the standard fresh every run, never from memory. The audit skill checks the result. Its job is to find nothing.
Every gap the QA gates catch, every correction I make and every fix applied twice goes back into the standard and the skills, logged with the commit or quote that taught it. One-off quirks are fixed and dropped. Anything that would reverse a settled decision stops and asks me.
Counts are from the standard’s changelog, where every rule is logged with the commit or the quote that taught it (2–23 July 2026): 18 rules mined from history when the skills were built, 32 learned since. The same pattern runs for sales channels, marketplaces, automation platforms and OCR: 191 rules across five standards, 113 of them learned at runtime. Faint sparks that die at the gate stand for one-off fixes that were not kept; those are illustrative.
When an agent gets it wrong, the fix goes into the skill, the hook or the CLAUDE.md, so the whole fleet never makes that mistake again.
“Anytime I don’t get the result, I want to stop just trying to fix the result and try to fix the harness.”
Things can take longer on the clock as long as they take less of me. That is what makes running many things at once worth it.
“It may take longer in world time to get things done, but it takes less time in human time.”
One loop ran six type-checks and two browser suites at once and took the laptop to a load of 77. Fifteen browsers took it to 868. Now a hook refuses heavy local builds and sends them to the server.
Agents cannot write to production. They file the exact command, I approve that string, and a separate process runs the identical bytes. Approving a description of a command is not approving the command.
An audit of six months of sessions found 44% of agent turns ended with an offer, and 29% of my replies were a bare “yes”. A hook now stops agents from asking permission for reversible steps.
When a rule that caused a real failure is deleted, a note stays in its place saying what it was and why it must not come back. Otherwise the next agent re-adds it as an obvious improvement. There are 122 of them.
Terminals are for doing. Anything I have to decide arrives as a page with the options, the trade-offs and a recommended default already marked.
“Terminal does not make it easy to make decisions, because it’s just the way our brain works.”
Reporting a bug in writing is slow. I record a quick spoken walkthrough of what is wrong, paste the link into a session, and the agent watches it and fixes it. I have done that 84 times since July.
“Please watch this video and fix the issue.”
When building is this cheap, the nice-to-haves become haves. Agents are told to go past 80%, every time.
“Just don’t stop at 80%, go to 110% every time.”
Write-ups on each layer are coming: the commands, the hooks, and what breaks when you run two dozen agents at once. Get an email when one lands or this page changes.
Last updated . This page changes as the setup does.
Method: prompts from my Claude Code prompt logs on the laptop and the server. They start on Sep 27, 2025, when the
log begins, 25 days after my first session, so the count is a floor; sessions, tool calls and concurrency from
63 GB of transcripts across my machines (Mar 2026 onward; earlier transcripts were not kept); a session counts as running at once if it was active in the same 10-minute window, so idle open sessions are not counted; commits from git. Quotes are mine, from recorded calls,
lightly edited for reading.