Jev Code Reviewer — Staged AI Code Review Engine & Surgical Agent Handoff

01 — Context & Purpose

Modern development teams increasingly rely on Large Language Models (LLMs) to automate pull request reviews. However, off-the-shelf AI code review bots flood PRs with generic nitpicks, hallucinate non-existent issues, and dump entire repositories into the prompt context, burning excessive tokens without localizing actionable bugs.

Jev is an open-source, staged AI code review CLI and Model Context Protocol (MCP) server engineered specifically for modern React, TypeScript, and Next.js monorepos. Instead of sending an entire PR diff to an LLM in one monolithic prompt, Jev evaluates code changes through a multi-stage deterministic pipeline before selectively handing off verified issues to AI coding agents.

02 — Problem Analysis: Why Generic AI Reviewers Fail

03 — Architecture: The Staged Review Pipeline

Jev decouples review execution into four sequential phases, progressively filtering noise before invoking AI models:

[ Git Diff / Working Tree Changes ]
                 │
                 ▼
[ Stage 1: Deterministic Static Analysis & Diff Parsing ]
  ├── Hunk header line-number extraction
  ├── Non-code / lockfile filtering
  └── Dynamic context trigger evaluation
                 │
                 ▼
[ Stage 2: Dimension-Specific Preset Engine ]
  ├── State & Correctness Checks
  ├── React Architecture & Hook Dependency Invariants
  ├── Next.js Boundary & Hydration Guards
  ├── Performance & Render Cascades
  └── Test Coverage & Error Boundary Gaps
                 │
                 ▼
[ Stage 3: Severity Ranking & Deduplication ]
  ├── Confidence threshold filtering (0–3 scoring)
  └── Noise reduction & false-positive pruning
                 │
                 ▼
[ Stage 4: Surgical AI Agent Handoff via MCP ]
  ├── Streaming Model Context Protocol (MCP) tool server
  └── Compact surgical context export (85–90% token reduction)

04 — Specialized React & Next.js Evaluation Dimensions

Instead of subjective code style feedback, reviews evaluate pull requests across five concrete architectural dimensions:

05 — Dynamic Contextual Triggers

Deep-dive semantic checks consume LLM inference tokens. To maximize speed and minimize compute, specialized evaluations run only when their specific code patterns appear in the modified diff:

• Hooks & Closures Trigger: Activates when useEffect, useCallback, or custom hooks are modified.
• Server Boundary Trigger: Activates on route segments, middleware, or "use client" file boundaries.
• Data Mutation Trigger: Activates when React Query, SWR, or mutation hooks are changed.
• Form & Input Trigger: Evaluates accessibility feedback, ARIA attributes, and controlled input synchronization.
• Context & Store Trigger: Scans for re-render waterfalls when global store providers update.

06 — Surgical AI Agent Handoff via Model Context Protocol (MCP)

When an issue is confirmed, passing the full codebase to an AI repair agent wastes context and introduces regression risk. Jev incorporates a native Model Context Protocol (MCP) Architecture:

Streaming MCP Server

Exposes standard tools (review_changes, recheck_file) directly to AI coding agents (Google Antigravity, Cursor, Claude Code) with real-time streaming:

• Findings are emitted progressively as each review dimension completes.
• Agents begin remediation on the first category of verified issues while subsequent dimensions are still evaluating in the background.

Compact Surgical Context Exports

Jev emits structured handoff artifacts (JSON and Markdown) containing strictly:

1. The isolated suspicious code hunk.
2. The exact line coordinate and file path (e.g. Component.tsx:L42).
3. The underlying invariant violation and explicit remediation guidance.

This achieves an 85–90% token reduction compared to full-repository context injection.

07 — Extensible Preset Plugin System

The review engine decouples its core analysis pipeline from domain-specific rules. Presets load dynamically from a root configuration file (jev.config.ts):

import { defineConfig } from "jev";
import frontendPreset from "jev-preset-frontend";

export default defineConfig({
  preset: frontendPreset({
    strictHydration: true,
    reactCompiler: true,
  }),
  severityThreshold: "warning",
});

Teams can author and distribute custom domain presets (jev-preset-node, jev-preset-vue) targeting their internal architecture standards while leveraging Jev's static diff parser, hunk mapper, and MCP streaming engine.

08 — Verified Outcomes & Developer Velocity

• 85–90% Reduction in Agent Context Tokens: Surgical hunk handoffs allow AI coding assistants to repair code without ingesting entire repositories.
• 70% Drop in False-Positive PR Comments: Multi-stage filtering and dynamic contextual triggers eliminated generic stylistic noise.
• Zero SSR Hydration Regressions: Automated Next.js boundary checks caught client-only browser API calls before reaching staging environments.
• Sub-Second Streaming Feedback: Streaming MCP output delivers immediate actionable insights without waiting for full batch PR scans to complete.