Best of Code Review — November 2025

  1. 1
    Article
    Avatar of zaidesantonManager.dev·26w

    Shadow work in engineering teams

    Engineering teams lose significant capacity to undocumented work that never appears in sprint planning. Three major categories drain productivity: invisible production support (ad-hoc fixes, alert investigations, support questions), technical glue work (code reviews, mentoring, documentation), and shadow backlogs (off-roadmap requests and technical debt work). This hidden work causes burnout in senior engineers, breaks capacity planning, creates strategic bottlenecks, and erodes trust between business and engineering. Solutions include making work tracking painless, distributing glue work across the team through mentorship, and formally incorporating shadow backlog items into planning rather than treating them as unofficial work.

  2. 2
    Article
    Avatar of javarevisitedJavarevisited·26w

    Don’t Ignore Thread Safety — Design for Concurrency from Day One

    Concurrency bugs are non-deterministic, hard to reproduce, and often emerge only under production load, making them far more dangerous than typical logic errors. Building thread-safe systems from the start requires adopting design principles like immutability, avoiding shared state, using concurrency-safe primitives, and reviewing code with concurrency in mind. AI-powered code review tools can automatically detect unsafe shared variables, missing synchronization, potential deadlocks, and race conditions during pull requests, catching issues before they reach production. As modern applications become increasingly distributed and parallel, treating concurrency as a baseline engineering skill rather than an afterthought is essential for building scalable, maintainable systems.

  3. 3
    Article
    Avatar of lobstersLobsters·27w

    AI's 70% Problem — Zed's Blog

    Addy Osmani from Google's Chrome team discusses the "70% problem" in AI coding: while AI tools can rapidly generate 70% of a solution, the remaining 30% involving edge cases, security, and production integration remains as challenging as ever. Despite over 30% of Google's code being AI-generated, trust in AI-generated code has declined from 70% to 60% in two years. The talk covers common pitfalls like the "two steps back" pattern where AI fixes create new problems, the reality that productivity gains are modest (1-2x) compared to hype, and code review becoming a new bottleneck. Osmani emphasizes that developers must understand and take responsibility for AI-generated code, especially junior developers who should use AI as a learning aid while maintaining curiosity.

  4. 4
    Article
    Avatar of github_updatesGitHub Changelog·26w

    Pull request "Files changed" public preview

    GitHub's new Files changed page now includes an Overview button that displays pull request descriptions inline, eliminating the need to switch tabs or scroll. The update also includes performance improvements for faster navigation, with more optimizations planned for the coming weeks. The feature is currently in public preview.

  5. 5
    Article
    Avatar of yegor256Yegor's Blog·27w

    Help Me, My PR Doesn't Merge!

    When a pull request fails to merge, adopt strategic approaches: fail fast and close it quickly if fundamental issues arise, split changes into smaller mergeable pieces, document bugs in the existing codebase separately from your PR, recognize when to move on to easier tasks, and avoid asking for help to maintain professional credibility. Failed PRs are learning opportunities, not setbacks.

  6. 6
    Video
    Avatar of continuousdeliveryContinuous Delivery·28w

    This Company Tripled Developer Speed By Adopting THIS Practice

    A well-known web company reduced average feature development time from 151 hours to 44 hours by adopting pair programming, while simultaneously decreasing production bugs and eliminating code review bottlenecks. The experiment, initially met with skepticism about productivity concerns, proved that two developers working together could deliver features faster and with higher quality than solo developers going through traditional pull request workflows. The company analyzed over 5,000 pull requests and found that larger code changes received fewer meaningful review comments, mirroring research showing code review effectiveness diminishes with change size.

  7. 7
    Article
    Avatar of systemdesignnewsSystem Design Newsletter·26w

    I Studied How Top 0.1% Engineering Teams Do Code Reviews

    A comprehensive guide presenting 42 best practices for effective code reviews, covering key areas like keeping pull requests small, automating routine checks, maintaining clear communication, using review metrics to identify bottlenecks, and fostering a collaborative team culture. The guide emphasizes balancing speed with quality, focusing on correctness over style preferences, and treating reviews as learning opportunities rather than criticism sessions.

  8. 8
    Article
    Avatar of swizecswizec.com·27w

    AI fills my day with busywork

    AI coding assistants create a paradox where developers feel busier despite increased output. Each completed task generates more ideas and work, similar to nucleation in physics. The workflow involves constant context switching between AI-generated tasks, code reviews, and prioritization decisions. While AI handles drudgery like task creation from Slack threads, it encourages parallel work that reduces actual productivity by 20% despite feeling more productive. The result is more busywork, decision overhead, and stress rather than saved time.

  9. 9
    Article
    Avatar of newstackThe New Stack·25w

    Is AI Creating a New Code Review Bottleneck for Senior Engineers?

    AI coding tools can rapidly generate scaffolding and basic patterns, but often leave developers struggling with the remaining 70% of work—integration, security, edge cases, and debugging. Google's Addy Osmani discusses how AI-generated code creates a code review bottleneck for senior engineers, as trust in AI output declines despite rising adoption. He recommends understanding generated code thoroughly, investing in context engineering, maintaining strong test coverage, and using AI as a learning tool rather than a crutch. Real productivity gains appear to be less than 2x, with greenfield projects seeing better results than legacy codebases with technical debt.

See all Code Review archives