Use Jev Review for Continuous AI-Assisted Code Quality Evaluation

What Is Jev Review?

Jev Review is a local Model Context Protocol server that gives AI coding agents structured software-quality signals while they work. It supports Claude Code, Codex, Cursor, and OpenCode and exposes one focused MCP tool named jev_review.

The tool evaluates code across independent dimensions such as correctness, complexity, readability, modularity, test quality, reliability, security, and maintainability. It returns numeric scores, confidence values, applicability indicators, and predefined rubric hints rather than a prose code-review essay.

Jev supplies the quality signal, but your primary coding agent remains responsible for diagnosing weaknesses, changing the code, and validating the result.

Jev Review runs as a local Node.js process over MCP stdio. It has no hosted backend, database, telemetry service, or author-operated proxy. Requests containing explicitly supplied review context are sent directly to the configured Jev API.

Key Features

• Continuous evaluation: Review a change after each coherent implementation slice instead of waiting until the end of a task.
• Independent quality dimensions: Each applicable metric receives its own score from 1 to 10 and a confidence value from 0 to 1.
• Iteration comparisons: Supply a previous evaluation to identify improvements, regressions, and unresolved weaknesses.
• Focused context: Submit a task, diff, selected files, repository context, or an appropriate combination of them.
• Local execution: Every supported client launches the same bundled dist/server.js process over stdio.
• No automatic repository access: The server only processes context explicitly passed to the tool.
• No artificial overall score: Jev Review preserves dimension-level results instead of blending them into a potentially misleading percentage.

Prerequisites

Before installing Jev Review, make sure you have:

• Node.js 20 or newer.
• A Jev API key from the TypeSafe console.
• Claude Code, Codex, Cursor, or OpenCode.

Quick Installation

1. Export the API key

Set the key in the environment before launching your coding client:

export JEV_API_KEY="your-key"

Do not place the real key in prompts, source files, diffs, or committed configuration.

2. Install the plugin from GitHub

Jev Review is distributed directly from its GitHub repository rather than through an npm publication:

npx plugins add NiazMorshed2007/jev-review

Select your coding client when prompted, restart the client, and verify that the MCP server is connected.

3. Request a review

After implementing and testing a nontrivial change, ask the coding agent to use Jev Review. For example:

Implement the requested authentication change, run the relevant tests, and use jev-review on the focused diff. Inspect the weakest important dimensions, make only justified improvements, and rescore before the final handoff.

Client-Specific Setup

Claude Code

Install the Claude Code target explicitly:

npx plugins add NiazMorshed2007/jev-review --target claude-code

Restart Claude Code and run /mcp to confirm that jev-review is connected.

For manual MCP-only configuration, point Claude Code at the bundled server:

claude mcp add --scope user jev-review -- node /absolute/path/to/jev-review/dist/server.js

When developing from a local clone, you can load the plugin directory directly:

claude --plugin-dir /absolute/path/to/jev-review

Codex

Install the Codex target and restart the client:

npx plugins add NiazMorshed2007/jev-review --target codex

Run /mcp to verify the connection. For manual configuration, add the following server definition to ~/.codex/config.toml:

[mcp_servers.jev-review]
command = "node"
args = ["/absolute/path/to/jev-review/dist/server.js"]
env_vars = ["JEV_API_KEY"]

Cursor

Install the Cursor target:

npx plugins add NiazMorshed2007/jev-review --target cursor

Restart Cursor and check Settings → MCP. The bundled skill is named jev-review. You can invoke it with /jev-review or leave it on Agent Decides.

For a manual setup, create or update ~/.cursor/mcp.json:

{
  "mcpServers": {
    "jev-review": {
      "type": "stdio",
      "command": "node",
      "args": ["/absolute/path/to/jev-review/dist/server.js"],
      "env": {
        "JEV_API_KEY": "${env:JEV_API_KEY}"
      }
    }
  }
}

On macOS, Cursor launched from the Dock might not inherit variables from your shell profile. Make the exported key available to GUI applications before starting Cursor:

launchctl setenv JEV_API_KEY "$JEV_API_KEY"

Verify that the variable exists without printing its value:

test -n "$(launchctl getenv JEV_API_KEY)" && echo "JEV_API_KEY is configured"

OpenCode

OpenCode is not currently listed as a portable installer target. Clone the repository and register the bundled server manually:

git clone https://github.com/NiazMorshed2007/jev-review.git
cd jev-review
opencode mcp add jev-review --global -- node "$PWD/dist/server.js"

For both the skill and MCP server, add a configuration like this to ~/.config/opencode/opencode.json, replacing the absolute paths:

{
  "$schema": "https://opencode.ai/config.json",
  "skills": ["/absolute/path/to/jev-review/skills"],
  "mcp": {
    "servers": {
      "jev-review": {
        "type": "local",
        "command": ["node", "/absolute/path/to/jev-review/dist/server.js"],
        "environment": {
          "JEV_API_KEY": "{env:JEV_API_KEY}"
        }
      }
    }
  }
}

Run opencode mcp list to verify the connection. OpenCode may display the tool as jev-review_jev_review, although its underlying MCP name remains jev_review.

Understanding the Tool Input

The jev_review tool accepts the following structure:

{
  task?: string;
  diff?: string;
  files?: Array<{
    path: string;
    content: string;
  }>;
  repositoryContext?: string;
  previousEvaluation?: Evaluation;
}

At least one current-context field is required. In most cases, send the task and a focused diff. Add complete files only when surrounding implementation details are necessary to understand the change.

A conceptual request might contain:

{
  "task": "Add input validation to the account creation endpoint",
  "diff": "<focused version-control diff>",
  "repositoryContext": "Node.js service using the repository's existing validation conventions"
}

This example illustrates the input shape; the coding client normally invokes the MCP tool on your behalf.

Recommended Evaluation Workflow

1. Understand the task. Inspect the repository, requirements, conventions, and relevant tests.
2. Implement a coherent slice. Complete a meaningful portion of the change rather than reviewing every minor edit.
3. Run relevant checks. Validate behavior before asking a score to guide further work.
4. Establish a baseline. Call jev_review with the task and focused diff.
5. Investigate weak dimensions. Have the coding agent inspect the implementation and form a concrete hypothesis about each important weakness.
6. Make the smallest justified improvement. Avoid speculative rewrites or unnecessary architecture.
7. Validate again. Rerun tests, type checks, linters, or other appropriate project checks.
8. Rescore with history. Pass the prior result as previousEvaluation to obtain per-metric comparisons.
9. Stop at the right time. Finish when requirements and checks pass and further score-seeking would add little practical value.

For example, the comparison may show a readability change such as 6.3 → 8.1 while security remains 8.2 → 8.2. This is more informative than a single blended score because it shows exactly which quality dimensions changed.

Quality Dimensions

Core dimensions

When the supplied context is sufficient, Jev Review evaluates:

• Correctness and requirement fit.
• Cognitive complexity.
• Readability and intent.
• Modularity and cohesion.
• Coupling and dependency quality.
• Changeability and change amplification.
• Abstraction and API design.
• Project and file structure.
• Duplication and reuse.
• Maintainability.
• Testability and test quality.
• Reliability and error handling.
• Security.
• Consistency and conventions.
• Documentation and explainability.

Context-dependent dimensions

The following dimensions are evaluated only when relevant evidence is available:

• Performance and resource efficiency.
• Scalability and flexibility.
• Compatibility and API stability.
• Observability and operability.

If the supplied context cannot support a dimension, the result uses { "applicable": false }. The evaluator does not assume that shorter functions, smaller files, additional layers, more comments, zero duplication, or more tests are automatically better.

Advanced Tips

Keep review context focused

Send the task and the smallest coherent diff that captures the implementation. Include full files only when omitted context would prevent a reliable evaluation. Focused submissions make the feedback easier for the coding agent to interpret.

Jev Review does not add its own character, token, or file-count limit. However, live behavior of the jev-latest API indicates a submitted-state ceiling of roughly 32,768 tokens. This limit is not published in the API documentation and may change. If the API returns max_tokens_exceeded, remove unrelated context or split the work into coherent review slices.

Use previous evaluations for controlled iteration

Pass the complete previous result in previousEvaluation when rescoring. Jev Review compares it locally and reports per-metric deltas, improvements, regressions, and unresolved weaknesses. The previous evaluation is not included in the current code context sent to Jev.

Diagnose before editing

A low score is a signal, not a root-cause explanation. Ask the coding agent to inspect the implementation, identify evidence for the weakness, and propose a minimal correction. Do not rewrite code merely to move a number.

Prioritize requirements over scores

Correct behavior and user requirements always outrank score improvement. A higher score does not justify breaking behavior, expanding scope, adding meaningless tests, introducing speculative abstractions, or creating unnecessary layers.

Use dedicated security tools too

Security is one evaluation dimension, but Jev Review complements rather than replaces dependency scanners, secret detection, static analysis, penetration testing, and other dedicated security controls.

Security and Privacy

The local MCP process reads JEV_API_KEY and uses it only in the TLS Authorization header sent directly to https://api.typesafe.ai/v1/systemone. Jev Review does not store or log the key.

Only the task, diff, files, and repositoryContext explicitly supplied to the tool are sent to Jev. The server does not discover or upload repository files automatically.

Review context leaves your machine for TypeSafe's Jev API. Do not submit secrets or unrelated proprietary material.

Consult TypeSafe's privacy policy for information about how the remote service handles submitted data.

Developing Jev Review Locally

To work on the project itself, clone the repository, install dependencies, and run validation:

git clone https://github.com/NiazMorshed2007/jev-review.git
cd jev-review
npm install
npm run validate

Useful development commands include:

npm run check
npm test
npm run build
npx plugins discover .
claude plugin validate . --strict

npm run build creates the committed dist/server.js bundle. Unit and MCP protocol tests use local fakes and do not consume Jev API quota. A live Jev request requires JEV_API_KEY.

Conclusion

Jev Review adds a disciplined quality-feedback loop to supported AI coding clients without taking control of implementation. Install the local MCP server, submit focused context after meaningful changes, use dimension-level results to guide careful improvements, and compare evaluations across iterations. Treat the scores as evidence rather than goals, and stop when the requirements, checks, and practical quality needs are satisfied.