jev-review
Open-source, MIT-licensed TypeScript code review that runs staged AI judgments over a Git diff or whole codebase and shows results in a local dashboard.
Jev Review is worth cloning if you want to see how far typed, staged model judgments carry a code review without one giant prompt — the orchestration-in-code approach is the actual product, and the layer-enforced architecture (verified by scripts/check-dependencies.ts) is the part you can study. It is not a service you can hand to a team: it is an alpha-era repository with five commits, no compiler-diagnostic or static-analyzer integration, and a hard TypeSafe API key dependency. Treat it as a reference implementation or a starting point rather than a turnkey reviewer, and compare it to hosted diff reviewers that ship polished integrations and guarantees.
Verified 7d ago · liveness 54/100 · cite: rightaichoice.com/tools/jev-review
- Developers who want a local, inspectable AI code-review workflow they can read end to end
- Engineers who prefer staged, typed model judgments over a single large diff prompt
- Teams already on Node.js 24+ and comfortable managing a TypeSafe API key
- Reviewers who want a codebase-wide scan alongside ordinary diff review
- Teams that need a hosted, managed review service with no local setup
- Groups that cannot add a TypeSafe API key or another external API dependency
- Users on Node.js versions below 24
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Jev Review if you need a hosted, multi-user review service with compiler-diagnostic or static-analyzer integration, or you cannot run Node.js 24+ alongside a TypeSafe API key.
The workflow will not run without a TYPESAFE_API_KEY, so every review carries the cost of the underlying TypeSafe API usage on top of the free MIT source.
There is nothing to buy — the whole workflow is MIT-licensed source with a single free plan, so the real budget line is the TypeSafe API key you supply. That makes it cheaper upfront than hosted AI review seats, but you pay per model call rather than per seat. Compare against hosted diff reviewers, which bundle integrations and guarantees into a subscription, and against free static analyzers, which cost nothing but do not reason about a diff.
In short
jev-review — Open-source, MIT-licensed TypeScript code review that runs staged AI judgments over a Git diff or whole codebase and shows results in a local dashboard. Best for Developers who want a local, inspectable AI code-review workflow they can read end to end, Engineers who prefer staged, typed model judgments over a single large diff prompt, Teams already on Node.js 24+ and comfortable managing a TypeSafe API key. Free to use.
Viability Score
How well maintained and how widely used is jev-review? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: September 2026
How we score →Key Features
- Staged code-review workflow with orchestration kept in TypeScript code
- Noul risk matrix feeding Choice and Score file profiles
- Choice evidence selection across concrete diff hunks or source regions
- Choice mechanism classification followed by Score severity scoring
- Conditional Choice reviewer routing driven by prior judgments
- Separate entry points for change review and complete-codebase scan
- Uses changed or related tests as context when judging test gaps
- Screens correctness, security, reliability, compatibility, and test coverage
- Structured hints, counterexamples, and explicit decision boundaries in prompts
- Thresholds and workflow policy applied in code, not in the model
- Local dashboard bound to 127.0.0.1 that never serves environment files
- Collapsible dashboard sections for large reports
- CLI output as JSON via review:changes and review:codebase
- Layer-enforced architecture checked by scripts/check-dependencies.ts
- npm run check typechecks, verifies dependency flow, and syntax-checks the dashboard client
About jev-review
Jev Review is a small code-review workflow built with TypeSafe Jev, licensed MIT and published on GitHub at devagrawal09/jev-review. Rather than pushing an entire diff into one prompt, it keeps orchestration in TypeScript and hands Jev a chain of bounded judgments: a Noul risk matrix feeds Choice and Score file profiles, then Choice evidence selection, Choice mechanism classification, Score severity, and conditional Choice reviewer routing. It exposes two entry points — review:changes for a current Git diff and review:codebase for a scan of every non-ignored source file under a scope — and both can save reports into a quiet local dashboard bound to 127.0.0.1:4317. The reviewer screens correctness, security, reliability, compatibility, and test coverage, selects concrete diff hunks or source regions before scoring impact, and uses changed or related tests as context when judging test gaps. Prompts carry structured hints, counterexamples, and explicit decision boundaries, while thresholds and workflow policy live in code so each model call stays narrow and inspectable. It targets developers and small teams who would rather clone a repository than buy a hosted AI review seat — people comfortable running Node.js 24+ tooling, supplying a TYPESAFE_API_KEY, and reading JSON from the CLI. Commands are plain npm scripts: review:changes, review:changes:save, review:codebase, review:codebase:save, dashboard, and check. The difference here is discipline, not breadth: the README states plainly that it does not yet integrate compiler diagnostics, static analyzers, repository indexing, or generated explanations, and that findings are review prompts rather than proof of a defect.
Behind the Verdict
The interesting thing about Jev Review is what it refuses to do. Most AI code-review tools collapse everything into a single prompt: paste the diff, ask the model for problems, render the answer. Jev Review instead splits the job into a staged pipeline, with a Noul risk matrix driving Choice and Score file profiles, then Choice evidence selection, Choice mechanism classification, Score severity, and conditional Choice reviewer routing. Each stage is a bounded judgment, and the policy that decides how those judgments combine lives in TypeScript code rather than in the model's instruction text. That design choice is why the repository is worth reading even if you never run it in anger. The supporting engineering is unusually tidy for a five-commit project. Everything sits under src/ in downward-only layers — cli and dashboard depend on review, review depends on adapters, adapters depend on domain — and scripts/check-dependencies.ts fails npm run check on any upward import, any import between cli and dashboard, or any cycle. The dashboard binds to 127.0.0.1 and, per the README, never serves environment files, and it collapses large reports into sections so a codebase-wide scan stays readable. Output is JSON from review:changes and review:codebase if you want to pipe it somewhere else. Where it falls short is scope, and the project says so itself. There is no compiler-diagnostic integration, no static analyzers, no repository indexing, no generated explanations. Findings are explicitly review prompts, not proof of a defect — you still decide what is real. The workflow needs Node.js 24+, Git, and a TYPESAFE_API_KEY, so it adds an external API dependency to your machine. Reports are local-only; there is no hosted or multi-user mode, which means no shared queue and no way to hand a review to a colleague who is not running the repo. The repository itself shows only about five commits, so expect the workflow to change under you. Fit-wise, this is a tool for a developer who already reads their own diffs and wants a structured second pass they can inspect line by line, or for an engineer studying how to compose typed model judgments into a pipeline. It is not for a team that wants a managed review service with integrations and support, and it is not a replacement for tests, a compiler, or a security scanner. Clone it, read src/review, and judge whether the pattern earns a place next to the tools you already trust.
Researching jev-review? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas jev-review actually fits — and what changes day-one when you adopt it.
You finish a branch and want a second pass before merging. You add TYPESAFE_API_KEY to .env, run npm run review:changes:save -- /path/to/repo, then npm run dashboard and open http://127.0.0.1:4317 to read the risk, severity, and mechanism classifications for the diff.
Outcome: A structured review of the change sits in a local dashboard you can read section by section, with the model's judgments separated from the policy that ranked them.
You have cloned a codebase you did not write. You run npm run review:codebase:save -- /path/to/package to scan every non-ignored source file under that scope, then read the collapsible dashboard sections for the highest-severity findings.
Outcome: A prioritized map of risky files and regions, generated without a static-analyzer install and with each finding framed as a review prompt to verify by hand.
You run npm run check to confirm the layer rules hold, read src/review and the *-judgments files to see how the staged pipeline is wired, then run review:changes on a recent pull request to compare its output against the reviewer you use today.
Outcome: A concrete read on whether orchestration-in-code is worth adopting, and a working example you can fork rather than a vendor evaluation cycle.
Use Cases
- Review a current Git diff for correctness, security, reliability, compatibility, and test coverage.
- Scan every non-ignored source file under a scope with the complete-codebase entry point.
- Use changed or related tests as context when judging whether a change leaves test gaps.
- Inspect structured risk, severity, and mechanism classifications in the local dashboard.
- Route changes to different reviewer logic based on prior conditional judgments.
- Pipe review output as JSON from review:changes or review:codebase into another tool.
- Run reviews locally with a dashboard bound to 127.0.0.1 that never serves env files.
- Enforce layer boundaries in a fork via scripts/check-dependencies.ts and npm run check.
Limitations
- The project needs a TypeSafe API key and Node.js 24+, so it is not usable out of the box without that external API dependency.
- It is early-stage — only about five commits are visible on the repository — and the workflow, commands, and report shapes can change under you.
- The dashboard is deliberately minimal and local-only, bound to 127.0.0.1, so there is no hosted or multi-user mode and no shared review queue.
- The README states plainly that it does not yet integrate compiler diagnostics, static analyzers, repository indexing, or generated explanations, and that findings are review prompts rather than proof of a defect.
- No specific model, rate limit, or context-window figures are stated in the scraped evidence.
- If you need polished integrations and guarantees, hosted diff reviewers cover that ground.
as of 2026-09-22
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published jev-review tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open source (MIT)
Free
Ideal for
Developers and small teams who want a local, inspectable review pipeline they can read and fork, and who already run Node.js 24+ and can supply a TypeSafe API key.
What this tier adds
Starting tier and the only tier: MIT-licensed source covering both review:changes and review:codebase, report saving, the 127.0.0.1:4317 dashboard, and npm run check.
Where the pricing makes sense
The company stage and team size where jev-review's pricing actually pencils out — and where peers do it cheaper.
There is nothing to buy — the whole workflow is MIT-licensed source with a single free plan, so the real budget line is the TypeSafe API key you supply. That makes it cheaper upfront than hosted AI review seats, but you pay per model call rather than per seat. Compare against hosted diff reviewers, which bundle integrations and guarantees into a subscription, and against free static analyzers, which cost nothing but do not reason about a diff.
Setup time & first value
How long it actually takes to get something useful out of jev-review — broken out by persona, not the marketing-page minute.
If Node.js 24+ and Git are already installed, first value is roughly five minutes: npm install, copy .env.example to .env, paste a TYPESAFE_API_KEY, then run npm run review:changes:save and npm run dashboard. Add ten to thirty minutes if you need to install or upgrade Node.js first. Reading src/review to understand the staged judgments is a longer evening, not a setup step.
Switching to or from jev-review
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From a single-prompt diff review script: replace the one large prompt with the staged review:changes entry point and keep your own wrapper only around the JSON output.
- →From a hosted diff reviewer: run review:changes:save on a recent pull request, compare the risk and severity output side by side, then decide whether the local workflow covers enough of your cases.
- →From reviewing without tooling: start with review:changes (print to JSON) before wiring the dashboard, so you can judge the findings without a UI.
- ↗To a hosted diff reviewer: export the JSON from review:changes or review:codebase and map its risk and severity fields onto the hosted tool's comment format.
- ↗To a static analyzer: route the file and region paths surfaced by the Noul risk matrix into your analyzer of choice as a prioritized worklist.
- ↗To your own pipeline: keep src/domain patch parsing and diff handling, drop the Jev judgment stages, and call the model you already pay for.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “jev-review”, and we withheld 6: 6 did not mention jev-review. We are showing none, because we could not prove any of them are about jev-review.
Official links
Tools that pair well with jev-review
Common stack mates teams adopt alongside jev-review, with the specific reason each pairing earns its keep.
Mira
Mira is a self-hosted, open-source AI code reviewer that indexes your whole repo and reviews pull requests with any LLM you choose.
Ai Review
Open-source AI code review that runs inside your CI/CD pipeline and sends code straight to your chosen LLM provider.
MarsX
Open-source dev platform uniting AI, NoCode, Code, and reusable MicroApps.
Featured Head-to-Head Comparisons
Jev Review vs Poolside Ai
These are not competitors, so there is no honest head-to-head pick. Jev Review is a free, MIT-licensed TypeScript code-review workflow you run yourself: it stages typed model judgments over your Git diff or whole codebase and writes them to a dashboard on 127.0.0.1:4317. Poolside AI is an enterprise vendor selling open-weight Laguna models and agentic orchestration for regulated, often air-gapped environments — no published price, no self-serve signup. If you are a solo developer wanting a review pass tonight, Jev Review is the only one you can actually adopt; if you are a bank or defense contractor that cannot send code to a third-party cloud, none of Jev Review's model-calling architecture will satisfy procurement.
Jev Review vs Roo Code
If you need an AI code reviewer today, Jev Review is the only one of these two you can actually run — it's free, open-source, and built around inspectable, staged judgments rather than one giant diff prompt. Pick it if your team is on Node.js 24+ and willing to manage a TypeSafe API key. Roo Code, by contrast, is a landing page: no demo, no extension, no published pricing. Only sign up if you enjoy evaluating unfinished software; otherwise wait until it ships.
Jev Review vs Cosine Genie
These are not the same purchase. Jev Review is a free, MIT-licensed TypeScript pipeline you run yourself — you inspect every staged judgment (Noul risk matrix, evidence selection, mechanism classification, severity scoring, conditional routing) and pay only in setup effort and a TypeSafe API key. Cosine Genie is a managed platform with a real price: trial credits, then $19/month entry, buying you the Lumen model family (Scout on-device, Outpost for production work, Sovereign coming soon), Swarm orchestration, MCP tool access, and air-gapped or single-tenant deployment. If your problem is 'review my diffs with something I can read and audit locally,' pick Jev Review. If your problem is 'maintain COBOL, Fortran, Verilog, Rust, or complex SQL on regulated infrastructure with a hosted agent and GitHub PR merging,' pick Cosine Genie — and budget for it.
Jev Review vs Headshotgenerator Io
These two are not competitors; there is no scenario where a buyer shortlists both. Jev Review is for a developer who wants a local, inspectable AI code-review pipeline they can read end to end and is willing to run Node.js 24+ and supply a TypeSafe API key. HeadshotGenerator.io is for a developer who wants to launch a headshot business on their own domain and is willing to wire Astria training, Supabase auth, Stripe credits, and Vercel Blob themselves. Pick Jev Review if your problem is 'my diffs get reviewed badly.' Pick HeadshotGenerator.io if your problem is 'I want to sell AI headshots.' If you genuinely need both, you need them for unrelated reasons.
Jev Review vs Bito
These two are not competitors — they occupy opposite ends of the AI coding stack. Jev Review is a free, MIT-licensed terminal workflow you install and read end to end; the only real cost is a TypeSafe API key and Node.js 24+. Bito's Governor is an enterprise spend-control product priced through sales, aimed at platform leads whose Claude Code, Cursor, or Codex bills are climbing across multi-repo codebases. If a developer wants an inspectable review pipeline today, Jev Review is the obvious pick. If you're a platform lead trying to cut agent token spend and need SOC 2 Type II and on-prem, Bito is the conversation you're having — nobody shortlists both.
Jev Review vs Replit Agent
These two don't compete for the same budget. Jev Review is a free, inspectable review layer for someone who already writes code and wants typed, staged judgments run locally against a Git diff — you pay in setup time and a TypeSafe API key, not in subscription fees. Replit Agent is the opposite trade: you pay Replit for a managed cloud IDE where natural language becomes a deployed app, and the value is speed to a live URL, not control over the review logic. If your problem is 'I need my diffs reviewed rigorously and I want to own the pipeline,' Jev Review is the tool. If your problem is 'I need to build and ship a working app this week,' Replit Agent is the tool. Choosing between them only makes sense if your real question is build-vs-verify.
Alternatives to jev-review
View all
Frequently Asked Questions
Best-of guides
Used jev-review? Help shape our editorial sentiment research.