Technical coaching in XP and TDD: extreme programming practices learned on your own code

QMates technical coaching brings extreme programming (XP) practices into your team, starting with TDD, pair programming and mob programming, and it works on the code the team has to ship right now. It suits a team that wants to change how it works, a tech lead who has to bring these practices to their group, or a developer who wants to learn them properly, which is why we focus on a few practices at a time. The people who work alongside you use extreme programming on the projects QMates delivers for clients too.

Book a call

When do you need technical coaching?

You need it when the team knows it should work differently and can't manage it while delivering. The signs look like this:

  • Tests get written at the end, if there's time, so often they don't get written at all
  • A month after the TDD course, nobody is still practising it
  • Every change needs a long manual check before release
  • Pair programming was tried and dropped because it looked like double the cost
  • Knowledge of some parts of the codebase sits in the heads of one or two people
  • A newly appointed tech lead has to guide the team on technical practices and nobody has prepared them for it
  • Code reviews keep getting longer and have become the place where design is discussed, after the work is done

What do we do?

We work with the people in your team on their own tasks, and choose the format as we go: a pairing session, a group session, an exercise or a few days of training. The format depends on what the team needs to learn and how much time it can give to it.

Pair and mob programming on real code

We sit alongside your developers, on site or remotely, on the stories in the sprint. In pair programming we work with one person at a time and swap the keyboard. In mob programming the whole team works on the same problem, which is the format we use when a design decision affects everyone or when only one person knows a part of the code.

TDD on the team's own tasks

Test-driven development is learned by writing the first test for the feature due to ship that week. We work on the red, green, refactor cycle, on choosing the next test, and on how tests shape the design of classes and modules. When the code to be changed is legacy and has no tests, the work starts from characterisation tests, which we describe on the Legacy Code Refactoring page.

Coding dojos and katas

A coding dojo is a group session on a short exercise, the kata, where how you get there matters more than the result. We use it to practise, away from production code, what would cost too much to get wrong there: small steps, frequent refactoring, names taken from the domain. It can become a regular slot in the team's week, run by the team itself.

Targeted courses on technical practices

When the team needs a shared baseline, we run courses of a few days on TDD, refactoring, simple design, hexagonal architecture and pair programming, whatever the language. We build them around the team's needs, and they work best when followed by sessions on real code, because a course on its own leaves knowledge that daily work soon wears away.

Coaching for tech leads and individual developers

We also work with a single person: a tech lead who has to bring the practices into their team, a senior developer who wants to become a technical reference point, someone who has just joined and needs to become independent on a codebase they don't know. Sessions alternate pairing on the code with discussion of the decisions that person has to make in their role.

TDD and pair programming with AI agents

Coding assistants write code fast, and TDD becomes the way to decide first what that code should do. We show the team how to pair with an agent following the red, green, refactor cycle, with human oversight at every step, so tests remain the specification of behaviour even when the agent writes the code.

How do we work with your team?

Every session starts from a real task the team is working on. It leaves behind a practice tried on your code and a concrete exercise for the team to work on until the next session.

Technical coaching is more targeted and more occasional than Embedded Teams. With Embedded Teams we join your organisation full time and develop alongside the team for the whole project. With technical coaching we work on a few practices with the people who have to adopt them, and the team carries the work forward on its own between sessions. It is often the right format when the team already handles delivery and needs to change how it does it.

We adopt your stack, your tools and your way of organising work. Even the least experienced of us has eight years of extreme programming behind them, and each of us practises every day what we teach, on the projects where we develop for clients.

What do we measure to find our bearings?

Wherever possible, we steer by measurement. Where we can't, we describe the systemic effects we see in the team and the factors worth looking into. DORA metrics, cycle time, lead time and value stream mapping are some of the metrics and techniques we use to guide continuous improvement, and they look at the team's flow of work without assessing individuals.

The effects of the practices also show in the code and the repository: smaller changes, more frequent integration into the main branch, changes that arrive with their tests, fewer defects after release. When these signals don't move, that is where the next session picks up.

What changes for the team and the product?

The way the team works every day changes, and the code shows it:

  • Tests are born with the code, and a change that breaks something is caught straight away
  • Changes are made in small steps, and a release stops being an event that takes days to prepare
  • The design improves with every change
  • More people know each part of the codebase, and an absence no longer halts a delivery
  • Tech leads guide the team on practices they have used first-hand on their own group's code
  • Between sessions the team already works with the new practices on its own, and that is where you see whether it has made them its own

Where do you start?

You can start straight from technical coaching, with a first session on the team's code. If the slowdowns have causes beyond practices, we recommend starting with the Software Delivery Assessment, which identifies the bottlenecks in code, practices, flow and organisation and tells you whether coaching is the right lever.

Related services

Frequently asked questions

What is technical coaching?
Technical coaching means experienced developers working alongside a development team and teaching technical practices such as TDD, pair programming and refactoring on the team's own code. It differs from classroom training because the practices are learned on real tasks, with immediate feedback. QMates does it from the standpoint of extreme programming, the method it also uses to develop its own projects.
How does technical coaching differ from Embedded Teams?
Embedded Teams brings full-time QMates developers into your team, who deliver with you and pass on their method for the length of the project. Technical coaching is more targeted and more occasional. It runs in sessions, on a few practices and with the people who have to adopt them, and the team carries on the rest of the work. The two formats can be combined, and coaching can follow Embedded Teams to support the practices once the team is working on its own.
Does TDD work on legacy code too?
Yes, with one extra technique. Before changing the code you write characterisation tests, which pin down the current behaviour and act as a safety net. This is the work we describe on the Legacy Code Refactoring page. Technical coaching teaches TDD on new code and on changes, and points you there when legacy is the main problem.
Doesn't pair programming double the cost?
Two people on one task write fewer lines an hour, but they review each other's work as they go, share knowledge and make design decisions together. In our experience, the time you win back in code review, defects and handovers makes up for the time spent in pairs. During coaching we show when pairing pays off and when it is better to work alone.
Do we have to stop delivering to do technical coaching?
No. We work on the tasks already planned, so every coaching session also produces shippable code. Coding dojos and courses need dedicated time, and we agree it with you so that it doesn't weigh on the team's commitments.
Does technical coaching work with our language and stack?
Yes. Extreme programming practices don't depend on the language, and we work with the stack, tools and processes you already use.

Want to bring TDD and pair programming into everyday work?

Tell us how your team works today, and we'll start from the practices you need most

We use your data to respond to your request. Read our Privacy Policy.