Latest / The CTO Podcast with Fexingo: Technical Leadership, Architecture, and Engineering Org / How GitHub Solved the Merge Conflict Crisis
Transcript
- Lucas: If these conversations are useful for what you're building or running, remember that listener support is exactly what keeps this network ad-free and focused on the substance. Luna: Yeah, and if you want to help us keep doing deep dives like this without interrupting them with ads, the link is buy me a coffee dot com slash fexingo. Lucas: Thanks for that. Now, let’s get back to the core tension in modern engineering: the gap between writing code and shipping it. Specifically, I want to talk about something every CTO has felt but rarely admits to as a primary pain point. It isn’t server latency. It isn’t even cloud spend. It’s the merge conflict. Luna: That feels almost too simple, Lucas. Is it really just about git commands getting messy? Lucas: It sounds simple until you realize it’s actually a symptom of broken collaboration flows. When we look at GitHub’s internal data over the last few years, they found that developers spent roughly twenty percent of their workweek resolving merge conflicts or waiting for code reviews to unblock them. That’s not a tooling problem. That’s a structural one. Luna: Twenty percent is huge. That’s basically a full day lost every week per engineer. How did they even measure that kind of friction? Lucas: They used telemetry from their own platform, tracking time to merge and time between commits. They noticed a pattern where large teams with many simultaneous contributors had exponential increases in conflict rates, not linear ones. The more people wrote code, the harder it became to bring it together cleanly. Luna: So they weren't just looking at error logs; they were looking at time stamps and commit histories? Lucas: Exactly. And what they realized was that traditional branching models, like long-lived feature branches, were creating artificial bottlenecks. Developers would sit on a branch for weeks, letting it drift further from main, which guaranteed a painful rebase later. GitHub decided to tackle this by changing how they encouraged people to interact with the central codebase. Luna: Did they force everyone onto short-lived branches, or was it more about the review process itself? Lucas: It was both, but the key innovation was the cultural shift around 'draft' status. Before this, pulling up a pull request often signaled 'I’m done, please review.' But many PRs were half-finished tests or incomplete features. GitHub introduced a clearer semantic distinction between a draft pull request and a ready for review request. Luna: That seems like such a small UI change. Why does labeling something as a draft matter for merge conflicts? Lucas: Because it changes the behavior of reviewers. When a PR is marked as a draft, reviewers don’t feel pressured to do a full line-by-line audit. They can wait until the work is actually stable. This reduces premature feedback loops that often lead to fragmented discussions and scattered comments, which then become harder to resolve during the actual merge phase. Luna: So it’s about managing expectations. If reviewers know it’s a draft, they hold off, and the author stays focused on finishing rather than answering questions prematurely. Lucas: Right. And that focus allows for smaller, more frequent commits. Smaller commits mean smaller diffs. And smaller diffs are exponentially easier to merge without conflicts. It’s a basic principle of systems design that applies here: reduce the surface area of change. Luna: But doesn’t requiring smaller commits slow down individual programmers who prefer to batch their work? Lucas: It can, initially. But GitHub’s data showed that the time saved in review and merge outweighed the overhead of committing more frequently. They also automated much of the boilerplate. For example, they introduced required checks that run before a PR can even be submitted if certain criteria aren’t met. This prevents broken code from ever entering the conversation. Luna: So they moved the failure state earlier in the process. Fail fast, fail locally, instead of failing in production or during integration. Lucas: Precisely. And they tied this to their continuous integration pipelines. If your unit tests fail, or if your linter flags style issues, the system blocks the merge. This removes the human element of catching syntax errors during review, freeing up senior engineers to focus on architecture and logic, which are the real sources of complexity. Luna: That makes sense. You’re offloading the mechanical validation to machines so humans can handle the strategic decisions. Lucas: Yes. But there’s another layer to this that’s often overlooked: the psychological safety of admitting when you’re stuck. In many organizations, a blocked PR is seen as a sign of incompetence. GitHub tried to flip that narrative by encouraging 'pair programming' styles within the code review interface itself. Luna: Pair programming through a pull request? How does that look visually? Lucas: It looks like real-time commenting threads that are treated as collaborative spaces rather than critique zones. They highlighted examples where authors and reviewers co-authored commits directly in the discussion. This turns the merge conflict from a solitary headache into a shared problem-solving session. Luna: That’s interesting because it treats the code history as a conversation log rather than just a set of instructions for the machine. Lucas: Exactly. And this approach significantly reduced the 'context switching tax.' When a developer has to stop working on Feature A to fix a conflict caused by Feature B, they lose mental momentum. By keeping branches short and merges frequent, GitHub minimized the time engineers spent in that high-friction state. Luna: Did they see a measurable drop in actual conflict rates, or was it mostly about faster resolution times? Lucas: Both. They reported a forty percent reduction in the frequency of complex merge conflicts across their largest enterprise customers. But more importantly, the median time from 'first commit' to 'merged' dropped by thirty percent. Speed matters, but predictability matters more for planning. Luna: Predictability. So managers can trust that a feature will land by Friday because the integration path is clear. Lucas: Yes. And this reliability allows for better release cycles. When you know your integration pipeline is robust, you don’t need to buffer releases with extra days for 'stabilization.' You can ship more often with less risk. Luna: It reminds me of the concept of trunk-based development. Are they essentially pushing everyone toward a single main branch? Lucas: They didn’t mandate trunk-based development, but they made it the path of least resistance. By making long-lived branches painful due to escalating conflict risks, they naturally steered teams toward shorter-lived branches that merged daily. It’s incentive-aligned design. Luna: Incentive-aligned. That’s a great way to put it. Most companies try to enforce process; GitHub changed the incentives so the process enforced itself. Lucas: Right. And for any CTO listening, the takeaway isn’t necessarily to copy GitHub’s exact UI. It’s to audit your own team’s friction points. Where are developers losing time? Is it waiting for approvals? Is it debugging environment issues? Or is it, as in this case, fighting with version control? Luna: It’s funny how we treat git as just a utility, but it’s actually the backbone of our social and technical coordination. Lucas: It is. And when that backbone is rigid, the whole body hurts. Softening it through better tooling and clearer norms pays dividends everywhere else in the organization. Luna: So, if I’m a manager looking at my team’s burnout, maybe I should start by looking at their average pull request age. Lucas: Start there. If your PRs are sitting open for more than two days, you have a process problem, not a talent problem. Fix the flow, and the talent will flourish. Luna: I think that’s a solid metric to track. Age of PRs, frequency of merges, and yes, conflict resolution time. Lucas: And don’t forget the qualitative side. Talk to your engineers. Ask them what part of the build-and-deploy cycle makes them want to scream. Usually, it’s something mundane like dependency hell or merge conflicts. Luna: Agreed. Removing those mundane frictions is one of the highest-leverage things a tech leader can do. Lucas: It really is. Because once you remove the noise, you can finally hear the signal—the actual innovation happening in the code. Luna: So, next quarter, instead of focusing solely on new features, maybe we look at streamlining the plumbing first. Lucas: Or at least ensuring the plumbing doesn’t leak all over our developers’ weekends. What do you think is the biggest hidden cost in your current workflow? Luna: For me, it’s probably the context switching between different environments. Dev, staging, prod—they all feel slightly different. Lucas: Environment parity is the other half of this coin. But that’s a story for another day. For now, let’s just keep those branches short and those comments constructive.