Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How GitHub Built a Culture of Code Review
Transcript
- Lucas: Let's talk about the single most disruptive thing GitHub did to their own engineering culture: making code review a non-negotiable habit for everyone, including the founders. Most companies treat code review as a gatekeeping mechanism, but GitHub treated it as a teaching tool. Luna: That is a fascinating shift in framing. I have seen so many teams use review as a way to catch mistakes, which creates anxiety rather than learning. Lucas: Exactly. The goal wasn't just to find bugs; it was to ensure that knowledge about the system lived in multiple heads, not just one. When they started enforcing strict pull request policies, they saw a temporary dip in velocity because everyone had to slow down and read more carefully. But within six months, that dip turned into a steep climb in stability. Luna: So the initial friction was actually the investment period? I wonder if other tech giants tried this and gave up too soon during that dip. Lucas: Probably. It requires a lot of patience from leadership to stick with the new norm when the metrics look bad for a few weeks. They also invested heavily in tooling to make the review process itself less painful. They built internal dashboards that showed exactly how long a pull request sat idle, which created healthy pressure to respond quickly. Luna: I like that. Transparency on wait times is a powerful motivator without needing to micromanage individual developers. Lucas: Right. And they didn't just rely on guilt. They tied review responsiveness to team performance goals. If your team was leaving PRs open for more than forty-eight hours, it showed up in quarterly reviews. It sounds rigid, but it forced people to prioritize communication alongside coding. Luna: That is a bold move. Linking soft skills like communication to hard performance metrics usually gets pushback from senior engineers who just want to build things. Lucas: They anticipated that pushback. So they framed it as reducing context switching. The argument was that if you batch your review time, you can get back to deep work faster than if you are constantly interrupted by ping-pong comments on old tickets. It appealed to the engineer's desire for flow state. Luna: Oh, I see. Positioning review as a way to protect focus time is much smarter than positioning it as administrative overhead. Lucas: It really is. And they backed this up with data. They found that teams with higher review participation had significantly fewer production incidents. It wasn't just about catching syntax errors; it was about architectural alignment. When two people look at the same change, they naturally discuss the broader implications. Luna: That makes sense. Architecture drift happens when one person makes a subtle decision that others don't realize until deployment. Lucas: Precisely. So the review became a mini-design meeting. It kept the system coherent without requiring massive upfront design documents that nobody reads. It was lightweight governance, embedded directly into the workflow. Luna: I am curious about the onboarding aspect. Did new hires struggle to adapt to this high-pressure review environment? Lucas: Actually, no. New hires often thrived because the review process gave them immediate feedback on code style and expectations. Instead of waiting for a manager to notice a mistake, they got real-time correction from peers. It accelerated their ramp-up time considerably. Luna: That is a huge benefit. Most companies drag out onboarding for months because there is no structured feedback loop early on. Lucas: Exactly. And it created a culture where asking for help was normalized. Since everyone was reviewing each other's work, it was natural to ask questions in the comments. It broke down the silo mentality that plagues many engineering orgs. Luna: So the social capital built through review interactions paid off in better collaboration later? Lucas: Absolutely. By the time a project hit a critical deadline, the team already knew who to call for help because they had spent weeks discussing code together. Trust was baked in through the daily grind of pull requests. Luna: This feels like a case where process actually enables creativity rather than stifling it. Lucas: It does. You only have creative freedom when you trust that someone else will catch the basics. If you know your code will be reviewed thoroughly, you can take bigger risks on the innovative parts because you aren't worried about breaking something fundamental. Luna: I love that perspective. Risk-taking becomes safer when the safety net is strong. Lucas: Before we go deeper into the metrics they used to measure success, I want to pause for a moment. If these conversations are useful for what you're building or running, a couple of dollars a month is genuinely what keeps these going. Visit buy me a coffee dot com slash fexingo if you've gotten something out of them. Luna: Yeah, it really does add up. Every bit helps keep the research sharp and the episodes coming out consistently every day. Lucas: Thanks for considering it. Now, let's get back to those metrics. GitHub didn't just track the number of reviews per week. They looked at the cycle time from first commit to merge. Luna: Cycle time is such a vital metric. It tells you how fast value actually moves through the system. Lucas: Right. And they segmented that data by team size. They found that smaller teams, under ten people, could handle faster cycles because there were fewer dependencies. Larger teams needed more structured review windows to coordinate. Luna: That makes total sense. Coordination costs scale non-linearly as teams grow, so the review process has to adapt. Lucas: They also tracked the rework rate. How often was a pull request sent back for major changes after initial approval? A high rework rate signaled that the initial review wasn't catching structural issues, which meant reviewers weren't looking closely enough. Luna: So they were using rework as a proxy for review quality? That is a clever indirect measure. Lucas: It was very effective. Over time, they saw the rework rate drop below five percent. That level of quality control is impressive for a platform handling millions of lines of code daily. Luna: Five percent is incredibly tight. Most projects I see bounce around twenty or thirty percent before stabilizing. Lucas: Part of that was automation. They integrated static analysis tools directly into the review interface. If your code failed basic style checks, the reviewer never even saw it. It filtered out the noise so humans could focus on logic and architecture. Luna: That is essential. Nothing kills morale faster than reviewing code that fails obvious formatting rules. Lucas: Exactly. By removing the trivial distractions, they raised the average quality of conversation in the comments. People started discussing trade-offs and edge cases instead of complaining about indentation. Luna: It sounds like they created a virtuous cycle where better tools led to better conversations, which led to better code. Lucas: Yes. And that culture spread beyond just the engineering department. Product managers started requesting design reviews before writing specs. It became a company-wide standard for quality assurance. Luna: That is a remarkable cultural shift. Usually, product and engineering are at odds over scope and deadlines. Lucas: When both sides adopt a review mindset, they start collaborating earlier. Product gets feedback on feasibility sooner, and engineering understands the business context better. It bridges the gap significantly. Luna: I think a lot of organizations miss that opportunity. They treat handoffs as boundaries rather than integration points. Lucas: They do. GitHub showed that you can blur those lines intentionally to create a smoother pipeline. It requires discipline, but the payoff in speed and quality is undeniable. Luna: It definitely challenges the traditional view that more process means slower output. Lucas: It does. The key is that the process is lightweight and automated wherever possible. Heavy bureaucracy still kills agility. But smart, embedded guardrails like review can actually accelerate delivery. Luna: So the lesson isn't to add more meetings, but to embed quality checks into the existing workflow. Lucas: Spot on. Make the right thing the easy thing. If reviewing code takes five minutes and prevents a bug that takes five days to fix, the math writes itself. Luna: I wonder if other industries could apply this model. Maybe legal contracts or financial reporting? Lucas: Definitely. Any field where complex work requires coordination could benefit from structured peer review. It reduces risk and builds collective ownership. Luna: It seems like a universal principle for any knowledge-based work. How do we get there though? Lucas: Start small. Pick one area where mistakes are costly and implement a simple review protocol. Measure the impact. If it works, expand it. It doesn't have to be a grand overhaul. Luna: Practical advice. Start with the pain point, prove the value, then scale the solution. Lucas: Exactly. GitHub didn't change the world overnight. They changed their own workflow, one pull request at a time. Luna: And now that workflow is the standard for the entire industry. A small change can indeed ripple outward. Lucas: True. So the question for us is, what is one small review process we can tighten up in our own work this week? Luna: I am going to look at my email inbox. I need a better system for peer-checking important drafts before I send them out. Lucas: A great place to start. Let's see if that improves your clarity and reduces follow-up corrections.