In a recent LinkedIn post, 🌀 Luca Rossi delves into the contentious topic of code reviews, highlighting a persistent paradox: their undeniable utility versus their often-criticized inefficiency. Rossi frames the discussion by acknowledging the growing sentiment that code reviews are becoming a significant bottleneck in modern development workflows.
He opens by validating the frustrations many developers feel, stating:
I keep hearing that code reviews need to go: they are the new bottleneck, we can’t keep inspecting every line of code, and so on.
Rossi, who admits to having previously held critical views on the practice, elaborates on these perceived shortcomings. He suggests that code reviews are frequently superficial and less effective in practice than the industry often portrays them.
The Enduring Value in Imperfect Reviews
Despite these criticisms, 🌀 Luca Rossi argues that the core value proposition of code reviews remains difficult to replace. He points to specific, high-impact scenarios where reviews have proven invaluable, such as identifying flawed abstractions or subtle deviations from project specifications that might otherwise go unnoticed.
According to 🌀 Luca Rossi, even a process that feels largely unproductive can yield critical benefits:
A review might feel useless 95% of the time, but that final 5% really saves your ass.
This sentiment underscores a key challenge: the difficulty in discarding a practice that, while flawed, offers crucial safeguards against critical errors.
The Search for a New Abstraction Level
The core of Rossi’s analysis centers on the feeling of being at an impasse. The traditional approach to code reviews is no longer sustainable, yet abandoning them entirely seems untenable due to the potential for catastrophic errors. Rossi posits that the issue lies in a missing intermediary layer of abstraction.
He explains this disconnect:
So it feels we are stuck. We can’t really afford not to review code, but we can’t keep doing things the old way either. There’s like a missing level of abstraction: code feels too low now, while specs feel too high.
This gap between the granular detail of code and the high-level nature of specifications leaves a void that current review processes struggle to bridge effectively. The current methods, Rossi implies, are too focused on the low-level implementation details, failing to adequately connect back to the broader architectural or functional goals.
A Call for Innovation
Concluding his post, 🌀 Luca Rossi expresses uncertainty about the definitive solution to this dilemma. He highlights the need for a novel approach that can reconcile the efficiency demands of modern development with the essential quality assurance provided by code inspection.
While not offering a prescriptive answer, Rossi’s contribution lies in clearly articulating the problem and inviting further discussion. He ends with a hopeful note, suggesting that the path forward requires innovative thinking from the broader development community.
As 🌀 Luca Rossi puts it:
Not sure what the solution is — just hoping someone smarter than me will pick this up 😄
His post serves as a valuable commentary on a fundamental aspect of software development, prompting reflection on how to evolve practices to meet contemporary challenges.
📝 About This Content
This article is based on insights shared by 🌀 Luca Rossi on LinkedIn.
📅 Originally posted on March 18, 2026 | View original post on LinkedIn →