I'm interrupting the normal newsletter format to let you know about a workshop I'm giving. It's called The Confident Handoff. I'm giving it remotely to a small group of early adopters on November 22-23, 2021.
Handoff is that point in time where the pitch goes to the build team to start the cycle. Why give a workshop about it?
Whenever I ask Shape Up teams what they struggle with, they talk about challenges in the build phase:
- Unknowns and questions surface too late in the cycle
- The build teams cram and rush to finish on time
- The intent and purpose of the pitch gets lost along the way
To solve these problems, my first question is: What was your process at handoff? How did the team interpret the pitch, break down the work, and set a plan of action?
I ask about handoff because it's the critical moment. It's where the work gets broken down, where the purpose of the pitch is carried over or lost, where technical surprises come to the surface or remain hidden (until it's too late).
Most teams don't have a standard process for handoff. Whether it goes smoothly or not depends entirely on the experience level of the programmer. Senior programmers consider the whole project, break it apart, target the unknowns, and deliver slice by slice. Junior programmers, on the other hand, tend to dive straight into the code, start with whatever looks easiest, and get bitten by unknowns later on. Senior programmers try to mentor the junior ones, but they struggle to explain what they do. It all happens intuitively in their heads.
To solve this, I've prototyped and tested a new method for handoff that makes what experienced programmers do in their heads visible and teachable to others. (I prototyped an early version of it here on this newsletter).
Here's how the method works:
- After reviewing the pitch, the junior programmer is asked to do an exercise. They use a step-by-step template that guides them to define tasks, group them into scopes, and order them into a sequence. Doing the exercise makes them think, shows their thinking, and prepares them for input from the senior programmer.
- Then there's a meeting with a senior programmer. The senior person reviews the junior programmer's breakdown and approach. The template lets them see what the junior programmer is thinking. The senior person makes recommendations about how to scope or approach it differently and the junior person makes changes in real time.
- At the end of the meeting, both parties are more confident about handing over responsibility. The senior person is confident the junior person sees the whole, has the right starting approach, and is prepared to raise problems when they arise.
Companies who tested the method reported catching issues in the first day that normally wouldn't have come up until weeks later in the project. Here's a quote from a junior programmer who went through the exercise:
[Before doing this] I understood the pitch, but I couldn't really speak to what should be worked on first ... what goes together ... what might we be able to be cut if we're running out of time. ... I haven't written any code yet, and my feelings have drastically changed about whether I can deliver this well within the timeframe and deliver everything that's wanted.
In this workshop, you'll learn how to do the handoff exercise, how to teach it to your programmers, and how to structure the handoff meeting to build confidence in your team.
We'll also look forward and backward from the moment of handoff to understand how to better format pitches, deal with discovered work, and keep tasks and scopes alive as the work changes.
Who's this for?
Senior technical and product people. Those working in Shape Up cycles will get the best results.
Size: < 20 people
Dates and times:
November 22 and 23, 2021
Deadline to apply:
October 27, 2021
Tickets available to qualified applicants:
November 1, 2021
$500/person, $900/two people
To participate, please use the link below to apply before October 27, 2021.
Apply to participate
If you have any questions, you can write me directly at email@example.com.