A developer sits in a bustling startup office in Gangnam on a Wednesday afternoon. On the screen, Cursor, an AI-powered code editor, has just spat out several hundred lines of a complex React component in a matter of seconds. The code runs, the UI renders, and the feature appears to work. Yet, the developer remains skeptical, squinting at the screen while manually hunting for unnecessary re-renders or subtle memory leaks that the AI might have overlooked. This is the modern developer's paradox: AI has accelerated the speed of code generation, but the speed of human verification remains a bottleneck. The industry is now facing a critical gap where the volume of produced code is outstripping the capacity to audit it.

The Rust-Driven Engine for Quantitative Code Health

To bridge this gap, Million.co has released React Doctor, an open-source tool under the MIT license designed to transform subjective code reviews into quantitative data. The tool allows developers to scan their entire project with a single command in the terminal:

npx react-doctor@latest

Upon execution, React Doctor evaluates the codebase and produces a diagnostic score ranging from 0 to 100. This is not a generic linting result but a composite health metric derived from six critical categories: state management, side effects, performance, security, accessibility, and architecture. By converting code quality into a numerical value, the tool provides a standardized benchmark for the integrity of code generated by AI agents.

The performance of this analysis is driven by oxlint, a high-performance JavaScript linter written in Rust. React Doctor implements its logic via the `oxlint-plugin-react-doctor` plugin, which contains over 100 specialized rules. Unlike traditional static analysis tools like ESLint, which operate on a JavaScript runtime and often suffer from significant memory overhead and execution lag, React Doctor leverages Rust's memory efficiency and parallel processing capabilities. This architecture allows the tool to analyze massive codebases containing thousands of files with near-zero latency, enabling a tight feedback loop where developers can verify changes immediately after they are written.

Precision is further enhanced through framework-specific presets. Recognizing that a generic React rule might be irrelevant or misleading in a specialized environment, React Doctor provides dedicated rule sets for Next.js, TanStack, React Native, and Expo. This ensures that the tool respects the architectural nuances and best practices of each ecosystem, reducing false positives that typically plague general-purpose linters. While traditional ESLint plugins require developers to manually configure complex `.eslintrc` files and pick individual rules, React Doctor positions itself as an immediate audit tool that provides a comprehensive health check out of the box.

From Static Linting to AI Agent Checkpoints

While most linting tools are viewed as passive assistants that catch human errors, React Doctor shifts the paradigm by acting as an active control mechanism for AI agents. The goal is to move beyond human-led auditing and create a system where AI agents can self-correct their own output. By running the following command:

react-doctor install

Developers can automatically register analysis skills within AI agents such as Claude Code, Cursor, Codex, and OpenCode. This integration transforms the tool into a checkpoint in the AI workflow. When combined with git post-checkout and post-merge hooks, the system ensures that every single code change is validated before it ever reaches a human reviewer. This creates an automated pipeline where one AI agent generates the code and another AI agent, powered by React Doctor's rules, audits and refines it, drastically reducing the need for manual intervention.

This capability is particularly vital in the era of the React Compiler. In environments where the compiler is active, manual memoization—such as the overuse of `useMemo` and `useCallback`—can actually degrade performance rather than improve it. React Doctor is specifically tuned to detect these redundant optimizations, flagging code that was written for an older version of React and needs to be simplified for the compiler. To integrate this into professional workflows, the tool offers an official GitHub Action that provides inline annotations and sticky comments on Pull Requests. To keep CI pipelines lean, the `--diff` mode allows the tool to scan only the files that have changed, ensuring that quality gates do not become deployment bottlenecks. Results can be exported and shared via react.doctor/share, allowing teams to track their technical debt over time.

Under the hood, the analysis engine is built on a parallel pipeline using Effect v4, a functional programming library that emphasizes type safety. By utilizing dependency injection, tagged errors, and generator-based control flows, React Doctor manages complex analysis exceptions at the type level. This ensures that the tool remains stable even when encountering highly unconventional code structures. The engine simultaneously executes linting and dead-code analysis to maximize throughput. For those who need to integrate these diagnostics directly into their own Node.js applications, the `@react-doctor/api` package provides a programmatic interface:

import { diagnose } from '@react-doctor/api';

const result = await diagnose(projectPath);

The development velocity of the tool has been aggressive. Version v0.2.4 marked the completion of the Effect v4 migration, while v0.2.7 introduced parallel analysis and agent detection. The most recent v0.2.8 release continues to refine the stability of the AI-to-AI verification pipeline, ensuring that the tool can keep pace with the rapid evolution of LLM-generated code.

To implement this effectively, teams must move beyond simple installation and establish quantitative thresholds for their technical debt. A score of 80 should serve as a baseline; any module falling below this threshold should trigger a mandatory human review, restricting the AI agent's ability to merge code automatically. This creates a hybrid governance model where the AI handles the bulk of the labor, but the human developer defines the quality boundary. Furthermore, the use of framework presets is not optional for high-scale projects; applying a Next.js preset in a React Native project would lead to irrelevant warnings and friction. The strategic application of the `--diff` mode in CI and the registration of agent skills in local environments allow teams to balance the need for speed with the requirement for absolute stability.

Automated verification is not a replacement for the human eye, but a necessary filter that defines the boundaries of trust for AI-generated software.