Skip to main content
Blog

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...

A code editor and a retro board linked by a line of action cards

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.