Mob programming with MobSession
Mob programming puts the whole team on one problem at one keyboard. MobSession keeps that shape and makes an AI coding agent the driver while your team navigates.
Mob programming means the whole team works on the same thing, at the same time, at the same computer. One person drives at the keyboard. Everyone else navigates: deciding direction, catching mistakes, sharing context out loud. MobSession keeps that shape and swaps in one change for the AI era: the driver is a coding agent, and your team are the navigators.
What mob programming is
Woody Zuill and his team at Hunter Industries popularized mob programming around 2011. It grew out of pair programming: if two heads on one problem beat one, the whole team on one problem can be stronger still. Knowledge spreads as it's created, decisions get made in the open, and the team carries shared context instead of stitching it together later in review.
The rule is simple. One driver turns intent into code. The navigators decide what to build, talking through the work while the driver types.
How MobSession adapts it
In a MobSession run, the driver is a real Claude Code session and the navigators are your team. The agent does the coding. People supply the thinking, the direction, and the judgment.
What that looks like today:
- One orchestrator starts a session with
mobsession starton their own machine. - Teammates join through a shared link. No setup on their end.
- Everyone steers the same agent live, in one shared view.
- Prompts queue and run one turn at a time, so the mob moves as a unit.
- Every contribution is attributed to the person who sent it.
- The agent works on the orchestrator's real machine, against the real repo.
You keep the value of mobbing, shared context and collective decisions, without anyone fighting over a keyboard. The agent is a fast, tireless driver. Your team stays where the leverage is: choosing what to build and checking that it's right.
How to run a good mob session
- Pick one goal. Mobbing works best with a single, clear objective. Say it out loud before the first prompt.
- Start the session. The orchestrator runs
mobsession startand shares the join link. - Talk, then prompt. Decide direction as a group, then send the prompt that captures it. Prompts run one turn at a time, so the mob sees each result before the next step.
- Read every turn together. Treat the agent's output as a draft to review right then, not later.
- Course-correct early. If a turn goes sideways, the next prompt steers it back. Small, frequent corrections beat big rewrites.
Rotating who steers
Mobbing stays healthy when no single voice owns the keyboard. Rotate who sends the next prompt on a regular rhythm, say every few minutes or at each natural checkpoint. Rotation keeps everyone engaged, spreads context across the team, and gives quieter teammates the wheel instead of waiting for a gap.
Benefits
- Shared context, in real time. The whole team watches the code take shape, so understanding is built in rather than recovered in review.
- Faster decisions. Direction is agreed out loud and acted on right away, with no handoff lag.
- Fewer surprises. Many eyes on each turn catch problems while they're still cheap to fix.
- Built-in knowledge transfer. Newer teammates learn the codebase and the reasoning by being in the room, not from a doc afterward.
- Attribution you can see. Contributions are tagged to people, so credit and history stay clear.
What is coming
A few capabilities are in early access and rolling out to teams: accounts and organizations, single sign-on, saved history and ROI tracking, audit logs, analytics, and roles. These aren't generally available yet. The live mobbing experience above, one shared agent driven by the whole team, is what runs today.