Three agents, one repo: the hackathon problem

Three people sign up as a team. Doors at 10, demos at 6. They all have a coding agent, and the math looks good: three engineers, three agents, one repo, three times the output.

Hour three is when the math stops working.

Hour three: everyone opens their own session

By one in the afternoon each person has opened a session of their own and explained the same project from scratch, in their own words. Three private conversations about one codebase. Two people have made the same decision differently. One has an environment that works and cannot say exactly why, which means nobody else can reproduce it.

None of it looks like a problem yet, because everything feels fast. Divergence feels like progress for as long as it lasts.

Hackathon teams are usually two to four people, small enough that everyone assumes coordination will take care of itself. At that size it does, right up until it does not.

Hour six: the reconciliation window

You have seen this hackathon. By four in the afternoon the last two hours are not building, they are reconciliation. Two or three branches that each moved the same files. An integration nobody owns. A hunt for the version of the app that actually runs, and a demo recorded on the one laptop where it does.

Somebody says the line every hackathon team has said: wait, you built that too?

A longer clock does not fix this. Twelve hours buys you more building and a longer merge. A weekend buys you three branches that have diverged for two days. The shape is the same, it just arrives later and bigger.

The work was there. The output was there. What was missing the whole time was a shared picture of what everyone else had already done.

Divergence got faster. Putting it back together did not.

Agents did not create this. They made it arrive sooner and bigger. Three people with agents produce divergence at three times the old speed and reconcile it at exactly the old speed, because reconciliation is still humans reading each other's work and arguing about it.

That gap is the whole story. A company takes a quarter to feel it. A hackathon team feels it before dinner.

What changes when the team shares one environment

Coshell gives the team a drive, which is a workspace holding the code, the environment, and the agent sessions, and everyone on the team can be inside it at once. On an eight-hour clock that shows up in six places.

One environment, immediately. One person sets up the drive. Everyone else joins a working environment from a browser. Nobody loses the first hour of eight to node versions, and nobody is the single point of failure for whether the thing runs.

One session, several people. Teammates prompt the same live agent session, watch the same work happen, and act on the same running environment. Prompts queue with a name on each one, so you can see what the agent is doing and what is next before you type. The person who stepped out for the sponsor talk reads the session instead of asking for a summary.

Overlap gets caught while it happens. When two people push work at the same logical concern, the second edit is held while a reasoning arbiter reads what both sides are changing and tells that agent how to proceed. It negotiates intent and never merges code for you. The last two hours stop being a reconciliation window, because the reconciling happened in the second it mattered.

Handoff without the packaging step. Someone takes a call, someone joins late from the train, and on an overnight event someone takes the small hours while the rest sleep. They pick up the session with the context intact. Teams building with agents do not hand each other code anymore, they hand each other context, and packaging that by hand is the tax nobody budgets for.

The demo has a URL. The app runs in the drive with an integrated browser on it, so it runs for everyone, including whoever is judging. Works on my machine is not a sentence you need at 6pm.

You can still work alone. Every session has its own privacy control. Take one private, try the thing that probably will not work, open it up when it does. Sharing a drive does not mean everything you type is a performance.

Judging: what a replay shows that a repo does not

If you run hackathons, you have a sharper version of this problem. AI made it hard to tell what was built during the event. The strongest project on the table might be a weekend of prior work with a fresh commit on top, and a judge has forty minutes and thirty teams.

Rules do not fix it. Commit-history policies and honor codes are unenforceable at that ratio, and they mostly inconvenience the honest teams who keep good history.

A shared session is a record. Every prompt carries a name and a time, the work happened somewhere anyone with a link can watch it back, and a read-only replay shows what a team did between kickoff and submission. It is the closest thing this era has to showing your work, and it turns judging into a conversation about how a team built something instead of whether they did.

Take a team into one drive at the next one

Coshell is free to self-host. One person runs a drive on a laptop or any box you control, the drive connects out so there are no inbound ports to open on venue wifi, and everyone else joins from a browser. Bring whichever agent you already like: it works with Claude Code, Codex, and more than 70 models.

Then look at the clock at four and see what is left to put back together.