Critic: Letting the AI Agent That Writes Code Review Its Own Code

A Counter-Intuitive Approach to Code Review

As AI coding tools rapidly proliferate, more and more code is being generated by AI Agents. This creates a new question: who reviews the code these AIs write? A Show HN project on Hacker News called Critic offers a controversial answer — let the same Agent that wrote the code review it.

This sounds a bit like having an athlete serve as their own referee, but there's a logic to it. The Agent that wrote the code has the most complete context: it knows what design trade-offs it made, why it chose a particular implementation, and which parts were temporary compromises. Compared to an external review tool that comes in cold and can only read a diff, the original Agent has a far deeper understanding of the intent behind the changes.

What Critic Is Trying to Solve

As AI-assisted programming scales up, manually reviewing AI-generated code line by line is becoming a bottleneck. Teams often face large chunks of AI-generated changes, where reviewers lack insight into how the code was generated and must assess quality and security under time pressure.

Critic aims to embed the "review" step directly into the Agent's workflow. Because the same Agent is both author and reviewer, it can immediately reflect on the code it just generated using its own reasoning chain: checking edge cases, verifying alignment with the original requirements, and surfacing potential logic bugs. In theory, this kind of "self-review" can catch some low-level errors and reduce the burden on human reviewers.

Potential Value and Obvious Limitations

On the positive side, having the author Agent participate in review does leverage its contextual advantage. It doesn't need to re-infer the intent of the code — it can quickly pinpoint "why I wrote it this way" and more easily identify deviations from the requirements.

But the limitations of this approach are equally clear. One of the core values of code review is precisely the introduction of an independent perspective — a reviewer brings different assumptions and blind spots than the author, which is how problems the author couldn't see get caught. If the author and reviewer are the same model running the same reasoning logic, then problems the model didn't consider during generation are likely to be missed during review as well. In other words, the model's own systematic biases cannot be eliminated by having it "review itself."

This is also where the key question lies when evaluating tools like Critic: is it meant to replace human review, or serve as a pre-filter? If it's the latter — acting like an automated self-checklist that weeds out obvious issues before handing off to a human or independent tool — that's a much more defensible position.

There's a relevant concept in cognitive science called Confirmation Bias: when people verify their own ideas, they tend to seek out supporting evidence rather than counterexamples. This bias has a parallel in large language models — when models evaluate their own outputs, they tend to defend rather than critically scrutinize them. Researchers call this "self-consistency bias." This means that even if an Agent is given the reviewer role by design, its reasoning still shares the same weights and inductive preferences as the generation phase. Systematic blind spots are hard to overcome just by switching "roles." This is why human review or independent model review remains considered irreplaceable in safety-critical scenarios.

An Industry Trend Worth Watching

Setting aside the fate of any individual product, Critic reflects a forming trend in AI programming: the review step itself is being AI-ified. As code generation becomes increasingly automated, the accompanying quality control tooling must keep pace — otherwise AI just shifts the bottleneck from writing to reviewing.

Two approaches are emerging in the market: one, like Critic, has the generating Agent self-review, prioritizing contextual coherence; the other deploys an independent review Agent, prioritizing independent perspective. Each involves trade-offs. The more mature solution in the future will likely combine both — the generating Agent handles self-review and initial filtering, while an independent Agent or human handles final sign-off.

It's worth noting that Critic currently has limited traction on Hacker News (5 upvotes, 1 comment) and is still at an early showcase stage. Its real-world effectiveness and adoption remain to be validated. For developers tracking the evolution of the AI programming toolchain, it offers a direction worth thinking about — not a mature solution.

In software engineering, static analysis tools (like SonarQube and Semgrep) and formal verification have long played the role of automated quality gatekeeping, but they target human-written code with manually maintained rule sets. The rise of AI-generated code introduces new challenges: the patterns and defect types in AI-generated code differ from human code. For example, AI is more prone to producing code that "looks reasonable but has subtle logic errors," rather than traditional syntax or style issues. This is pushing the industry to explore review strategies specifically tailored for AI-generated output. The self-review approach that Critic represents, alongside the independent Agent review approach, can be seen as two early experimental directions in that exploration.