Software teams constantly wrestle with a fundamental dilemma: deliver new features quickly or take the time to ensure code quality and maintainability. Traditional mobbing (mob programming), where the whole team works together at one workstation, maximizes shared understanding and code quality through constant peer review. However, that thoroughness can slow down progress. On the flip side, AI-assisted development can turbocharge coding output, but it often comes at the expense of maintainability and team alignment. Everyone’s seen what happens when one developer uses an AI tool in isolation, you get speedy code that may not fit the team’s standards or long-term vision.

What if your team could get the best of both worlds? Recently, Atlassian’s Micros Extensibility team set out to do exactly that. They experimented with mobbing with AI, blending the collaborative rigor of mob programming with the speed and exploratory power of AI tools. The goal was ambitious: deliver faster without sacrificing code health. Over a couple of months, they refined a workflow that does just that. In this blog, we’ll explore what they learned, why this approach works, and how you can apply mobbing with AI to boost your own team’s productivity.

Speed vs. Maintainability: The Classic Tradeoff

At the heart of every software project lies a tension between speed and maintainability. On one side, speed is all about shipping features quickly, responding to stakeholder requests, and keeping momentum high. It measures how fast you can turn ideas into working software. On the other side, maintainability is about building a codebase that’s clean, consistent, well-tested, and resilient. High maintainability means future developers can easily understand and extend the code without breaking things. The challenge is that optimizing purely for one often undermines the other. Teams that focus only on speed might cut corners, introduce duplicative or fragile code, and incur technical debt that slows them down later. Teams that focus only on maintainability might fall into “gold-plating”, polishing every component and handling every edge case, but making painfully slow progress on new features. In practice, software leaders and developers are always trying to balance these two forces. Is it possible to increase development velocity and improve code quality at the same time? Mobbing with AI proposes a compelling “yes” by combining approaches that traditionally sat at opposite ends of that spectrum.

Speed vs maintainability chart comparing AI, solo development, mob programming, and mobbing with AI.

Why Mobbing + AI is a Winning Combination

Mobbing leans toward maintainability and knowledge-sharing, while AI tools lean toward pure speed. When used together, they fill in each other’s gaps. Here are several reasons this combination works so well:

AI handles the tedious parts, fast. Instead of a whole team spending 30 minutes writing boilerplate code or setting up basic test cases, an AI tool can generate that in seconds. The human team then reviews and tweaks the AI’s output to fit their standards. This means less time on rote coding and more on higher-level design and decision-making.
The team ensures quality and shared understanding. AI-generated code isn’t always perfect and it might not follow your architecture, or it could include subtle bugs. In a mobbing-with-AI scenario, everyone is reviewing AI suggestions together in real time. Mistakes or mismatches with the project’s style are caught early. The code that goes into your repository is understood and vetted by the whole team, not just tossed in by one person and a bot.
Continuous exploration without breaking flow. In a normal mob programming session, hitting an unknown might require someone to step away and research or prototype, temporarily splitting the mob. With AI, the team can ask for a quick prototype or example right on the spot. For example, if they’re unsure how a new library works, they can prompt the AI to generate a simple usage snippet. The mob can immediately evaluate it, discuss pros and cons, and decide on the next steps all without losing momentum or leaving anyone behind.
Everyone learns the AI tools together. Using AI in a group setting also boosts the whole team’s AI literacy. Rather than one “AI power user” on the team, everyone gets exposure to crafting prompts, analyzing AI outputs, and refining suggestions. Over time, the team as a whole becomes more skilled at leveraging AI for development. This shared competence prevents silos and spreads knowledge evenly across the group.

Together, these dynamics turn the usual tradeoff on its head. Mobbing with AI isn’t about averaging speed and quality, it’s about multiplying the benefits. The team can deliver quickly and build software that lasts, because speed and maintainability stop being a zero-sum game.

Mobbing with AI in Action: How One Team Blended Human and Machine

Let’s look at how Atlassian’s team put mobbing with AI into practice. This will give a concrete picture of how a session is structured and how work gets done. In their experiment, mobbing sessions typically involved 2 to 4 developers working together at a time. Developers could join or leave as needed, but at any given moment one person was the designated facilitator. The facilitator shares their screen with the code editor, writes code or prompts into the AI, and essentially “drives” the session. To keep everyone engaged, the facilitator role isn’t fixed and it rotates among team members during the session so that everyone gets a turn behind the wheel and no one tunes out.

To complement the human mob, the team assembled an AI squad, a set of AI tools, each with a special role in the workflow. These included:

AI coding assistant (CLI-based): A command-line tool the team could prompt for generating code snippets or entire functions on demand. This AI agent would take the current task description and coding standards as input and output a first draft of code.
In-editor AI autocompletion: Each developer had an AI-powered code completion tool in their own IDE. This provided on-the-fly suggestions and quick fixes as code was being written or reviewed, helping individual team members stay productive even while one person was typing.
AI chat for questions and ideas: The mob also used an AI chat assistant to ask ad-hoc questions. This was handy for clarifying how an unfamiliar library works, checking syntax, or even brainstorming design approaches. Instead of someone leaving the room to Google answers, the answer came instantly into the mob’s discussion.
AI code reviewer: Once the team had code ready in a branch or pull request, an AI code review agent could automatically critique it. This agent would check the changes against the team’s custom guidelines and testing standards, flag potential issues, and suggest improvements. It served as a tireless second pair of eyes, helping catch things the team might miss in the heat of development.

Equipped with this lineup of AI helpers, the team followed a consistent workflow for each feature they tackled. The process was highly iterative and collaborative, with the mob guiding the work and the AI accelerating execution at each step. Let’s break down the step-by-step workflow they used to blend mob programming with AI assistance.

Workflow diagram showing mob programming with AI, from defining guidelines to retrospective.

Step-by-Step: Mobbing with AI Workflow

Set standards and guidelines: The whole team begins by agreeing on coding and testing standards for the task at hand. This means nailing down things like naming conventions, project structure, code style, and what “done” looks like for tests. By defining these ground rules up front, the team gives the AI a clear frame of reference. The AI’s code suggestions will be more consistent and on-brand if it “knows” the style and conventions the team expects.
Define the task and write a lightweight spec: Next, the mob aligns on what needs to be built. They might sketch out a quick specification or list of requirements for the feature or sub-task. It’s important to break the work into small, well-scoped tasks that can be tackled one at a time. Smaller tasks mean faster feedback loops and less chance of getting off-track. The team at Atlassian created a simple spec template to fill out for each task. In fact, they even let the AI help here: sometimes they would ask the AI to draft a task spec based on the template and their initial notes, then the team would refine that draft. This saved time on writing boilerplate specs from scratch and often raised questions the team hadn’t considered. If the mob ran into an open question they used the AI chat to generate a couple of quick option outlines or prototypes. The group would then review those AI-suggested options and decide together, ensuring they made informed decisions without sending someone off on a solo research spike.
Develop in cycles: With a clear spec for a small task, the team moves into a tight development loop. Here’s how a typical cycle goes:
- AI generates code: The facilitator prompts the AI coding assistant to produce an initial code implementation. The AI returns a first draft of code.
- Team reviews and refines: The mob examines the AI’s code suggestion together. They might spot logical errors, areas that don’t follow their architecture, or simply opportunities to improve clarity. They discuss these and the facilitator edits the code accordingly. This step is crucial – the AI’s output is not final until the team is happy with it. Any changes the team makes here are also fed back into the shared understanding.
- AI generates tests: Once the code looks good, the team prompts the AI to generate test cases for it, whether unit tests, integration tests, or scenario tests, depending on the task. The AI can quickly spit out a suite of tests that cover basic cases.
- Team reviews and refines tests: Just as with the code, the mob goes over the AI-created tests. They ensure the tests make sense, truly verify the intended behavior, and cover edge cases they care about. The team might add a couple of additional tests or modify the AI’s tests for clarity and completeness. This also helps teach the AI what “good tests” look like for next time.
The team repeats this generate→review→refine cycle as needed. They aim for small iterations, often implementing one small piece and testing it before moving on. For example, they might write one or two tests first and get them passing, then let those serve as examples for the AI to generate more tests. By keeping each cycle short, they avoid doing big bang changes that are hard to debug. The tight feedback loop ensures any issues are caught early, and the AI’s suggestions get better aligned with the project’s needs after each iteration.
Iterate and evolve the solution (team + AI): As each small task is completed, the team updates the spec and moves on to the next one, feeding the latest code and decisions back into the AI’s context. This continuous updating means that the AI “learns” more about how the team works as the project progresses. Early on, there might be more back-and-forth, the AI’s first drafts could miss the mark, requiring several rounds of refinement. But later, as the AI has more examples of the team’s preferred patterns and the spec becomes more complete, its output comes much closer to what the team expects on the first try. In Atlassian’s trial, the first few tasks required a lot of guidance, but later tasks were completed with far fewer prompts because the AI could reference the growing codebase and specification as examples of the desired outcome.
Capture knowledge and update documentation (team + AI): Once a feature is finished, the team makes sure to update documentation so that their hard-won knowledge is preserved. Here, the AI can assist as well. The team can prompt the AI to take the final spec and code and produce supporting docs – for example, updating the spec document to reflect what was actually built, or even generating diagrams of the system’s design using a syntax like Mermaid. This ensures that the documentation isn’t left behind as the code evolves. By the end of the project, the spec serves as accurate documentation of the system, thanks in part to these AI-generated updates.
Reflect as a team (team activity): After each major effort or feature, the mob holds a short retrospective. They discuss what went well and what was tricky when using the AI. Did using the AI actually save time in this case? Did any of its suggestions cause confusion or need a lot of rework? The team might decide to adjust their prompting techniques or update their coding standards based on these lessons. This continuous improvement cycle helps them get better at mobbing with AI the more they do it.

Throughout this workflow, the human team is in the driver’s seat on decisions, quality, and understanding, while the AI acts as an accelerator and assistant. It’s a true collaboration: the mob guides the AI, and the AI’s output informs the mob’s next steps.

Results: Faster Delivery and Better Code

So, what was the outcome of this experiment in blended teamwork? In short, the team delivered more, faster – without the usual downsides. Over roughly two months, the team implemented or significantly updated around ten features in their system. Each feature was non-trivial, yet most of these were designed, coded, and merged into the codebase within a day or two each. Under the team’s previous workflow, a change of that scope might stretch over a week, often bogged down by multiple rounds of code review and rework. With mobbing and AI, the initial development was quicker and the entire team had already reviewed the code before the formal pull request, so the review cycle was almost a formality.

Moreover, as the project went on, the quality of the AI-generated output clearly improved. Early in the experiment, the AI’s first attempt at a piece of code might only get things “half right,” requiring several edits and clarifications from the team. But by the end, the AI was regularly producing drafts that were perhaps 80% correct on the first pass. Often, just one or two small tweaks from the developers were enough to get the code ready to merge. This jump in accuracy came from the AI having more context it was effectively learning “how this team works” from the evolving spec, the coding standards, and the code it had helped write so far.

An arguably even bigger win was the shared understanding and confidence within the team. Because everyone worked on everything together, every developer knew how each new feature was implemented and why it was built that way. In traditional development, you might merge a teammate’s code with only a skim of their work, or discover design decisions during a hand-off; in mobbing with AI, there are no surprises because the whole team is present for the entire journey of a feature. This level of collective code ownership bodes well for maintainability down the line, anyone on the team can modify or fix that code, since they were part of creating it. It’s exactly the outcome mob programming strives for, now achieved at a much higher speed thanks to the AI boost.

Beyond Coding: Other Ways AI Supports Development

The story above focused on using AI during coding and testing, but the team found value in applying AI across other stages of the software development lifecycle as well. Here are a few other areas where AI can make a difference:

Requirements gathering and analysis: AI can assist in the early project phases by drafting and refining requirements. For instance, you can provide an AI with a summary of stakeholder requests or project goals, and it can help organize them into a structured list of functional and non-functional requirements. This ensures you haven’t missed anything obvious and can highlight ambiguities to resolve. For example, one team fed the AI a description of a proposed system’s goals and constraints; the AI returned a draft requirements document covering core features, performance targets, and integration considerations, which the team then discussed and tweaked. Using AI as a virtual business analyst can jump-start the conversation and give the team a solid starting point.
Spikes and prototyping: When you need to evaluate new technologies or compare different solutions, AI can generate quick proof-of-concept code to save you time. Let’s say you’re deciding between two libraries for a task, you could ask an AI assistant to implement a simple example using each library. By quickly reviewing these AI-generated prototypes, the team can gauge the complexity and elegance of each approach without spending hours writing disposable code themselves. This rapid prototyping helps teams make informed architectural decisions while keeping the whole mob in the loop.
Design and architecture discussions: AI can even help at the design level. Teams have used AI tools to propose multiple architecture diagrams or sequence flows based on a system description. An AI might output a few different models in diagram form. These visuals give the team concrete options to debate. Additionally, if your team uses a language like Mermaid for diagrams, you can ask the AI to produce a Mermaid syntax for a flowchart or component diagram of your system. It’s a quick way to visualize ideas during a design meeting.
Code review and quality assurance: We touched on this with the AI reviewer agent essentially, AI can be a tireless code reviewer checking for common issues. By training an AI on your project’s standards and past code reviews, it can automatically flag things like inconsistent formatting, missing unit tests, complex functions that need refactoring, or potential bugs. While human judgment is irreplaceable for higher-level feedback, an AI reviewer can handle the repetitive checklist items in seconds. This not only saves the team’s time, but it also means developers get near-instant feedback on their code. They don’t have to wait hours or days for a colleague’s review to catch something straightforward.

In all these cases, the theme is using AI as an assistant to amplify the team’s capabilities. It’s not making decisions for you, but it provides quick drafts, suggestions, or checks that help the humans work more effectively. By incorporating AI at various stages, teams can reduce drudgery and focus more on creative, value-added work.

Tips for Working Effectively with AI

If you’re intrigued by the idea of mobbing with AI or simply using AI in your development workflow, here are some practical tips to keep in mind:

Start small and iterate: Don’t ask the AI to build your entire feature in one go. Begin with a tiny, well-defined task. Let the AI give you a draft, then review and refine it with your team. As you and the AI become more confident, gradually increase the scope. This iterative approach helps the AI learn your preferences and lets your team gain trust in the AI’s outputs.
Manage expectations: Think of AI as a smart assistant, not an infallible autopilot. The AI might not get things perfect on the first attempt – and that’s okay. Your goal is to have it produce a useful starting point that you can then improve. By treating initial AI outputs as drafts, the team stays in control and isn’t disappointed when some manual adjustments are needed. Over time, you’ll see the draft quality improve.
Keep prompts and specs up-to-date: An AI is only as good as the context you give it. Treat your prompt as a living document. Whenever your team makes a decision feed that information back into the AI on the next prompt. Keeping the AI “in the loop” on these evolving standards means its suggestions will stay aligned with the team’s direction.
Use examples to guide the AI: One of the most powerful ways to get better output is to show the AI an example of what you want. This could be an existing code snippet that represents your preferred style, or a sample test case that follows your format. By giving a concrete example, you reduce ambiguity and help the AI mimic your team’s style and structure. Essentially, you’re teaching by example, which is often more effective than abstract instructions.
Always review AI output together: No matter how good the AI seems, never skip the review. The mob-review step isn’t just about catching errors – it’s where the team builds understanding and consensus. Make sure at least one of the developers reads through every line of AI-generated code or text. Use it as an opportunity to discuss why something is written a certain way. This not only ensures quality and maintainability, it also turns every AI suggestion into a learning moment for the team.

The Future of Teamwork with AI

The experiment in mobbing with AI demonstrated that development speed and code maintainability don’t have to be at odds. By combining the collective brainpower of a team with the rapid automation capabilities of AI, teams truly can deliver features faster without sacrificing quality or shared understanding. It’s a glimpse into a future where AI is woven into the fabric of teamwork not as a replacement for human developers, but as a force multiplier. The key insight is that simply using AI isn’t enough; it matters how you use it. When an entire team is involved in prompting, reviewing, and refining AI-generated work, you avoid creating silos of knowledge. Instead, you spread skills and insight across everyone. In this model, AI becomes a collaborative partner at the table, a powerful tool that the whole team wields together. It’s not a magic button that writes your software for you, but it amplifies what a well-coordinated team can accomplish. If your team is looking to boost productivity while keeping the codebase clean and healthy, consider giving mobbing with AI a try. Start with a small project or a single feature. Set some clear standards, experiment with an AI coding assistant or two, and see how it fits your workflow. Be ready to adapt and learn as you go treat it as an experiment. You might just find that by working side-by-side with AI, your team can achieve more than you ever thought possible.

Interested in learning more? Contact Atlas Bench to book a complimentary consultation with our Certified Atlassian Experts.

Boost your team’s speed and code quality with Atlassian tools. Try them today and experience AI-powered collaboration in action.

undefined

Atlas Bench is a Platinum Atlassian Solution Partner with deep Cloud Specialization, helping Data Center customers move beyond migration and fully transform on the Atlassian Cloud Platform. We deliver Atlassian’s System of Work end to end through four collections: Strategy, Teamwork, Service, and Software, connecting planning to execution, aligning teams around outcomes, modernizing service delivery, and accelerating software development.

We are also recognized as an Atlassian World Class Software Development Partner of the Year (Americas), and we bring AI leadership to every engagement. By leveraging Rovo for automation and purpose built agents, we reduce manual work, unlock knowledge across tools, and speed up decision making so organizations realize measurable value faster in cloud.

Mobbing with AI: Boosting Speed and Quality Through Teamwork