Insights

Working alongside Grokbot: two AI teams on one repository

Working alongside Grokbot: two AI teams on one repository

On 5 November, 98 of the 115 demo sites I had built for prospective clients were showing a placeholder page instead of the demo. Nothing had been hacked and no server had failed. Two AI teams, both working for me and both doing something sensible, had published over each other. By 20:42 that evening every demo was back, and by 22:31 I had confirmed that all 30 links already sitting in prospects' inboxes still opened the right page.

Why there are two teams

Most of the studio's work runs on Claude, through a roster of named agents. Since October a second team has worked alongside it: Grokbot, an assistant built on xAI's Grok that I run with a few helpers of its own. It checks a shared folder every five minutes for instructions and picks up whatever is marked ready.

The two are good at different things. Claude's side is careful with long briefs, reviews and code. Grok's side is quick with images and video, and it handles publishing to the demo host. So on 2 November I split the work along those lines. Claude's team scores each demo against the brief, checks every claim against the business's own website, and writes plain fix directions. Grok's team makes the edits, renders the hero images and films, and deploys. Each side does what it is best at, and each side's work is checked by the other.

For a few weeks the arrangement ran on good intentions. Instructions went into a shared file, Grokbot read them, finished work came back with a note. A day before the collision I had already added one rule: every change goes to GitHub first, from the studio's main machine, and nobody deploys from a separate copy. I had noticed Grok-side polish going live that never appeared in the repository. The rule was right. It was also one day too late.

What happened on 5 November

That day, a set of logo fixes and one full rebuild of a demo went live straight from working branches, the side copies where changes are made before they join the main version. They were good changes. They had simply never been merged into the main version.

The next routine deploy came from the main version, as it should. It replaced the live files with what main held, and main did not hold the branch work. When the dust settled, most of the fleet was serving the fallback page. No prospect had complained, but some had links to those pages in their inbox, and I had no way of knowing who might click that evening.

Timeline of 5 November 2026. Earlier that day, logo fixes and one full rebuild publish straight from branches that never reached main. At the next deploy, a routine deploy from main replaces the live files and the branch work disappears from the site. Found: 98 of 115 demos serving a fallback page instead of the demo. 20:42 Pacific: 0 of 111 on the fallback page, every demo restored and checked. 22:31: 30 of 30 links already sent to prospects confirmed working, old address included.
Two reasonable habits, one bad day, and the same-evening repair.

I take some comfort that this is not a problem I invented. A study of AI-written code changes on GitHub, AgenticFlict, posted on 4 April 2026 and revised in May, collected more than 142,000 pull requests opened by coding agents and found merge conflicts in 27.67% of the 107,000 or so it could process. A second paper, by Xu, Subramanian and Karthik, published on 6 July 2026, went a step further and compared agents working beside agents from the same tool with agents working beside a different tool. Conflicts were roughly twice as common across tools, 41.7% against 19.8%. Two teams from two different companies on one repository is exactly the riskier case.

The rulebook

That evening my instruction to both teams fit in two lines: the studio's machine to GitHub, GitHub to deploy, one shared set of demos, and git as the record of everything. The result is a single page in the repository that both teams must read before touching a demo. It starts by naming both teams, so neither can claim it was meant for the other.

Diagram of two teams sharing one repository. Claude's team scores and directs: reviews each demo against the brief, writes fix directions and checks claims against the business's real site. Grok's team edits and deploys: makes the changes, renders hero images and video, publishes the fleet once Eric says yes. Both feed one pipeline: 1, claim the demo with one line in a shared file; 2, branch, named by team and day, from a fresh copy of main; 3, merge into main first, since nothing deploys from a branch, side folder or laptop; 4, deploy the whole fleet at one commit, logged with time, commit and who ran it. Four standing rules: only Eric says ship; message boards in the repo rather than chat; a fingerprint check that live files match main byte for byte; no partial uploads.
One pipeline for both teams. The orange step is the one that was missing on 5 November.

The rules are short enough to remember:

  • Claim before you start. One line in a shared file names the demo, the team, the person and the branch. Nobody starts on a demo someone else has claimed.
  • Merge before deploy, always. Nothing goes live from a branch, a side folder or anybody's laptop. The main version is the only copy that counts.
  • Deploy the whole fleet at one commit. Per-demo uploads were how the live sites drifted away from git in the first place, so they are gone.
  • Log every deploy in git. One line each: when, which commit, who ran it, which demos changed.
  • Check the fingerprints. After a deploy, the live files must match main exactly. A demo that matches nothing in git is a question to ask, not a mystery to live with.
  • Only I say ship. Claude's team pushes a branch and asks. Grok's team merges and deploys once I say yes.

Messages between the teams moved into the repository too: two plain files, one in each direction, newest entry at the top, each tied to the commit it refers to. That sounds fussy. In practice it means a note that says "this demo is ready" also says exactly which version of it is ready, and anyone can check.

What the rule changed

Work is slower by a few minutes per change, and much calmer. The deploy log has a line for every release since the rule began. When a live page looks wrong, the first question is no longer "who touched this?" but "does it match main?", and that question takes seconds to answer.

The handoffs are clearer too. A fix direction from Claude's side now names the demo, the branch it applies to, the exact problem as a visitor would see it on a phone, and what done looks like. Grok's side answers on its own board with the commit that carries the fix. When a direction is unclear, the question goes on the board rather than into a guess, and the answer stays in the history for the next person who touches that demo.

The split of work has not changed. Claude's side still writes the reviews and the fix directions; Grok's side still makes the films and runs the deploys.

If you run more than one AI tool on the same project, or more than one freelancer for that matter, the lesson carries over directly. Agree on one copy that counts, make every change join it before it goes live, and write down who published what. The dashboard I use to watch the agents work is a separate story, told in a status file per bot.

The rulebook's first line carries the date it was written: 5 November 2026.

Common questions

Why use two different AI tools on one project?

They are good at different things. One side reviews and writes fix directions; the other edits, renders images and video, and deploys. Each checks the other's work.

What went wrong on 5 November?

Changes went live from branches that were never merged. The next normal deploy replaced them, and 98 of 115 demos showed a fallback page until that evening.

What is the single most important rule?

Merge before deploy. Nothing goes live from a side copy, so the main version always matches what visitors see.

Related

← All insights