*A Campfyrr use-case walkthrough: what it looks like when a team splits work before opening the IDE, instead of after the merge conflict.*
Here's the failure mode almost every team on Cursor or Claude Code eventually runs into, even though no one on the team is doing anything wrong: two developers, two agents, one afternoon, and no shared record of who's touching what. Dev A tells their agent to refactor the auth flow. Dev B tells theirs to add OAuth on top of the schema as it exists right now. Both agents do exactly what they were asked. Both developers find out they've collided only once the PRs land.
The problem isn't the agents — it's that the fast conversation with an agent is private by default. Nothing forces a team to split work *before* anyone starts typing instructions.
Starting the split where the work actually gets decided
> Tech lead (human), 9:03am > ## This week: auth cleanup + OAuth > Two things need to happen and they touch the same schema. Need to sequence this before anyone starts.
Instead of assigning this in a standup and letting each person go run it through their own agent separately, the lead opens the command line right on the page:
> *"List the two workstreams, what each one touches, and where they could conflict."*
> Agent — in response to *"list the two workstreams..."* > ### Workstream 1 — Auth refactor > Touches: lib/auth/, the sessions table schema. > ### Workstream 2 — Add OAuth > Touches: lib/auth/, adds columns to the sessions table. > Conflict: both modify the same schema. Workstream 2 should start from workstream 1's *finished* schema, not the current one, or the OAuth columns land on a table that's about to be restructured out from under them.
That's the exact collision that normally only surfaces in a PR review, surfaced instead before either developer has written a line of code.
Owners, in the same place as the plan
> Dev A (human), 9:07am — added as owner of Workstream 1 > Starting the refactor now. Will flag here the moment the new schema's stable.
> Dev B (human), 9:08am — added as owner of Workstream 2 > Waiting on Dev A's flag before I touch sessions. Starting the OAuth provider config in the meantime — that part doesn't depend on the schema.
Neither developer is guessing what the other is doing or waiting on a Slack thread to resurface. The sequencing lives on the same page as the task split, with names attached — anyone on the team can open this doc cold and see exactly who owns what and in what order, without pinging either of them.
Handing each workstream to its own agent, with shared context
Both developers now go do exactly what they'd normally do — open Cursor or Claude Code and let their agent write the actual code. The difference is that the instruction each of them gives their agent can point back at a shared plan instead of being reconstructed from memory: "follow the schema changes described in workstream 1 of the auth-cleanup doc," not "hey, what did we say about the sessions table again?"
What changes
Nothing about how fast either agent works. What changes is the thirty seconds it took to write down that workstream 2 depends on workstream 1 finishing first — thirty seconds that, without a shared page, usually only get spent *after* the conflicting PRs are already open, when undoing the collision costs a lot more than thirty seconds.
Worth knowing: this doesn't automatically detect conflicts for you — nothing here watches the codebase and warns you when two workstreams are about to collide. It's a shared page that makes the collision visible when a team actually reads it together, which is a smaller promise than automated detection, and one that's true today rather than on a roadmap.
--- Synced from Campfyrr: https://ghostcursor-self.vercel.app/doc/6b660faf-b (id 6b660faf-b) · last synced 2026-09-07T19:23:21.299Z