Built in a day by a swarm of agents: what worked and what broke
We built the first Tinkerbee from 21 tickets with one coding agent per ticket, in parallel. Here is the setup that kept them out of each other's way, and the four things that broke.
Karthik and the Skcript R&E team

On November 19 we started with an empty repo at 5:47 in the evening. By 10:44 that night, all 21 tickets for the first version of Tinkerbee had merged to main and deployed to tinkerbee.io. Each ticket was built by its own coding agent, Claude Code, many of them at the same time.
This is the honest version of that day: what we set up before the first line of code, what kept a crowd of agents from stepping on each other, and what broke anyway.
The work before the work
The agents were fast because the thinking was already done. Two days earlier we started grilling our own one-paragraph goal, one question at a time, with the same method Tinkerbee runs. By the time we wrote code we had:
- 99 Decisions, each with an ID and a reason,
- 8 ADRs,
- a Glossary, with the words to avoid,
- a Spec with 166 user stories,
- and 21 tickets, numbered so that blockers come first.
Every ticket said what to build, what blocked it, and its acceptance criteria. An agent picking up ticket 14 (Todos) could see that it waited on 05 (Decisions) and 08 (comments), and nothing else.
That plan was the real product of the first two days. The code came from it.
Rules that kept the swarm apart
Twenty agents writing to one repo will collide. We wrote a short set of rules into the repo's instructions file so every agent read them first.
One feature, one module. Each feature lives in its own folder in the API and exposes one router. Registering it is one line in a shared routes file. Shared files stay tiny, so two agents rarely touch the same lines.
One ticket, one branch, one PR. Branch NN-slug, PR titled NN: <ticket title>. Nobody bundles two tickets.
One test seam. Tests drive the backend over HTTP only, with a fake LLM and a fake GitHub. This was an ADR, not a preference. It meant an agent could change anything inside a module as long as the API kept its promises, and every other agent's tests would still tell the truth.
A mock API for the web. The web app runs against an in-memory mock with one flag, so a front-end agent never waited for the matching API ticket to merge.
Speak the Glossary. Agents were told to use the Glossary's terms exactly. A Spec is never a "doc". The code, the UI and the tests ended up using one vocabulary, which made review faster than we expected.
How a ticket went
An agent took a ticket, read the plan, built the API module with its HTTP tests, built the web page against the mock, and took screenshots in light and dark. Then it opened a PR. CI ran on our own self-hosted runners: clippy and the tests for the Rust API against a real Postgres, and the type check and build for the web. A green PR merged, and main deployed to production through Coolify.
Most tickets merged within minutes of each other. Some had to rebase over three or four others first. Ticket 10, the Grill preview and Tinker ✨, rebased on 09, 13, 06 and 20 before it went in.
What broke
Four things, in the order we hit them.
The CI workflow was invalid
Our first workflow put job.services inside a job-level env, which GitHub Actions rejects. Nothing ran. The fix also added a deploy job that runs on the same runners after CI goes green.
The deploy trigger used GET
The deploy job called Coolify's deploy endpoint with GET. Our Coolify version answers that with a 405. One line changed it to POST. Small, but it was the difference between "merged" and "live".
A rolling deploy orphaned background jobs
This was the interesting one. Coolify deploys with a rolling update. The new container boots, runs its startup recovery, and only then does the old one stop. During one deploy, a new repo connection started an ERD snapshot and a Glossary guess on the old container. The new container had already run its recovery. Then the old container stopped and took both jobs with it.
Nothing marked them failed, so the UI showed "running" forever, and no error was logged anywhere.
We ruled out the obvious suspects first. The model provider replied in about 23 seconds on an ERD-sized prompt. The GitHub App token and the clone both worked. The bug was in our assumptions about deploys, not in any one service.
The fix had three parts:
- A sweep runs every minute and fails any run older than its timeout plus a minute, with a reason.
- ERD snapshots got their own run records, with a timeout, a stored error and startup recovery, like grill rounds already had.
- Calls to the model provider now time out, and a git process is killed when its run is.
The lesson for us: any background job needs a record that something other than the process running it can see and close.
A button pointed at nothing
After all 21 tickets merged, we ran a read-only audit with a separate model, Fable. It checked each of the 166 user stories against the code. It found real gaps. The Overview page had an "Import docs/adr" button that posted to a route that did not exist. Specs were missing their counts of Open Questions, Todos and PRs. Search did not return ERD entities. We closed them all in one PR.
A manual check in production found one more. A search hit for an ERD entity selected it but did not scroll it into view. That fix shipped about half an hour after the audit.
What we would keep
- Plan first, in writing. The agents spent their time building, not deciding. When an agent had a question, the answer was usually already in the Decisions log.
- Small shared surface. Merge conflicts were rare and dull, which is how they should be.
- One test seam. 25 test files over HTTP, and no agent's refactor broke another agent's tests by accident.
- An audit at the end. Tickets passing is not the same as stories being covered. A separate read-only pass caught what each agent, inside its own ticket, could not see.
What we would change
- Write the deploy and background-job rules down before the first ticket, not after the first outage.
- Run the story audit after every few tickets, not once at the end.
- Treat "the UI says running" as a claim to verify. Every long job now has a state you can check.
Tinkerbee exists to make Specs with no gaps, so coding agents do not have to guess. Building it this way was a good test of the idea. Where the plan was complete, the agents were quick and right. Where we had not written something down, like how deploys behave, things broke.
Tinkerbee is in beta, and it is a Skcript R&E project. Read why we built it in Specs with no gaps, or sign in with GitHub to request access.