The AI revolution has created a pair of crises within the software industry:
- Code review has become the new bottleneck, one that AI fundamentally cannot fully automate or replace.
- Engineers are abdicating their understanding of and judgment over the systems they are building.
The two terms in this title play key roles in the analysis of these problems, and a nuanced understanding of both is pivotal to resolving them.
The software industry has already accepted "cognitive surrender": the idea that we solve problems using tools that we either don't fully understand or to which we have delegated decision-making. Take circuitry and assembly code, for example. We claim that we use abstractions for these and that there is no need to deeply understand these concepts to solve real problems. And we are correct.
That is not to say there is no justified fear of abdicating judgment.
The direction of the solution, as with many of these AI challenges, lies not in augmenting existing processes and tools with AI, but rather in reimagining the solution with AI at the center—i.e., becoming AI-native.
Typical discussions around code review often result in ham-fisted takes, as "code review," as defined today, retains all of its traditional properties. Traditionally, code review serves several purposes: correctness, maintainability, security, architectural consistency, and knowledge sharing. AI challenges the assumption that humans must inspect implementation details to achieve all of these outcomes.
Is a deep comprehension of the implementation of software, line by line, necessary for the health of the system? (And did we really do this before AI?)
If we extrapolate the pattern of abstraction, then the answer is no. Software teams need to rethink what warrants review so that proper judgment and a correct understanding of the system are retained, and only to investigate the implementation when the evidence warrants it.
I expect the industry to embrace intent review. Reviewing requirements, architecture, and decisions provides control without requiring full implementation comprehension. We should invest in establishing confidence that software works as intended without needing to comprehend every line of its implementation.
Cognitive surrender in and of itself is not the crisis, its surrendering judgement at the wrong layer of abstraction.
Top comments (0)