Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / Why Code Reviews Are The Real QA
Transcript
- Lucas: We spend a lot of time talking about automation, about chaos engineering, about shadow testing, but I want to talk about the single most underrated safety net in modern software engineering: the humble code review. It’s not flashy, it doesn’t generate headlines, but if you look at the incident reports from major platforms, nearly half of them trace back to a logic error that should have been caught by a second pair of eyes. Luna: Right, because automation catches syntax errors, but it rarely catches bad intent or flawed assumptions about how a user might misuse a feature. Lucas: Exactly. And here is the thing that surprises a lot of people who aren’t deep in the weeds: the size of the review changeset matters more than the tool you use. Data from companies like Google shows that when pull requests exceed six hundred lines of code, the probability of a bug slipping through rises sharply. It’s not just fatigue; it’s cognitive load. Luna: So we are basically asking humans to perform high-stakes pattern recognition while multitasking? That sounds exhausting. Lucas: It is. But the real issue isn’t just the volume of code; it’s the culture surrounding the review. Too many teams treat reviews as a gatekeeper function where one senior engineer holds the keys to production. This creates a bottleneck and, worse, a single point of failure for institutional knowledge. Luna: Which means if that senior person is out sick or leaves the company, the whole pipeline stalls. Or worse, nobody knows why the legacy code works the way it does. Lucas: Precisely. Atlassian, for instance, shifted away from a strict approval model toward a distributed ownership model. They encourage multiple reviewers, even junior ones, to comment on PRs. The goal isn’t just approval; it’s shared context. When five people read your code, you’ve effectively onboarded five people on that specific module. Luna: That’s a fascinating pivot. You’re trading a small amount of review speed for a massive gain in collective brainpower. Lucas: You are. And it forces a conversation. Instead of a silent thumbs-up, you get questions like, 'Why did you choose this algorithm?' or 'How does this handle edge cases?' Those questions are where the actual quality assurance happens. It’s not the linting tool; it’s the dialogue. Luna: But doesn’t that slow down velocity? If everyone has to wait for five people to chime in, deployments must take forever. Lucas: Not necessarily, if you decouple review time from approval authority. You can request comments from anyone, but only require approval from one or two domain experts. This allows junior engineers to learn by reading code without blocking the merge queue. It’s a mentorship engine disguised as a quality check. Luna: I love that framing. Mentorship engine disguised as bureaucracy. That’s exactly how good engineering culture scales. Lucas: And let’s be honest about the other side of this coin: the emotional labor. Code reviews can feel personal. A critique of your code feels like a critique of your worth. Teams that fail here don’t fail because their tools are bad; they fail because they haven’t established psychological safety. Luna: Yeah, I’ve seen devs get defensive when someone points out a race condition. It’s hard to separate ego from output. Lucas: It is. The best teams I’ve worked with normalize the idea that code is an artifact, not an identity. They use language that focuses on the system, not the person. 'This function is confusing' instead of 'You wrote this badly.' It sounds subtle, but it changes everything. Luna: So the soft skills are actually the hard constraints for technical success? Lucas: Absolutely. Without that baseline respect, reviews become political minefields. People stop submitting PRs early because they’re afraid of criticism. They submit massive batches hoping no one looks closely. Which brings us back to our earlier point about batch size. Luna: Right, fear drives large batches, which drives missed bugs, which drives fire drills. Lucas: A vicious cycle. Now, there’s another layer here that we need to address, and it’s about the timing of the review. Waiting until the code is written is often too late. Some teams are adopting pre-review discussions, or design docs, where the architecture is debated before a single line of code is written. Luna: So you’re shifting the QA left even further, into the planning phase? Lucas: You are. And it saves enormous amounts of rework. If you catch a flaw in the design doc, it costs pennies to fix. If you catch it after merge, it costs thousands. But here is the catch: you still need the code review to ensure the implementation matches the design. You can’t skip the second step. Luna: Makes sense. The design doc sets the map, but the code review checks if you actually drove the car off the cliff. Lucas: Perfect analogy. And speaking of driving off cliffs, let’s take a quick breath. If today's tech conversation gave you something usable, consider supporting the show directly. A couple of dollars a month is genuinely what keeps these going — buy me a coffee dot com slash fexingo — that's F. E. X. I. N. G. O. Luna: Yeah, it really helps keep the lights on and lets us dig deeper into these kinds of operational details rather than just skimming the surface. Lucas: Thanks for listening. Anyway, back to the mechanics. One metric that often gets ignored is the review turnaround time. How long does a PR sit idle? If it sits for more than twenty-four hours, it usually indicates a blocker, either in the reviewer’s workload or in the code’s complexity. Luna: So idle time is a warning sign, not just a nuisance? Lucas: It is. Long-lived PRs tend to accumulate merge conflicts and drift from the main branch. By the time they are reviewed, they are no longer fresh in the reviewer’s mind, nor the author’s. The context window has closed. You’re reviewing stale code against a moving target. Luna: That’s a great reason to enforce shorter cycles. Keep the context hot and the feedback loop tight. Lucas: Exactly. And this ties into automation again. Use bots to nudge reviewers. If a PR hasn’t been touched in four hours, ping the assigned reviewer. If it’s been twelve hours, escalate to a secondary reviewer. Automate the pressure, not the judgment. Luna: So the bot is the project manager, not the judge? Lucas: Correct. The bot ensures flow; the humans ensure quality. When you mix those up, you get either bottlenecks or disasters. There is a middle ground, though, and it’s called asynchronous review. Not everyone needs to review every PR. Domain expertise matters. Luna: So if I’m working on the billing module, I shouldn’t expect my frontend specialist to deeply audit my database queries? Lucas: No, but they might notice if the API contract changed unexpectedly. That’s the beauty of cross-functional reviews. You don’t need expertise in every line, just enough to spot integration risks. It turns the review into a network effect rather than a hierarchy. Luna: Network effect. I like that. It makes quality a communal responsibility rather than a checkpoint. Lucas: It does. And that shifts the incentive structure. When quality is communal, people are less likely to cut corners because they know their peers will see it. Social accountability is a powerful motivator, often stronger than any policy document. Luna: Unless the social accountability becomes toxic, of course. Which brings us back to that psychological safety point. Lucas: Always. Toxicity kills collaboration faster than bad code kills servers. You need a culture where pointing out flaws is seen as helping, not hindering. It takes time to build, but it’s the foundation of everything else we’ve discussed today. Luna: So, code reviews are less about finding bugs and more about building a resilient, informed team? Lucas: Spot on. The bugs are just the visible symptom. The real product is the team’s ability to communicate complex ideas clearly and consistently. If your reviews are good, your software will be good. It’s that simple, and that hard. Luna: Hard work, but clear work. Much better than guessing what the black box AI test suite found wrong. Lucas: Much better. AI can suggest patterns, but it can’t understand the nuance of why a workaround was necessary three years ago. Humans bring that historical context to the table. Never underestimate the value of looking over someone’s shoulder. Luna: Or looking over their shoulder via a screen. Either way, presence matters. Lucas: Presence matters. As we move into the next quarter, with all the usual deployment pressures, maybe the best thing your team can do is slow down the merge rate and speed up the conversation. Quality isn’t about speed; it’s about clarity. Luna: Clarity over speed. I think that’s a rule worth writing down above every desk. Lucas: I’d print it on sticky notes. Thanks for hanging out with us on Software Testing with Fexingo.