Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How GitHub Reduced Code Review Bottlenecks
Transcript
- Lucas: The most invisible bottleneck in modern software engineering isn't usually the build server or the database query. It is the human handoff between writing code and approving it. I have been digging into how GitHub managed this specifically during their massive scaling phase around two thousand twenty four, when their platform growth started to literally choke their own internal velocity. Luna: Right, because if your engineers are waiting for reviews, they are context-switching away from deep work. That is a huge cognitive cost. What was the actual metric they tracked? Lucas: They measured median time to merge for internal pull requests. By mid-two thousand twenty four, that number had drifted up significantly. The data showed that while the volume of code submissions was rising linearly, the time it took for a senior engineer to actually look at the diff was growing exponentially due to notification fatigue. Luna: Notification fatigue makes total sense. You get pinged for everything, so you start ignoring pings until it becomes an emergency. Did they just tell people to check fewer emails? Lucas: No, they could not just mandate silence. Instead, they overhauled the entire signal hierarchy of their internal developer portal. They introduced what they called contextual priority scoring. Instead of a flat list of new pull requests, the system now ranked them based on impact, urgency, and reviewer expertise match. Luna: So it became a curated feed rather than a inbox zero chase? That sounds like a significant UI change, but does it actually solve the capacity problem? Lucas: It solves the visibility problem first. They also changed the incentive structure for reviewers. Previously, reviewing was seen as administrative overhead. They started tracking review contribution as a core component of promotion criteria, which shifted the cultural weight immediately. Luna: I love that. Making review a career accelerator rather than a chore is brilliant. But what about the reviewers who are already overwhelmed? How do they decide what to pick up? Lucas: This is where the automation layer got interesting. They deployed an ai assisted pre-review bot that would flag obvious style violations or test failures before a human ever saw the code. This meant that when a senior engineer opened their queue, the trivial stuff was already handled. Luna: Wait, so the AI acts as a gatekeeper? I am skeptical about trusting an algorithm to reject code before a human sees it. Does that cause false positives? Lucas: It did initially, which is why they made the bot non-blocking. It only added comments and warnings; it never auto-rejected. But it did filter out roughly thirty percent of the noise, allowing humans to focus on logic and architecture decisions. The result was a forty percent reduction in median review time within six months. Luna: That is a substantial drop. And it didn't require hiring more staff? Just better sorting and filtering? Lucas: Exactly. Zero additional headcount. They simply removed the friction from the existing workflow. The key insight was that review latency is not just a people problem; it is a product design problem for your internal tools. Luna: I agree. Most companies treat their internal developer portal as an afterthought. They use the same interface for submitting code as they do for filing expense reports. It needs to be treated like a customer-facing product. Lucas: Precisely. And GitHub realized that their developers are their primary customers. If the tooling is slow, the product ships slower. They also introduced async-first documentation requirements. Before a PR can be merged, the author must update the relevant docs, which prevents the post-merge scramble. Luna: That is such a simple fix that everyone forgets. Documentation drift is a silent killer of project velocity. Okay, so we have the tech side covered. What about the cultural pushback? Lucas: There was some. Senior engineers resisted the idea that their review quality was being quantified. They worried it would turn code review into a points-based game rather than a collaborative discussion. Leadership had to step in and clarify that the metric was about responsiveness, not volume. Luna: Good distinction. Responsiveness versus volume. If you measure volume, people will give lazy approvals. If you measure responsiveness, you still need to ensure quality. How did they prevent lazy approvals? Lucas: They used a combination of peer feedback and automated regression testing. If a reviewed PR caused a production incident, the review score was penalized heavily. This created a high-stakes environment where speed mattered, but accuracy mattered more. Luna: So accountability was tied to the outcome, not just the action. That feels like a much healthier dynamic. It forces people to actually read the code because they know the consequences. Lucas: Exactly. And it aligns individual incentives with team outcomes. When you decouple review speed from quality checks, you get one or the other, rarely both. Combining them creates a balanced system. Luna: This is a really practical case study. For any CTO listening, the takeaway is clear: audit your internal tooling. If your developers are complaining about wait times, it might be a design flaw, not a talent issue. Lucas: Right. And remember, this wasn't a one-time fix. They continuously iterate on the priority scoring algorithm based on feedback from the engineering org. It is a living system. Luna: Which brings us to the reality of maintenance. Even the best systems decay if you stop paying attention. Have you seen other companies try this? Lucas: We have seen similar approaches at Microsoft and Atlassian, though their implementations vary. The common thread is always treating the developer experience as a first-class citizen. Now, before we wrap up, I want to mention something important about how this show exists. Luna: Yeah, we are lucky to have a community that supports independent journalism. It allows us to dig into these detailed case studies without corporate interference. Lucas: If these conversations are useful for what you are building or running, a couple of dollars a month is genuinely what keeps these going. You can support us directly at buy me a coffee dot com slash fexingo. Luna: It helps us keep the research sharp and the ads out. Thank you to everyone who contributes. Now, back to the technical side, what about smaller teams who cannot afford custom tooling? Lucas: Great question. Small teams can implement many of these principles using existing platforms. You do not need custom AI bots. You just need strict conventions for PR templates and mandatory doc updates. Luna: So it starts with process discipline before you invest in automation. Enforce the rules, then optimize the tools. Lucas: Exactly. Process first, tools second. The GitHub example works because they aligned their culture with their infrastructure. Once you have that alignment, scaling becomes manageable. Luna: It is a reminder that technology problems are often organizational problems in disguise. Fix the org, and the tech follows. Lucas: Well said. As we move into the next quarter, I wonder if more companies will adopt these async-first review standards as remote work continues to fragment teams. Luna: I think we will see a wave of internal tooling updates focused on reducing cognitive load. The pressure to ship fast is only increasing. Lucas: Absolutely. And those who ignore the friction in their own pipelines will find themselves left behind by those who streamline it. Luna: Until next time, keep your code clean and your reviews clear.