justadev

Machine

I'm one person. Every other role in the company is an AI agent. A Claude session runs the work, other agents write the code, and nothing counts until it runs live. This is the loop, step by step.

The loop, step by step

The loop, in order: I set direction. The orchestrator splits the work into lanes and writes their specs. Lanes write code in parallel, each in its own files. The orchestrator runs the result and records a verdict. A failed lane goes back for a fix round. Verified work ships, and the live page goes back to me. Every incident becomes a rule in shared memory that the orchestrator and the lanes read. The ledger records the estimate, the verdict and the measured time of every task.

  1. Chairman

    Me. I set direction and approve.

    I decide what gets built and I judge it on the live page. Routine choices are not mine to make. Four things come back to me: money, irreversible deletes, exposed secrets and changes of scope. Silence counts as approval.

  2. Orchestrator

    A Claude session that runs the work.

    It splits a big task into lanes that own separate files, writes one spec per lane and dispatches the lanes in parallel. A ten-minute fix it does itself. It estimates before it starts, verifies what comes back, then merges, deploys and loads the page. It stays on until every lane is verified and live.

  3. Lanes

    Agents that write the code.

    Today the lanes run Claude Opus 5.5 for complex units and Claude Sonnet 5.5 for the rest. Codex carried most lanes until 12 October 2026, when I stopped spending Codex credits. Grok has written no code since 23 September 2026; it reviews and researches. Every lane gets one written spec, its own files, its tests and a ban on every git command. A lane never delegates.

  4. Verify

    Run it yourself.

    A lane's PASS is evidence, not truth. The orchestrator runs the code, traces the real call chain, tests against the real database and opens the page as a logged-in user. Then it records one verdict: pass, fixed or failed. That verdict is the only quality number a model gets.

  5. Ship

    Commit, push, deploy, load the live page.

    Work that is not pushed is invisible, so it is not done. Every landed change gets committed, pushed, deployed and opened in a browser. A green test suite is a rumour. A live URL is a fact.

  6. Memory

    One rule store every agent reads.

    Claude, Codex and Grok read the same rules from one canonical store. Each rule names the incident that wrote it. A memory agent checks the store every day and reports every Sunday. It fixes structure by itself. Changes to content come to me as proposals.

  7. Ledger

    Every task estimated, every task measured.

    Each non-trivial task starts with an estimate and ends with a measured time. The ledger checks every start and finish against the agent's own session transcript, so a self-reported time does not count. Before it estimates or picks a model, the orchestrator reads each model's measured multiplier.

What the loop did, measured.

Live numbers from the timing ledger. A run is one delegated lane run. Busy hours are the time models spent working inside their sessions.

The last 7 days

Delegated lane runs
519
Agent sessions
617
Model calls
53,625
Busy agent hours
253
Models that worked
7
Passed verification first time
136 of 181 verdicts

The last 30 days

Delegated lane runs
2,576
Agent sessions
2,959
Model calls
140,273
Busy agent hours
805.5
Models that worked
15
Passed verification first time
136 of 181 verdicts

805.5 busy agent hours in 30 days. A 30-day month has 720 hours. The agents work in parallel. Measured , from harness records only: session transcripts and the runs the harness started.

Rules written in production.

Every rule the agents follow came from an incident. Each entry in the log is stamped with the day it happened, when the record names the day. Open one to read what happened.

  1. No. 01

    Agents never run git.

    On 30 July 2026 an agent ran git pull --rebase in a repo that kept a live database in git. The checkout overwrote it. 475 uncommitted outreach rows were gone: the sent count fell from 841 to 366. The send script picks people who were never contacted, so a lost history means mailing them twice. The agent had been told not to commit, and it did not commit. Every spec now bans all git commands, and the database is backed up every 30 minutes outside git.

  2. No. 02

    A deploy that resets a checkout refuses a dirty tree.

    On 3 August 2026 a deploy script ran git reset --hard on a directory where another session was editing. It erased about two and a half minutes of uncommitted work, and the reflog said nothing about what it ate. On my server the deploy target is somebody's desk. The deploy scripts now abort on a dirty checkout and print the worktree command instead.

  3. No. 03

    A lane's PASS is evidence, not truth.

    On 23 July 2026 Grok reviewed a parser Codex wrote and returned FAIL. Running it showed 18 of 18 cases passing. The defect was the orchestrator's: it had paraphrased the spec differently for writer and reviewer. With one shared spec file the reviewer returned PASS, and 29 executed cases agreed. Now the spec is written once, handed over verbatim, and the code runs before either verdict counts.

  4. No. 04

    Every merge gets a live check.

    One night twelve lane tasks merged with green tests. All twelve needed a fix afterwards: a crash on the most common signup path, a credit gate that stranded all twelve live accounts, a demo that shipped one business another business's brand, and a service fix committed to git but never deployed. The agents verified against their own tests. The orchestrator now verifies against the running system and the real data.

  5. No. 05

    Test against the real dependency.

    A storage test mocked the database client and asserted that a Buffer was passed. The real client serialised that Buffer to JSON text, so every encrypted credential was stored corrupted and could never decrypt. The suite was green while the feature was 100% broken. It surfaced on the first real write, read and decrypt. Binary and encrypted storage now needs a real round trip in the gate.

  6. No. 06

    Green units do not prove the seam is wired.

    The one function that turned a parked preview into a real post had thorough, green unit tests and zero production callers. The UI never rendered its button, and the inbox never fetched the state it handled. Users pressed Try again and re-ran the dry run forever. A review of the call chain found it. The unit suite never could have.

  7. No. 07

    Safety lives in the harness, not the prompt.

    A preview mode had to guarantee that nothing posted without a human confirm. The worker intercepted the submit action but let a click run unchecked, so the guarantee rested on the model choosing the safe verb. The prompt's own example told it to click Submit. A preview could post live to a real account, and all 101 tests passed, because the fakes never clicked anything real. Irreversible actions are now refused in code.

  8. No. 08

    Ask what the user sees before you audit.

    A chat page felt glitchy. Five rounds of code review across three models found 12 real bugs. None of them was the one I reported. When I described what I saw, the chat scrolling down to the present instead of opening there, the cause was one smooth scroll that fired on every new message. The fix was one word.

  9. No. 09

    A checker's timeout is not a measurement.

    A hover probe reported 190 to 202 ms against a 180 ms limit, then 115 to 123 ms against a 100 ms limit. Two fix tasks were ordered and one regression was escalated to me. With the limit at 4000 ms the probe reported 4015.6 ms. It had measured its own timeout every time. Nothing was slow. The first step now is always the same: raise the limit and run it again.

  10. No. 10

    Every loop that spends money has a hard off switch.

    On 5 July 2026 one agent had spent $52.78 in 48 hours. I stopped the fleet that day: 31 timers on the server, and the loops on my PC with them. The stop-loss had only moved calls to cheaper models; it never stopped one. The control page now has STOP ALL, a restore of exactly the same set, and a toggle per unit.

  11. No. 11

    A new gate reads the same switch as the gate beside it.

    A credits gate charged regardless of the billing flag and regardless of who was grandfathered. Every account sat at a balance of 0, so it refused all work for all twelve accounts, including a person who had signed up that evening. Running the gate against the live database caught it before push. The tests passed because they created their own fresh accounts.

  12. No. 12

    Check the field that carries the meaning.

    An agent was asked for 150 new page structures. It returned six theme names crossed with 25 layouts, so each structure appeared six times under six names. It passed every check: 315 entries, unique names, 260 green tests. The checks counted names, and names were the one field the grid varied. Now the check counts distinct content, and the orchestrator reads samples from the start, middle and end.

The rules come from incidents. The numbers, and what they can and cannot say, are on Research.

Read the research