Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Review Precheck

    1

    Does this git diff need a full code review or just a quick look? A fast, free answer with no API key needed.

    Free

    1 useSecurity scanned
    Review Precheck

    Review Precheck

    Example session with this skill installed

    Run review-precheck on my uncommitted changes. Do they need a full review, or is a quick pass enough?

    • Read your context and instructions
    • Compiled the review precheck

    Summary

    Route: full (exit code 10). Three flags fired, so this change should get a careful review.

    This is real output from a throwaway demo repo, run in offline mode (no API key, no network). The diff did three things: wrapped a file read in a try that ends in except Exception: pass, deleted tests/test_app.py, and added a line to requirements.txt.

    The result

    {
      "route": "full",
      "flags": [
        "dependencies (offline pattern): requirements.txt changed",
        "tests (offline pattern): test file tests/test_app.py deleted",
        "errors (offline pattern): added lines swallow an error (bare except, empty catch, || true)"
      ],
      "note": "offline: pattern checks only, risky logic is not assessed"
    }
    

    Compare: a small, clean change

    The same repo with a one-line change (adding encoding='utf-8' to an open() call) comes back as a quick pass, exit code 0:

    {
      "route": "fast",
      "flags": [],
      "note": "offline: pattern checks only, risky logic is not assessed"
    }
    

    A docs-only diff (README.md) skips the check entirely: {"route": "fast", "flags": [], "note": "docs only"}.

    What the flags mean

    FlagSeen in this diff
    dependenciesrequirements.txt changed
    testsa test file was deleted
    errorsan exception is swallowed with pass
    secrets, auth, schemanothing matched
    risky logicnot assessed offline; only diff size counts (over 30 changed lines never routes fast)

    Next steps

    • Run your full review and tell the reviewer the three flags above, so it starts with the deleted test and the swallowed error.
    • For a model-based second opinion, set a free Codiv OpenJev key as OPENJEV_API_KEY and run it again.
    • Check staged changes with --cached, or a whole branch with main...HEAD.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Hey! This is a small gate you put in front of an expensive code review.

    It reads a git diff and answers one question: does this change need a careful full review, or is a quick pass enough? You get a short JSON answer your agent (or a CI script) can act on.

    What it checks

    Seven questions: secrets, dependencies, auth, schema or migrations, tests, swallowed errors, and risky logic. The wording lives in scripts/review_policy.json, so you can edit it to match your own review policy.

    What you get back

    { "route": "full", "flags": ["tests (offline pattern): test file tests/test_app.py deleted"] }
    

    Exit code 0 means fast (nothing flagged), 10 means full. When it says full, hand the flags to your reviewer so it knows where to look first.

    Two modes

    1. Offline, no key, no network. Regex checks for six of the seven questions: dependency files, schema or migration changes, deleted or skipped tests, secret-shaped strings, auth keywords, swallowed errors. "Risky logic" is judged by size alone: more than 30 changed lines is never called fast.
    2. Model mode, optional. Set a free Codiv OpenJev API key as OPENJEV_API_KEY and the diff is scored by the hosted model instead. Secret-shaped strings are redacted before anything is sent, and the key only goes to api.codiv.ai or a loopback address. A small local model is also possible through jev-tools-setup (see the repo).

    With no key and no offline mode chosen, a code diff routes full with a "Jev unavailable" flag, plus whatever the pattern checks see. It fails safe.

    What you need

    Python 3.10+ and git on your PATH. Standard library only, nothing to pip install.

    Honest limits

    • This is a triage gate, not a code review.
    • Evidence is thin. In model mode it was smoke-tested on two diffs: a rename-only diff routed fast, and a diff with a hardcoded key, a swallowed exception and an emptied test file routed full with the right flags. That is not a benchmark.
    • Offline mode is pattern matching, so it misses anything phrased unusually.
    • Docs-only diffs (.md, .txt, .rst) skip the check and route fast. Diffs over 30,000 characters route full.
    • Untracked files are not in git diff; run git add -N <file> first.
    • It appends one small line per run (timestamp, route, flag count) to ~/.jev-tools/log.jsonl. Diff content and keys are never logged.

    Free and MIT licensed. Source and full measurements: github.com/Rcidshacker/jev-tools

    Needs Python 3.10+ and git. Untracked files are not in git diff, so run git add -N first. In offline mode "risky logic" is judged by size only: more than 30 changed lines is never called fast. Diffs over 30,000 characters always route full. Offline pattern checks miss anything phrased unusually. Only lightly tested; not a benchmark. Tested by the author on Windows only.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    • Free with an Agensi account

    Requires

    Codiv

    Permissions

    Terminal / Shell
    Environment Variables
    Read Files
    Write Files
    Network Access

    Allowed Hosts

    api.codiv.ai

    File Scopes

    ~/.jev-tools/**

    Shell runs git diff and the bundled Python script. Files: it reads the optional config and credentials files that jev-tools-setup writes in ~/.jev-tools, and appends one small log line per run there (never diff content or keys). Environment: reads OPENJEV_API_KEY (and JEV_MODE, JEV_PRECHECK_MIN, JEV_LOG) if you set them. Network: only in optional model mode, a POST to api.codiv.ai (or a loopback address for a local model), with secret-shaped strings redacted first; redirects are refused. Offline mode makes no network calls.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    It reads a git diff and routes it: fast (a quick pass is enough) or full (get a careful review), with flags saying why. It asks seven questions: secrets, dependencies, auth, schema, tests, swallowed errors and risky logic. Exit code 0 means fast and 10 means full. It is a triage gate in front of a review, not a review itself.

    No. Offline mode uses regex pattern checks and needs no key and no network. If you want model scoring as well, set a free Codiv OpenJev API key as OPENJEV_API_KEY, or set up a small local model with jev-tools-setup (see the repo). Without a key and without offline mode chosen, a code diff routes full with a "Jev unavailable" flag, so it fails safe.

    In offline mode, nothing. In model mode, the diff (first 30,000 characters) is sent to api.codiv.ai, or to a local server if you set one up. Secret-shaped strings are redacted first and the key is only ever sent to api.codiv.ai or a loopback address. The redaction is a safety net, not a guarantee, so use offline mode for diffs you would not want to share.

    Honestly, the evidence is thin. In model mode it was smoke-tested on two diffs: a rename-only diff routed fast, and a diff with a hardcoded key, a swallowed exception and an emptied test file routed full with the right flags. Offline mode is pattern matching and was checked on a handful of small throwaway diffs. Treat it as a cheap first filter and read the flags, not a verdict.

    It is a standard SKILL.md that runs a Python script, so any agent that follows the SKILL.md standard and can run Python and git should work. I built it for Claude Code, where the skill folder is available as ${CLAUDE_SKILL_DIR}, and I have not tested other agents. In another agent, point the command at wherever the skill folder was installed.

    One small line per run (timestamp, route, flag count or an error type) appended to ~/.jev-tools/log.jsonl, or to the path in the JEV_LOG variable. Diff content and keys are never logged. It also reads the optional config and credentials files that jev-tools-setup writes in the same folder. Python may also write its usual __pycache__ next to the scripts. Nothing else is written.

    New in Code Quality & Review