4 mins read
Technical Retrospectives: When the Topic Is the Code
Most retros stay at the level of process. The standup runs long, a handoff gets dropped, a ticket was too vague to start. Those conversations matter, and they are usually where...

Most retros stay at the level of process. The standup runs long, a handoff gets dropped, a ticket was too vague to start. Those conversations matter, and they are usually where the quick wins are.
Some problems do not fit that shape. The test suite takes 22 minutes and people skip it. One module changes every sprint and breaks something each time. Review requests sit for two days. Nobody raises any of this, because the format asks how the team felt, and the answer is "fine, mostly".
A technical retrospective is the same meeting pointed at the code.
Code problems arrive as feelings
A system problem that reaches a general retro lands as an impression. "The codebase is hard to work in." "Reviews are slow." Everyone nods, nobody leaves with a next step, because the statement is too wide to act on.
That is not a failure of the people in the room. The format is built for team interaction, and the code is not a participant.
Pick one system, not the whole codebase
A technical retro works with a narrow scope. Choose one area for the session: the test suite, one service, the review process, the deploy pipeline, or the part of the app that keeps producing bugs.
Then ask three questions.
- What did this area cost us in the last month?
- Where did it surprise us?
- What is one change we can make in the next two weeks?
One area per session keeps the conversation concrete and stops it from turning into a general complaint about legacy code.
Bring numbers, not impressions
Feelings open the discussion. Evidence settles it.
Before the session, gather a small set of numbers for the area under review:
- The slowest tests and how often they fail without a real bug
- Median and worst-case time to first review
- How many bugs traced back to this module
- How often the pipeline failed for reasons unrelated to the change
You do not need a dashboard. A list of five flaky tests with their failure counts moves the conversation from "the suite is unreliable" to "these three specs fail once a day and everyone reruns the build".
Keep it blameless, keep it specific
Technical retros drift into blame faster than process retros, because code has an author.
The useful split is between the person and the design. "Ana's pull request broke the build" ends a conversation. "The build only catches this class of error at runtime, so passing locally tells you very little" starts one.
Ask what made the mistake easy. A missing test, an unclear interface, a shared helper with surprising behavior, a review that had no chance of catching it. The answer is usually a change to the system rather than a conversation with a person.
End with engineering work
The output should look like normal engineering work: a ticket, an owner, a date, a pull request.
Weak: improve test reliability. Useful: Sam quarantines the three flaky specs by Friday and puts them behind a separate job.
Small actions that ship beat a plan that sits in a document. If an action needs more than two weeks, split it until the first piece does not.
Keep the habit small
One technical retro a quarter is enough for most teams, plus the occasional extra session after a rough month. Put it on the calendar like any other retro, open with the actions from the previous one, and treat it as part of the same improvement loop rather than a separate engineering review.
SprintPulse keeps that loop in one place: retro notes, merged themes and owned action items with dates, linked to the Jira or Linear ticket where the work happens.
The code is part of how the team works. It belongs in the conversation.
Run the next retro with follow-through built in
SprintPulse turns feedback into owned, dated action items and keeps them visible in Jira or Linear after the meeting ends.