The Senior Janitor: Escaping the AI Code Review Trap

There is a growing chatter on social media, from LinkedIn to private engineering Discords, that paints a worrying picture of the software industry in late 2025. Senior engineers are burnt out. But they aren't burnt out from crunching on difficult architectural problems. They are burnt out from being "janitors."

They are drowning in a flood of technically correct but architecturally disastrous code generated by AI-assisted workflows.

The promise of AI was to give every engineer a "senior pair programmer." The reality, often, is that it has given every engineer an enthusiastic intern: one who types at 1000 words per minute, knows every library in existence, but has zero restraint and limited understanding of why we don't rewrite the entire authentication layer just to fix a typo.

The Velocity Trap

In the past, the friction of typing acted as a natural filter. If you had a bad idea, you usually realized it halfway through typing the boilerplate. The effort cost gave you time to think.

AI removes this friction. It lowers the cost of generating code to near zero. However, the cost of reading, understanding, and maintaining code has not changed. This creates a massive imbalance of effort:

Generation is instant. Verification is expensive.

The results of this asymmetry are already appearing in 2025 data. According to GitLab’s Global DevSecOps Report, organisations are losing an average of seven hours per team member weekly due to AI-related inefficiencies. This phenomenon is known as the AI Paradox (GitLab, 2025). Furthermore, research by Metr.org (2025) found that experienced developers often take 19% longer to complete tasks with AI assistance despite the perception of increased speed.

We are seeing Pull Requests (PRs) balloon in size. What used to be a focused, atomic change is now a sprawling refactor because the AI "suggested it." The senior engineer, tasked with reviewing this, is forced into the role of a cleaner: sweeping up the mess left by a high-velocity, low-judgment process.

The "Solo Code Factory"

Perhaps more concerning is the cultural shift. AI is turning engineers into solo code factories.

Instead of discussing a problem with a teammate, engineers are pair-programming with their private Large Language Model (LLM) context. We are losing the collective intelligence of the team. We are bypassing the peer review and collaboration that turns distinct lines of code into reliable software. We are getting code that works for the individual but degrades the system for the group.

Restoring Rigor: Standards of Practice for the AI Era

The solution is not to ban AI. That would be like banning compilers. The solution is to recognize that velocity without direction is dangerous. Therefore, AI requires more rigor, not less.

When you have an engine that can go 200mph, you don't remove the brakes; you upgrade them. We need to re-assert the fundamental practices of software engineering, not as "nice-to-haves," but as "survival mechanisms."

1. Architecture Before Action (The ADR)

You cannot "prompt" your way to a solid architecture. If you don't have an Agreed Decision Record (ADR) before you open the Integrated Development Environment (IDE), the AI will hallucinate a structure for you.

AI can be given your domain rules, but it cannot reason about trade-offs the way a human can. It optimizes for "getting it working." The Engineer must provide the Intent.

• The Rule: No code generation starts without a clear, written plan. The Senior reviews the Plan (ADR), not just the Code.

2. Constraints as the Contract

In many engineering cultures, Test-Driven Development (TDD) served as the primary contract: a way to define behaviour before writing code. In the AI era, this concept must evolve into a broader system of structural constraints.

• The Workflow: The Human defines the Spec (Interfaces, Zod Schemas, API contracts) before requesting the implementation.
• The Benefit: This shifts the "contract" from human-written tests to machine-enforced types. If the AI deviates from the schema, the compiler or linter rejects the code before it ever reaches a human reviewer.

3. Context Management (The Context Architect)

A major failure mode is assuming the AI knows "how we do things here." It doesn't.

• The Skill: Engineers must evolve from simply prompting for code to becoming context architects. We must design the system of constraints by feeding the AI our "Project DNA," strict linting rules, and atomic commit philosophy.
• The Restraint: We must teach Juniors (and Seniors!) to reject the AI's suggestion if it violates these norms. Just because the AI generated 50 lines of boilerplate doesn't mean you should commit them.

The "AI Auditor" Illusion

To combat this flood, the industry has turned to AI auditors: systems that review code automatically. While impressive, relying on them blindly introduces a dangerous compounding effect. These agents typically operate in three layers:

1. Deterministic Layer: Running linters and static analysis to catch syntax errors.
2. Contextual Layer: Using RAG to fetch related files, though limited by context window boundaries.
3. Reasoning Layer: Using an LLM to judge logical correctness.

The failure occurs at the reasoning layer. These tools suffer from contextual blindness: they can verify internal consistency but cannot see global business rules or implicit system dependencies. We are trying to solve probabilistic noise with probabilistic filtering. This creates a trust gap where 46% of developers report they do not trust AI output (Stack Overflow, 2025), leading to a paradox where we are manually reviewing the reviewer.

AI models operate on pattern matching, not reasoning. They produce code without reason. If we rely on AI Auditors to check this, we break the chain of reasoning entirely. We get a system that works by accident, not by design, adding yet another layer where we lose Reasoning Integrity.

Breaking the Solo Code Factory

The greatest risk of AI is not bad code; it is the erosion of collective intelligence and Reasoning Integrity. Because AI makes it trivial to move from "Idea" to "Pull Request" in minutes, engineers are increasingly bypassing the social friction that defines healthy teams.

To restore integrity, we must introduce intentional friction into the workflow:

• Socialize the Contract: An Architecture Decision Record or simple Schema becomes the centerpiece of a team discussion before a single line of code is generated. This discussion defines the shape that the AI must fill.
• Leverage Discovery, Reject Judgment: Use AI tools to catch syntax errors and fetch context, but explicitly reject their "Reasoning." The machine finds the dots; the human connects them.
• The AI as Adversary: Instead of asking the AI to "approve" the code, ask it to find flaws in the design. Use the agent to stress-test the contract before implementation begins.

We are back where we started: the human is the bottleneck. Until AI demonstrates true Reasoning Integrity, the only way to scale velocity is to scale understanding.

Conclusion: Rigor is Reliability

We are moving into an era where writing code is the least valuable part of a Software Engineer's job. The value has shifted entirely to judgement and reasoning integrity.

• Judgement: Knowing what to build and why.
• Planning: Defining the architecture (ADRs) and the constraints (Contracts/Schemas).
• Rejection: Knowing when to block high-velocity noise to protect system coherence.

In a high-velocity AI environment, rigor is the only path to reliability. We don't slow down to follow rules; we follow rules so the system never has to stop. Velocity cannot be sustained without reasoning integrity. Until AI tools can reliably demonstrate that integrity, we must throttle the speed to match the human capacity for reasoning.

AI is a powerful engine. But an engine without a steering wheel is just a crash waiting to happen. By restoring engineering rigor, we ensure that the speed of AI leads to durable outcomes, not just faster failures.

References

Brooks, F. P., Jr. (1995). The Mythical Man-Month: Essays on Software Engineering (Anniversary ed.). Addison-Wesley.

CodeRabbit. (2025, November 12). State of AI vs Human Code Generation. CodeRabbit Engineering Blog. https://coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report

GitLab. (2025). GitLab Survey Reveals the "AI Paradox," Faster Coding Creates New Bottlenecks Requiring Platform Solutions. GitLab Press Release. https://ir.gitlab.com/news/news-details/2025/GitLab-Survey-Reveals-the-AI-Paradox-Faster-Coding-Creates-New-Bottlenecks-Requiring-Platform-Solutions/default.aspx

Metr.org. (2025, July 10). Experienced open-source developers took 19% longer to complete tasks with AI assistance. METR Blog. https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/

Stack Overflow. (2025, July). Stack Overflow’s 2025 Developer Survey Reveals Trust in AI at an All-Time Low. Stack Overflow Press Release. https://stackoverflow.co/company/press/archive/stack-overflow-2025-developer-survey/