Agentic AI Coding BREAKS Mob Programming (Here’s How to Fix It)

This article is available as a video on the Modern Software Engineering channel.

As a technical coach, I find Mob Programming is really effective. Recently of course, we started using agentic AI, and everything changed. It’s been a shock – Agentic AI BREAKS collaborative mob programming. You very easily get failure modes and bad experiences and unhappy teams. It’s taken a while and some experimenting – and I want to share what I’ve learnt about collaborative coding that includes AI. 

The best way I know to transfer technical skills within a team is to actually create software together – particularly for junior engineers, they learn so much by watching people use their tools and from being included in the conversation about design and direction and engineering choices. Mob programming, Ensemble, Software Teaming – these are all names for the same kind of collaboration. I’ve been doing this for many years and I’ve coached a lot of teams in how to make it work.

When you’re collaboratively coding with others there are two main failure modes:

• #1 nobody is talking, the typist is doing all the work. 
• #2 everyone is talking at once, the typist is confused and not doing anything. 

Both are bad. In #1 People are zoning out and reading their phones. This is not collaboration. In #2 there is conflict and people aren’t listening to one another. This is not collaboration either.

For some people, those failure modes are all they’ve experienced in an ensemble or mob setting, and they probably dismissed teh idea and went back to solo programming. We’ve known for a long time, there are some specific communication techniques that prevent these failure modes, and enable better outcomes than you can get on your own.

Preventing ensemble failure

I learnt these ensemble patterns from pioneers like Woody Zuill and Llewllyn Falco.

Firstly “strong style” with frequent rotations on a timer. Basically you nominate one person in the ‘talking’ role and they direct and lead the work. They explain to the person who is controlling the keyboard and mouse, called the ‘typist’, on what code they should write. You rotate roles every few minutes so everyone gets a turn. It’s a pretty successful way of keeping everyone engaged and pointing in the same direction.

To keep everyone aligned and to enable smooth transition between roles, I also teach the communication pattern ‘Intention, location, details’. This means the talker keeps everyone on board by frequently explaining their ‘intention’. Sometimes they need to go to ‘location’ – point at somewhere on the screen or in the codebase, and once everyone’s attention is on that, it’s clear what they mean. Occasionally that’s not enough and they give explicit ‘detail’ so the ‘typist’ gets told exactly what to do. In the main though, you communicate intention, so when you rotate roles, the next person should have a good idea about where the previous person was headed, and can seamlessly take over. 

Sometimes the next steps are unclear and the talker doesn’t know what to do. In that case I advise the team to pause all the roles while they talk through the next steps. The rule is that while the talking and typing roles are suspended, no code is written, you just discuss long enough until you know enough to proceed coding. Then,  you re-start the timer and resume the roles and rotations. 

More experienced ensembles tend to dispense with the timer and rotate roles more informally, but the overall effect is the same, the ensemble speaks with one voice and everyone stays engaged and contributes to the code.

This is how it’s supposed to work. 

Failure with Agentic AI

Unfortunately, when you introduce agentic AI as a tool for coding in the ensemble, this seems to very easily all fall apart. We get failure mode #1 as soon as we submit a prompt to the AI. Everyone is quiet, staring at the screen, trying to keep up with what the agent is doing. It’s like the agent has become that nightmare typist who does all the work without explaining or checking in with everyone else as they make decisions they don’t explain.

Then, we get failure mode #2 as soon as it completes. Suddenly everyone talks at once about what happened, what we should do next or what they think the agent has done wrong or wanting to try again a different way. The group focus just splits in every direction.

Rotating roles on a timer also falls apart as soon as the AI takes longer to complete a prompt than the length of one rotation. Some people don’t get a turn at all, the agent uses all their time. 

Then there’s the communication pattern ‘Intention Location Details’. The ‘intention’ part – that’s usually all you need for the agent. The talking role turns into dictating prompts and the typist is doing little more than correcting grammar. It doesn’t feel like you’re leading and collaborating any more.

It’s miserable! Agentic AI BREAKS mob programming! What do you do as a technical coach when all the things you’ve been teaching these many years, stop working, and your job changes overnight? It’s an ongoing process of revising everything I thought I knew about coaching.

New patterns for collaborative coding

I’m convinced that collaborating with colleagues is still valuable. If you can apply more minds to a hard problem you’ll get a better solution than any individual could have alone. And, probably better results than only one human plus an AI. Particularly if one of your goals is to mentor juniors and turn them into seniors.

I’ve been looking for new patterns of interaction that allow a group to code together, make use of agentic AI tools, without falling into the classic failure modes.  I’d like to share some of the things I’m finding that really seem to work.

Collaborative Prompt Writing

First new interaction pattern: collaborative prompt writing. We need to agree what to ask the AI to do next. I’ve taken inspiration from Marko Taipale in his book ‘CollabAI’. He says:

“Sometimes, ask everyone to write a prompt silently in a shared doc, then pick the best one. This removes the “loudest voice” bias.” 

We call this ‘quiet prompting’. I’m normally working remotely, so I set up a shared online activity board and we all individually write a prompt text in ‘private mode’ so we’re not distracted by what everyone else writes. Then we reveal and discuss and put together a combined text with the best elements of what we’ve written. If we’re more than three people I find it works particularly well to combine this with 1-2-4-All from Liberating structures. We go into pairs to combine our prompts, then return and put together a final text. 

Obviously this takes longer than if one person just decides the next prompt and we use that. I find these advantages outweigh that:

1. Everyone has time to think for themselves in silence before anything gets decided
2. If we disagree about the next thing to do, that becomes visible. 
3. Everyone contributes and has a stake in the next step, even quiet people
4. I can use this as a coaching opportunity, and point out what kinds of things to put in a good prompt. 

I don’t do this on every single prompt, usually when starting a new task or when there’s a lot of uncertainty.

Paste the transcript

In pre-AI days, I mentioned we had this ensemble interaction mode where we pause the roles and rotations, and discuss what to do next. These days, it’s relatively straightforward to get a real-time transcript of our conversation. Often the best idea is to have that conversation, then simply paste the transcript into the AI tool as a prompt. 

We often use this together with the ‘check alignment’ pattern.

Agent does something

While the agent is working, I try to avoid us all staring at the screen reading the agent output as it flies past. Depending on how fast you can read, and what kinds of things you notice, people can get very different impressions of what the agent is doing, and the ensemble gets easily out of alignment, all with different views of the current status. 

If I can, I’ll try to get someone to speak out loud what they think the agent is doing – give a running commentary. I encourage people to listen to them instead of reading the agent’s output. We need to keep thinking together, not split off in different directions or to start multitasking. This can be challenging, I admit.

Examine and evaluate changes

Once the agent is done, it usually provides a summary of what it did at the end of the output. Depending on how fast you read, this can cause conflict and failure mode #2 – all the people who read it quickly are already racing ahead discussing the next idea, and others get lost. I really think it’s worth slowing down at this point. Appoint someone to read the summary out loud to the group, and look through the agent’s changes on the shared screen together. We can discuss, ask questions, and decide whether to keep or discard the agent’s work. Then, we’re well set up to continue talking about the overall strategy, direction, priorities, and what to prompt for next.

Retrospective

After a collaborative coding session I will always reserve about 15 minutes for a retrospective. We put the agent and the code to one side and go meta. What happened in the session, how do we feel about it, what can we improve on? 

I’m a technical coach and this retrospective has always been a huge learning opportunity for the team, even more so when we’ve been using unfamiliar tools, including AI tools. I want us to name the process patterns and prompting patterns we’ve been using. Because – getting people to use words to describe the things they’ve done is a huge step in understanding that thing and in gaining expertise. 

For example, you might have done this already and not realized it’s an established pattern with a name – Instead of telling the AI to do something specific, instead ask it to give you a number of options. That’s the pattern ‘reverse direction’. If we did that in the ensemble session, someone should name that pattern in the retro.

This helps us to develop the group language for talking about agentic development at a higher level. We’re doing collaborative engineering, using agentic tools. We need a new vocabulary for that. The retrospective is hugely important for building our team language and raising up junior engineers.

Conclusions

Ensemble or software teaming or Mob whatever you want to call collaborative coding easily breaks when we start using agentic ai tools. Other coaches have noticed the same problems as me and we’re all searching for good solutions. 

Today I’ve outlined a few techniques I’ve been using: 

• Quiet prompting.
• Reading agent summaries out loud.
• Naming the AI interaction patterns we’ve used.

I’m convinced we’ll all build better teams and better software if we work out how to apply more human minds to a software problem, especially when we’ve got agentic ai tools involved. 

Happy Coding!