243 agent threads in a week: how I rebuilt Shuffl from my phone

What does one person with agents ship in a week?

I rebuilt Shuffl by talking to coding agents on my phone: on a sailboat, lying in bed, dictating on the drive to daycare. I never opened my laptop. Here is what that added up to by September 28.

agent threads since September 21

243

threads started in 38 seconds

10

merged pull requests

556

commits on the busiest day

127

computer-use jobs on my Mac

45

pull requests a person reviewed

0

What does a prompt look like?

All day I rattle off thoughts into voice-to-text, one after another. Build this. Go check the page that just went live. That button is wrong, here’s a screenshot. I don’t wait for anything to finish. A coordinator agent decides whether each message is new work or belongs to a thread that’s already running, and routes it there. It’s an ADHD brain’s dream.

The prompts are rough. This post started as the message below, “use in physical” and all (it meant Infisical). From that one message the thread found its evidence in the repository and GitHub, wrote the post, drew the diagrams, screenshotted the page on desktop and phone and opened the pull request.

Maybe we actually write another blog post next to this that kind of dives deep into how we did this um, technically. So we can like show this off from an engineering perspective. […] make it technical add like diagrams um, you know talk about how Astra used computer use to create new accounts and create API keys and use in physical […] I think that’s like the huge takeaway.

How do 243 threads run at once?

Every thread gets a fresh cloud container. A start-up hook installs Node, starts PostgreSQL 17 with pgvector and seed data, and gets Chromium ready, so the agent can run the real app and the whole test suite. It builds the change, screenshots every screen it touched, pushes, drives the pull request green, merges it and sends me the screenshots.

Decisions go into shared project memory. When I say “every new feature ships with analytics events” once, every later thread already knows.

Does it stop when I sleep?

Long jobs keep going after I stop talking. On September 23, 57 commits landed on main between midnight and 6 AM.

What came before Projects?

The first two weeks ran from one Apple Notes checklist, and I never logged into GitHub. One checkbox just said “Celebrations”. Codex turned it into an issue with acceptance criteria and a full implementation prompt, and nine days later the feature was in the product. By September 25 the note had 229 checkboxes and 144 were ticked. The catch was that an idea could wait a day for the next sync, and Projects removed that wait.

How do you make a repo agents can work in?

Every thread starts cold, so whatever it needs has to be written where it will look or enforced by a check it can’t skip.

• An AGENTS.md with the working agreements: product rules, UI rules, where each kind of test goes, how to run the app.
• One Next.js app with the business logic in one shared package, so there is one obvious place for everything.
• Append-only migrations, 148 so far. Each agent renumbers its migration to the next free number right before it merges.
• Rules written as tests. A test fails when an API mutation has no analytics event, and the push is refused when a screen changed but its docs screenshots didn’t.

How fast is the CI loop?

With nobody reviewing code, the checks are the review. At first every push ran them on GitHub’s runners, about 1,000 billed minutes a day. So a thread moved CI into the agents’ containers, which already had the database and toolchain. The pre-push hook now runs everything in about seven minutes, and main releases itself when its hourly checks pass. When main goes red, the coordinator starts a thread to fix it.

Why is computer use the biggest lesson?

After the first week, code stopped being the slow part. Everything behind a login was: new accounts, API keys, console settings. Cloud agents can’t sign in as me, and I don’t want production secrets in their containers.

So when a thread hits a step that needs my accounts, it files a GitHub issue labelled computer-use that another agent can follow without me. I point Astra at the label and it works through the queue in my signed-in browser. One thread even kept the Mac awake for a week so the jobs could run overnight. Some of what the 45 jobs did:

Goal: one sentence on what should be true when you are done.

Rules: use my signed-in browser. Stop and ask at any login, 2FA or passkey prompt. Keys go from the provider’s copy button straight into the secrets manager, never into a screenshot, chat, file or GitHub.

Steps: numbered, one click path each.

Verify: how to prove it worked without printing a secret.

Report: comment here with what changed and no secret values.

• Set up Stripe’s products, prices and customer portal in test and live mode.
• Made a read-only Stripe key and a read-only database role, so cloud threads can look at production without changing it.
• Created the npm organisation, published the SDK and CLI, and turned on trusted publishing.
• Put keys into Infisical, checked they reached Vercel and redeployed.
• Exported all 35 tables of the old Shuffl database and checked each one against hashes and row counts.

Code stopped being the slow part. Everything behind a login was, until computer use.

What is the biggest computer-use job?

The biggest job is moving the old Shuffl, its own servers and database, onto the new platform. Cloud threads wrote the exporter, the converter and an import runner that can verify, go live and roll back, and the steps that need my accounts run on my Mac.

After the export, a read-only comparison against the live database found timestamps shifted by a time zone. The agent marked that export archive-only and asked for a corrected one. I wouldn’t have caught that by hand.

How do I copy this setup?

If I started over, I’d set it up in this order:

1. Write an AGENTS.md for an engineer who has never seen the repo, then turn its most expensive rules into tests.
2. Add a start-up hook that gives every agent session your database, seed data and a browser.
3. Run CI in a pre-push hook inside that session, and keep GitHub to a fast gate plus an hourly check on main.
4. Send every thought as its own message and let a coordinator route it. Let the agents merge once the checks pass.
5. Turn every job behind a login into an issue shaped like the template above, and let a computer-use agent work the queue.
6. Keep a short list of things that can’t be undone, and make each one wait for a typed yes.