Kanban for Coding Agents: A Board-to-Review Workflow We Ran With Claude Code
Five cards, five worktrees and one merge conflict. What a board for agents has to do, tested with git and Claude Code, and how Agentastic, Vibe Kanban, Nimbalyst and GitHub Projects handle each step.
Contents
- What a board for coding agents has to do
- Three kinds of agent boards
- The test: five cards, one repository
- Run 1: the board committed the test cache
- Run 2: three cards in parallel, reviewed and merged
- When two cards change the same line
- What the test says about agent boards
- The same loop in Agentastic
- Agentastic, Vibe Kanban, Nimbalyst and GitHub Projects compared
- Which one to use
- Reproduce the test
- Troubleshooting
- Sources
- Frequently asked questions
A kanban board for coding agents gives every card its own git branch and worktree, starts an agent on it, and moves the card through In progress, Review and Done as the work comes back. The board only helps if two things hold: the column reflects what really happened, and nothing reaches main without a review. We ran that loop with plain git and Claude Code on five cards. Three cards that touched different functions merged cleanly, and two that rewrote the same line conflicted. Agentastic's Kanban board gives you the same loop on a Mac, with labels as columns and the agent's live state on each card.

Checked on November 15, 2026. Agentastic publishes this guide about its own product. We ran the git and Claude Code steps ourselves. The Agentastic, Vibe Kanban, Nimbalyst and GitHub Projects steps come from each one's own docs and source code; we didn't run those apps for this guide.
What a board for coding agents has to do#
A board for people tracks who is doing what. A board for agents also has to start the work, keep each agent's files apart, and stop anything from merging unreviewed. Our test did each step with a few lines of shell, so you can see what any agent board is really doing for you.
| Step | What has to happen | How our test did it |
|---|---|---|
| Write the card | The card text becomes the prompt, so it needs a scope and a way to check the work | One Markdown file per card, ending with "run python3 -m unittest and make sure every test passes" |
| Start | A new branch and worktree from main, then an agent inside it | git worktree add -b card/<name>, then claude -p with the card text |
| Track | The column comes from real state, not from someone remembering to drag a card | board.sh reads git: no branch means To do, a merge commit on main means Done |
| Review | The diff, the test result and the agent's own summary, side by side | git diff --stat, the tests rerun in the worktree, the summary from Claude Code's JSON output |
| Merge | Merge the card, or send it back to the agent with the problem | git merge --no-ff, and one conflict sent back to Claude Code |
| Clean up | Remove the worktree and branch but keep the record | git worktree remove and git branch -d; the merge commits keep each card in Done |
Three kinds of agent boards#
Tools that call themselves a kanban for agents put different things on the cards. Knowing which kind you need narrows the choice quickly.
| Kind | A card is | Examples |
|---|---|---|
| Backlog board | A task that may not have started yet | GitHub Projects, Nimbalyst's task tracker, and Vibe Kanban's issue board before it was retired |
| Session board | An agent or worktree that already exists | Agentastic's Kanban board, Nimbalyst's session kanban |
| Cloud-agent board | An issue that an agent in a hosted sandbox picks up | GitHub Projects with Copilot, Claude or Codex assigned to the issue |
A backlog board answers "what should run next?" A session board answers "what are my running agents doing, and which ones need me?" Most people running several local agents want the second, plus a backlog somewhere else.
The test: five cards, one repository#
We used a small Python module, inventory.py, that loads a coffee shop's stock from name,quantity lines, with four unit tests. The board was a folder next to the repository:
board/
repo/ the git repository, on main
cards/ one Markdown file per card; the text is the prompt
worktrees/ one worktree per started card
logs/ Claude Code's JSON result for each card
agent-settings.json what the agents may not do
start-card.sh start one card
board.sh print the boardEach card is plain text with a scope and a check. This is cards/duplicate-items.md:
When the same item appears on two lines, load keeps only the last quantity. Make load add the quantities together instead. Add a test for it, then run python3 -m unittest and make sure every test passes. Change only what this card needs.start-card.sh gives one card a branch, a worktree and a headless Claude Code run, then commits whatever the agent left behind, so the branch is ready for review:
#!/bin/bash
# start-card.sh CARD: give one card its own branch, worktree and agent run.
set -u
BOARD="$(cd "$(dirname "$0")" && pwd)"
CARD="$1"
WORKTREE="$BOARD/worktrees/$CARD"
export PATH="$HOME/.local/bin:/opt/homebrew/bin:/usr/bin:/bin"
git -C "$BOARD/repo" worktree add --quiet -b "card/$CARD" "$WORKTREE" main || exit 1
cd "$WORKTREE" || exit 1
claude -p "$(cat "$BOARD/cards/$CARD.md")" \
--model sonnet \
--permission-mode auto --permission-prompts none \
--setting-sources project --settings "$BOARD/agent-settings.json" --strict-mcp-config \
--max-budget-usd 1 \
--output-format json > "$BOARD/logs/$CARD.json" 2> "$BOARD/logs/$CARD.err"
git add --all
git commit --quiet -m "$CARD" || echo "$CARD: no changes"The agent may edit files and run the tests, but agent-settings.json denies git commit, git push and gh, so the script makes the commit and nothing leaves the machine. Auto mode with --permission-prompts none means a run never stops to wait for an answer. Our scheduling guide explains each of these flags in detail.
board.sh works out every card's column from git alone, so a card can't sit in the wrong column because someone forgot to drag it:
#!/bin/bash
# board.sh: show the column each card is in, worked out from git.
BOARD="$(cd "$(dirname "$0")" && pwd)"
cd "$BOARD/repo" || exit 1
for file in "$BOARD"/cards/*.md; do
card="$(basename "$file" .md)"
if git log --format=%s main | grep -qx "Merge branch 'card/$card'"; then
column="Done"
elif ! git rev-parse --quiet --verify "card/$card" > /dev/null; then
column="To do"
elif [ ! -s "$BOARD/logs/$card.json" ]; then
column="In progress"
elif [ "$(git rev-list --count "main..card/$card")" -gt 0 ]; then
column="Review"
else
column="Stuck"
fi
stat="$(git diff --shortstat "main...card/$card" 2> /dev/null)"
printf '%-12s %-18s %s\n' "$column" "$card" "$stat"
doneWe ran everything on November 15, 2026, with Claude Code 2.1.325 and Claude Sonnet 5.5 on macOS 26.4. The runs used a clean environment and project-only settings, so no personal hooks or plugins took part.
Run 1: the board committed the test cache#
We started three cards at once: negative-quantity (reject a negative quantity), duplicate-items (add up repeated items) and low-stock (a new low_stock() function). All three agents finished in 7 to 10 seconds and the board moved every card to Review. The diff stats looked wrong, though: each branch showed four changed files where we expected two.
The extra files were Python bytecode. Running the tests created __pycache__/, and git add --all in our script committed it. One agent had even said so in its summary: "Running the tests created an untracked __pycache__/ directory. I left it alone." The script committed it anyway.
To see what that costs, we merged two of the branches in a scratch clone. The source files merged on their own, and the only conflicts were the cache files:
warning: Cannot merge binary files: __pycache__/inventory.cpython-314.pyc (HEAD vs. origin/card/duplicate-items)
CONFLICT (add/add): Merge conflict in __pycache__/inventory.cpython-314.pyc
CONFLICT (add/add): Merge conflict in __pycache__/test_inventory.cpython-314.pyc
Auto-merging inventory.py
Auto-merging test_inventory.py
Automatic merge failed; fix conflicts and then commit the result.We threw the three branches away, committed a .gitignore containing __pycache__/ to main, and started again. Any board that commits for the agent needs this first: build output, caches and logs belong in .gitignore before the first card starts.
Run 2: three cards in parallel, reviewed and merged#
The same three cards, started a second apart, finished in 13 seconds of wall time:
| Card | Agent time | Turns | Diff | Tests in the worktree | Estimated cost |
|---|---|---|---|---|---|
| negative-quantity | 8.6 s | 4 | 2 files, +9 −1 | 5 passed | $0.041 |
| duplicate-items | 11.1 s | 4 | 2 files, +4 −1 | 5 passed | $0.038 |
| low-stock | 7.0 s | 4 | 2 files, +15 −1 | 6 passed | $0.038 |
While they ran, board.sh showed all three as In progress. Afterwards it showed them in Review with their diff stats:
Review duplicate-items 2 files changed, 4 insertions(+), 1 deletion(-)
Review low-stock 2 files changed, 15 insertions(+), 1 deletion(-)
Review negative-quantity 2 files changed, 9 insertions(+), 1 deletion(-)Review meant three checks per card: read the diff, rerun the tests in the worktree, and read the agent's summary for anything it decided on its own. That last check matters. The low-stock agent noted that "an item exactly at the threshold is not included". That is a product decision, and the card text didn't settle it. We accepted it, but on a real team someone has to say yes to it.
Then we merged the cards one at a time from main:
cd board/repo
git merge --no-ff --no-edit card/negative-quantity
git merge --no-ff --no-edit card/duplicate-items
git merge --no-ff --no-edit card/low-stock
python3 -m unittestAll three merged without conflicts, because each card touched a different function. The full suite ran 8 tests and passed. We removed each worktree with git worktree remove and each branch with git branch -d, which refuses to delete a branch that isn't merged. The board still showed all three cards as Done afterwards, because it reads the merge commits rather than the branches.
When two cards change the same line#
Real backlogs aren't that tidy, so we started two cards that overlap: missing-quantity (treat beans, as 0) and unit-suffix (read milk,3l as 3). Both agents were done within 14 seconds, and both branches passed their tests. Each had rewritten the same line of parse_line:
# missing-quantity
quantity = int(quantity) if quantity.strip() else 0
# unit-suffix
quantity = int(quantity.strip().rstrip("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"))The first merged cleanly. The second stopped with CONFLICT (content): Merge conflict in inventory.py. This is the merge conflict a board can't prevent, only schedule around. We aborted that merge, so main kept a clean history, and sent the card back to its agent. That means its column was effectively In progress again:
cd board/worktrees/unit-suffix
git merge --no-edit main # reproduces the conflict inside the card's worktree
claude -p "Merging main into this branch conflicted in inventory.py. Resolve the conflict so that a missing quantity still counts as 0 and letters after the number are still ignored. Keep both tests, then run python3 -m unittest and make sure every test passes." \
--model sonnet --permission-mode auto --permission-prompts none \
--setting-sources project --settings ../../agent-settings.json --strict-mcp-config \
--max-budget-usd 1 --output-format json > ../../logs/unit-suffix-rework.jsonThe agent resolved it in 10.2 seconds and 3 turns, for an estimated $0.036. It split the line into two steps, stripping letters first and treating an empty result as 0, and reported 10 passing tests. Its summary flagged one new behaviour for review: widget,kg now parses as 0. Because commits were denied, it ended with "I haven't staged inventory.py or committed the merge. Do you want me to do that?" We committed the merge ourselves, merged the card into main, and the suite passed with 10 tests. The board showed all five cards as Done.
| Part of the test | Wall time | Estimated cost | Tokens |
|---|---|---|---|
| Run 2: three parallel cards | 13 s | $0.117 | 206,114 |
| Two overlapping cards | 14 s | $0.089 | 207,510 |
| Sending one card back to resolve the conflict | 11 s | $0.036 | 56,462 |
| Kept loop, total | 38 s | $0.242 | 470,086 |
Run 1, which we threw away, cost another estimated $0.136. The dollar amounts are Claude Code's own estimate at API list prices. On a Pro, Max or Ultra subscription, these runs count against your plan's usage instead of being billed.
What the test says about agent boards#
- Clean the base branch before the first card. A board that commits for its agents commits everything they leave behind. Our only conflicts in run 1 came from test caches, not code.
- Conflicts come from overlap, not from parallel work. Three cards in parallel merged cleanly because each touched a different function. Two cards that touched the same line conflicted. Split cards by function or file. When two cards have to touch the same code, run them one after the other or mark them as dependent.
- Send a conflict back to its card. The agent that wrote the code resolved its own conflict in 10 seconds once the prompt named both behaviours to keep. Resolving it by hand would have meant reading two agents' intentions out of their diffs.
- Read the summary as well as the diff. Both product decisions in this test showed up only in the agents' summaries: the low-stock boundary, and
widget,kgparsing as 0. - A column you drag is an opinion; a column computed from state is a fact. Our script computed columns from git. Most apps let you drag cards and show the agent's live state separately, so check both before you merge.
The same loop in Agentastic#
Agentastic's Kanban board is a session board. Every worktree in every open repository is a card, and the columns are that repository's labels plus Unlabeled. This section comes from the board's documentation and the app's source code; we didn't run the app for this guide. The screenshot at the top is from an earlier build of the board. Today's cards also carry diff stats, pull-request status and a ring showing the agent's state.
| Step | In Agentastic |
|---|---|
| Open the board | Cmd+Opt+K, View → Show Kanban Board, or the toolbar button. It opens as an editor tab, so it can sit beside your work. |
| Write and start a card | The New task row at the foot of a column opens Agent Home for that repository with the column's label already chosen. Each agent gets its own worktree on a new branch from the base you pick. From a script: dev agent create --label "In progress" --prompt-file card.md. |
| Track | A card shows the agent ringed by its state: blue while it works, orange when it asks you something, red when it failed, green when it's ready for review. Its last message appears too, starting with Asks: or Failed: when it needs you. |
| Review | The card shows live diff stats against the base and the pull request's review and checks in words. Hover for a read-only look at the conversation or terminal, or double-click to open the workspace. There, a line comment in the diff viewer can go straight to the agent, and code review can run Claude Code, Codex, CodeRabbit or Greptile. |
| Merge | Right-click a branch and choose Merge into current, or merge, squash or rebase from the pull-request panel. If GitHub reports a conflict, the panel shows Merge Conflict. Add to Chat then hands a conflict-fix prompt to the live agent in that worktree, or stages it for you to review first (source control). |
| Overlapping cards | Mark cards with relationships such as Depends On, Blocks or Conflicts With. The counts show as badges on the cards. |
| Clean up | Right-click the worktree and choose Delete Workspace (git worktrees). |
Two differences from our script matter. First, columns don't move by themselves. A card changes column when you drag it, launch an agent into a column, or run dev label assign. The live state lives in the ring, not the column. Second, the cards are worktrees, not backlog items. Work that hasn't started stays in Linear, GitHub Issues or a file until you launch it, and a linked Linear or Sentry issue shows as a chip on the card.
Agentastic runs on macOS 14 or later. It runs more than 50 agents, including Claude Code and Codex, and each one can work in a worktree, a container, over SSH or in a cloud sandbox. The parallel agents workflow covers the rest of the loop, from launching a batch to cleaning up.
Agentastic, Vibe Kanban, Nimbalyst and GitHub Projects compared#
Each tool below handles the same loop differently. These facts come from each one's own site, docs, repository or source code, checked on November 15, 2026; we didn't run Vibe Kanban, Nimbalyst or GitHub Projects for this guide.
| Tool | A card is | Where the agent runs | Review and merge |
|---|---|---|---|
| Agentastic | A worktree with its agents; columns are labels you set | Your Mac, a container, an SSH host or a cloud sandbox | Diff stats and PR status on the card; line comments to the agent; merge in the app |
| Vibe Kanban | A workspace; the issue board is retired | Your computer | Inline diff comments to the agent; pull requests with generated descriptions |
| Nimbalyst | A session in a phase, plus separate task cards | Your computer, with an optional worktree per session | Files changed per card with inline diffs; keep or revert per file |
| GitHub Projects | An issue or pull request with a Status field | GitHub's cloud, for Copilot, Claude or Codex assigned to the issue | A pull request that asks you for review; Done when it merges |
| Tool | Runs on | Price | Status |
|---|---|---|---|
| Agentastic | macOS 14 or later | Free | Actively developed |
| Vibe Kanban | macOS, Linux and Windows via npx | Free | Community maintained; 0.1.46 shipped November 15 |
| Nimbalyst | macOS, Windows, Linux; iOS app | Free for individuals; Teams $20 per user a month, free in beta | Actively developed |
| GitHub Projects | GitHub on the web | Projects included with GitHub; agents need a paid Copilot plan | Third-party agents in public preview |
Vibe Kanban: workspaces still run, the board doesn't#
Vibe Kanban made the board-plus-worktree pattern popular. Its company, Bloop, announced on April 10, 2026 that it was shutting down, and said the project would continue as open source, maintained by the community. The announcement also said hosted kanban issues, comments, projects and organisations would go after 30 days, while "local workspaces will continue to function." The README still opens with "Vibe Kanban is sunsetting." In the current source, a project page shows an export-only screen: "Project functionality has been retired."
The project is still moving, though. Version 0.1.46 shipped on November 15, 2026, with five new contributors. It added installing and running agents from the ACP registry and turned off usage analytics and crash reports. Pick it if you want a free, cross-platform workspace launcher and can live without the board. Our Vibe Kanban alternatives guide covers the full history and how to move your work.
Nimbalyst: two boards, one for tasks and one for sessions#
Nimbalyst has the closest thing to Vibe Kanban's original board. Its session kanban puts each Claude Code or Codex session on a card that moves through phases: backlog, planning, implementing, validating and complete. A separate task board holds plans, bugs and features, linked to the sessions doing the work. Worktree isolation is a one-click option per session, not the default. Pick it if you plan on a board first and want Windows or Linux.
GitHub Projects: the board you may already have#
A GitHub project is a table, board or roadmap built from your issues and pull requests. Two built-in workflows are on by default: a closed issue or pull request goes to Done, and so does a merged pull request. Assign an issue to Copilot, or to Claude or Codex as third-party agents, and the agent opens a pull request and asks for your review when it finishes. Those agents run in GitHub's cloud and use GitHub Actions minutes and AI credits. Copilot only sees the comments an issue had when you assigned it, so follow-ups go on the pull request. Pick it if your team already plans in GitHub and is happy for agents to run in GitHub's cloud. Agents running on your own machine won't move its cards.
Which one to use#
- You run several agents on a Mac and want to see which ones need you: Agentastic. Its cards are the worktrees themselves, with the agent's state, diff and pull request on each.
- You plan on a board before any agent starts, or you need Windows or Linux: Nimbalyst, with its separate task and session boards.
- Your team already plans in GitHub and is fine with agents in GitHub's cloud: GitHub Projects with Copilot, Claude or Codex assigned to issues.
- You want a free, cross-platform workspace launcher and don't need a board: Vibe Kanban's community edition.
- You want no app at all: the two scripts in this guide. They work anywhere git and Claude Code run. For Codex, swap the
claude -pline forcodex exec; our scheduling guide has a testedcodex execcommand, but we didn't run Codex in this board test.
Whichever you pick, keep the review gate: the reviewer reruns the tests in the card's worktree, reads the agent's summary, and only then merges.
Reproduce the test#
You need git, Python 3 and Claude Code signed in. Create the repository with git init -b main board/repo, add these two files, and commit them.
inventory.py:
"""Stock list for a small coffee shop, loaded from 'name,quantity' lines."""
def parse_line(line):
"""Parse 'name,quantity' into (name, quantity)."""
name, quantity = line.split(",")
return name.strip(), int(quantity)
def load(text):
"""Load stock from text with one 'name,quantity' item per line."""
items = {}
for line in text.splitlines():
if not line.strip():
continue
name, quantity = parse_line(line)
items[name] = quantity
return items
def report(items):
"""Return a printable stock report, one item per line, sorted by name."""
return "\n".join(f"{name}: {items[name]}" for name in sorted(items))test_inventory.py:
import unittest
from inventory import load, parse_line, report
class ParseLineTests(unittest.TestCase):
def test_name_and_quantity(self):
self.assertEqual(parse_line("beans,12"), ("beans", 12))
def test_strips_name(self):
self.assertEqual(parse_line(" milk ,3"), ("milk", 3))
class LoadTests(unittest.TestCase):
def test_skips_blank_lines(self):
self.assertEqual(load("beans,12\n\ncups,40\n"), {"beans": 12, "cups": 40})
class ReportTests(unittest.TestCase):
def test_sorted_by_name(self):
self.assertEqual(report({"milk": 3, "beans": 12}), "beans: 12\nmilk: 3")
if __name__ == "__main__":
unittest.main()agent-settings.json, in the board folder:
{
"permissions": {
"deny": [
"Bash(git push *)",
"Bash(git commit *)",
"Bash(gh *)",
"SendMessage",
"ListAgents"
]
}
}Save start-card.sh and board.sh from above next to it, write the card files, and run:
cd board
printf '__pycache__/\n' > repo/.gitignore
git -C repo add .gitignore && git -C repo commit -m "Ignore Python bytecode"
chmod +x start-card.sh board.sh
mkdir -p logs worktrees
./start-card.sh negative-quantity & sleep 1
./start-card.sh duplicate-items & sleep 1
./start-card.sh low-stock & wait
./board.shThe other two cards read:
negative-quantity.md: parse_line accepts a negative quantity such as "beans,-2". Make it raise ValueError when the quantity is negative, with a message that names the item. Add a test for it, then run python3 -m unittest and make sure every test passes. Change only what this card needs.
low-stock.md: Add a function low_stock(items, threshold=5) to inventory.py that returns the names of items whose quantity is below the threshold, sorted by name. Add a test for it, then run python3 -m unittest and make sure every test passes. Change only what this card needs.The overlapping pair:
missing-quantity.md: parse_line raises ValueError for a line with no quantity, such as "beans,". Treat a missing quantity as 0 instead. Add a test for it, then run python3 -m unittest and make sure every test passes. Change only what this card needs.
unit-suffix.md: Some lines put a unit after the number, such as "milk,3l" or "beans,12kg". Make parse_line ignore letters after the number. Add a test for it, then run python3 -m unittest and make sure every test passes. Change only what this card needs.Agents don't write the same code twice, so your diffs and timings will differ from ours. The conflict between the last two cards should still appear, because both cards have to change the same line.
Troubleshooting#
| Symptom | Cause | Fix |
|---|---|---|
| A card's diff shows more files than the agent changed | Build output or caches were committed with the work | Add them to .gitignore on main before starting cards; on a branch, git rm -r --cached __pycache__ |
fatal: a branch named 'card/x' already exists | The card was started before | Finish or discard the old run: git worktree remove, then git branch -D |
| A card stays In progress | The agent is still running, or it crashed before writing its result | Check logs/<card>.err; the JSON result is written only when the run ends |
| A card shows Stuck | The agent finished without changing anything | Read its summary in logs/<card>.json; the card was usually unclear or already done |
CONFLICT (content) on merge | Two cards changed the same lines | git merge --abort, merge main into the card's worktree, and send the card back with both behaviours named |
| The agent asks whether to commit | Commits are denied on purpose | Let the script or the reviewer commit |
error: the branch 'card/x' is not fully merged | git branch -d refuses to delete unmerged work | Merge the card first, or use git branch -D to throw it away |
| An Agentastic card is in the wrong column | Columns are labels and don't follow the agent's state | Drag the card, or run dev label assign <label> from its worktree |
| A GitHub project card doesn't move when a local agent finishes | Built-in workflows react to issue and pull request events on GitHub | Open the pull request, or move the card yourself |
Sources#
Checked on November 15, 2026:
- Claude Code: headless mode, CLI reference, permission modes, costs
- Git: git worktree, git merge, gitignore
- Vibe Kanban: "Goodbye bloop", README and source, releases
- Nimbalyst: Kanban for Claude Code, pricing
- GitHub: about Projects, built-in automations, kick off a task with Copilot, third-party agents
- Agentastic: Kanban board, Agent Home, source control,
devCLI reference
Related: a parallel coding agents workflow that survives review, seven problems worktrees don't solve, and how to schedule Claude Code and Codex tasks.
To put your agents on a board, download Agentastic for macOS.
Frequently asked questions#
What is a kanban board for coding agents?#
It is a board where each card is a task that an agent works on in its own git branch and worktree. The columns show where each task stands: waiting, in progress, ready for review, or merged. The useful ones start the agent from the card and show its diff and test results before anything merges.
Does Agentastic move cards between columns automatically?#
No. Agentastic's columns are labels, and a card changes column when you drag it, launch an agent into a column, or run dev label assign. The agent's live state shows separately, as a ring on the card: blue while it works, orange when it asks you something, red when it fails, and green when it is ready for review.
Is Vibe Kanban's kanban board still available?#
Not in the current release. In Vibe Kanban's source, a project page now shows an export-only screen saying kanban, issue and workspace flows are no longer available there, and the README still says the project is sunsetting. Local workspaces still run, and version 0.1.46 shipped on November 15, 2026.
Can GitHub Projects work as a kanban board for Claude Code or Codex?#
Yes, for agents that run in GitHub's cloud. Assign an issue to Copilot, or to Claude or Codex as third-party agents, and the agent opens a pull request and asks for your review. The project's default workflow sets the item to Done when that pull request merges. Claude Code or Codex sessions on your own machine don't update the board.
How do I stop two coding agents from conflicting?#
Give each card its own worktree and branch, keep cards small, and don't run two cards that edit the same function at the same time. In our test, three cards that touched different functions merged cleanly. Two cards that rewrote the same line conflicted, and the second went back to its agent, which resolved it in 10 seconds.
Do I need a separate worktree for each card?#
For agents that edit files at the same time, yes. Two agents in one checkout share the same files, so one agent's half-finished edit can break the other's tests. A worktree per card gives each agent its own files and branch, and the merge is where their work meets.
How much did the test cost?#
Claude Code estimated $0.12 for the three parallel cards and about $0.24 for the whole kept loop of five cards and one rework, all on Claude Sonnet 5.5. That figure is Claude Code's own list-price estimate. On a Pro, Max or Ultra plan, the same runs count against your plan's usage instead.