Bug Blindness

Dan Luu has built a career on saying the quiet part loud, and "Bug Blindness" is another masterclass in uncomfortable truths. The core insight—that repeated exposure to a codebase physically impairs your ability to see defects in it—cuts against every Agile ceremony, every "shift left" movement, and every manager who thinks adding more code review gates will fix quality. Luu's evidence-based approach here is the real kicker: this isn't anecdote, it's cognitive science applied to software development. The industry loves to pretend that process fixes human fallibility, but the data keeps saying otherwise. What makes this essay land so hard is that it explains a phenomenon every working developer has experienced but never had words for. You know that feeling when someone points out a bug in code you've reviewed ten times, and you can't believe you missed it? That's not stupidity—that's your pattern-matching hardware doing exactly what it evolved to do. The problem is that evolution didn't prepare us for systems with 50,000 lines of business logic and a naming convention that makes everything look the same. Luu's piece essentially argues that our tools and processes are fighting a losing battle against our own biology. The HN discussion adds another layer worth noting—the comments are full of people sharing their own "how did I miss that" war stories, which is both validating and depressing. The validation comes from knowing you're not alone; the depression comes from realizing the problem is systemic. No amount of pair programming, linting, or AI-assisted review fully solves this because the blindness isn't in the tools—it's in the operator. The best anyone can do is rotate perspectives, get fresh eyes on critical code, and accept that your own review is the least reliable filter in your pipeline. This connects to a broader theme Luu has hammered for years: the gap between how we talk about software engineering and how it actually works. We sell stakeholders on predictability, but the reality is that human cognition is the weakest link in every software supply chain. "Bug Blindness" is another data point in that ongoing argument, and it's a compelling one. The uncomfortable conclusion is that the most effective quality measures are the ones that force you to see your code as a stranger would—and those are exactly the measures most teams skip because they're awkward, slow, or humbling. Source: https://danluu.com/bug-blind/