Insights
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.
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.
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 work
Related



