MobSessiondocs

Onboard engineers in live sessions

Ramp new hires by steering the agent through your real codebase together, instead of handing them stale docs.

Onboard a new engineer by having them steer the agent through your actual codebase, with the team in the same session. They open a link and learn from live code, not a wiki snapshot.

New engineers learn a codebase by watching how the team moves through it: which files matter, how a request flows, where the sharp edges are. MobSession makes that a shared, live activity. There's nothing for the new hire to set up. They open the link, land in the session, and watch the agent read files, make edits, and run commands in real time.

How it works

Every session has one orchestrator: the engineer running the agent. The new hire and a mentor join the same session and steer alongside them. Anyone can queue a prompt, and prompts run one at a time, so the session stays easy to follow.

Everyone watches the same thing at once. The agent reads the file, makes the change, runs the test, and the room sees each step. Prompts are attributed, so it's clear who asked what.

Who does what

  • Orchestrator. Runs the agent and keeps the session moving. Usually a team member who knows the area.
  • New hire. Steers the agent toward the parts of the codebase they need to understand, and asks questions in the same room.
  • Mentor. Adds context the agent and new hire would otherwise miss, and points the exploration toward what matters.

A suggested first week

No formal curriculum needed. Use the codebase as the syllabus and let the agent do the navigation.

Day one: trace one real request

Pick a feature the new hire will own. Have them steer the agent from the entry point to the database and back, asking it to explain each hop in plain language. By the end they have a mental map no doc could give them.

Mid week: make a small real change

Move from reading to doing. Have the new hire queue prompts for a low-risk change: a copy fix, a small validation, a test. They watch the agent edit and run things live, with the mentor in the room to catch anything off.

End of week: explore a gnarly corner

Point the session at the part of the system everyone warns new people about. Let the new hire ask the agent the questions they were afraid to ask a person. The mentor fills in the history and the why.

Why this beats reading docs

  • Always current. The new hire learns from live code, not a snapshot that goes stale.
  • Active, not passive. Steering the agent means making decisions from hour one.
  • Questions answered in context. The mentor is in the same room as the code being discussed, so answers land against something concrete.
  • Shared understanding. The whole room sees the same exploration and builds a common picture of how a feature works.

Revisit the session later

Preview. Saved session history lets a new hire walk back through what the team explored, on their own time. This is in early access and rolling out to teams. Onboarding analytics, accounts, and orgs are on the same track. As these roll out, a single session can become a reusable ramp-up path for later hires.

Keep going