More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Code Review Gate for AI-Written Code: 120+ Scripted Checks

    1

    Every other review skill hands your agent a checklist and hopes.

    $14

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Code Review Gate for AI-Written Code: 120+ Scripted Checks

    Code Review Gate for AI-Written Code: 120+ Scripted Checks

    Example session with this skill installed

    Review PR #142 before I merge it. The branch is checked out; the description is in PR.md. It adds Stripe checkout for bookings and the author says it includes validation, error handling and tests.

    • Read your context and instructions
    • Compiled the code review gate
    • Generated the document

    Verdict: BLOCK — scripted score

    0/100 (F). Do not merge: 12 critical findings, the description is contradicted by the diff, 23 high-severity findings. 19 files, +188 / −17 lines.

    Claims in the description vs the diff

    ClaimStatusEvidence
    Added input validation on the booking payload❌ unsupportedNo added line validates anything; the only hint is // TODO: validate dates (route.ts:21)
    Handles errors gracefully in the new API routes❌ unsupportedroute.ts:41 returns err.stack to the client; notify.py:22 except Exception: pass
    Includes unit tests for the new booking endpoint❌ unsupportedbookings.test.ts adds it.only + it.skip, 0 assertions
    No breaking changes: formatPrice and slugify are unchanged⛔ contradictedslugify removed (utils.ts:5), formatPrice(cents, currency) → (cents) (utils.ts:1), DROP COLUMN phone (0002_payments.sql:15)
    Fixes #142 (double bookings)❌ unsupportedthe overlap check is commented out (route.ts:24-28); no regression test
    Tested locally with the Stripe CLI❓ unverifiablecannot be checked from a diff

    Critical (12) — .env.local committed with a Supabase service_role JWT, a live Stripe secret key, the database URL with its password and an OpenAI key · the same Stripe key hard-coded in lib/stripe.ts:3 · NEXT_PUBLIC_SUPABASE_SERVICE_ROLE_KEY used in lib/supabase.ts:6 (service role shipped to the browser, RLS bypassed) · dangerouslyAllowBrowser: true in lib/ai.ts:4 · alter table profiles drop column phone in a live migration.

    High (23) — Stripe webhook handled without constructEvent (anyone can POST "payment succeeded") · unit_amount: body.amount and amount_cents: body.amount (the customer sets the price) · payments table created without RLS · create policy ... using (true) on bookings · jwt.decode(token) replaced jwt.verify · the middleware line that redirected logged-out users was removed · dangerouslySetInnerHTML on review bodies · pickle.loads, shell=True, random.randint OTP in the worker · it.only · "left-pad": "*", "openai": "latest", new postinstall script.

    Medium (14) — /api/admin/users and /api/checkout have no auth check · server action updateProfile updates any profile by id · mailer.send(...) never awaited · stack trace in the 500 response · SECURITY DEFINER without search_path · mutable default items=[] · requests.post without timeout · test file skipped a case.

    Low (15) — select('*') on profiles, console.log of the request body, two TODOs, five commented-out lines (the overlap check), catch (err: any), four new functions no test references.

    Judgement pass (mine, not scored): the POST /api/bookings handler trusts owner_id from the body, so any caller can create bookings on behalf of any user; the webhook writes payments without idempotency, so a Stripe retry double-inserts; nightsBetween is never used, so a 1-night and a 30-night stay cost the same client-sent amount.

    Next steps

    1. Rotate the Supabase service key, the Stripe key and the database password now; remove .env.local and purge it from history.
    2. Move the service-role client and the OpenAI call to server-only code; verify the webhook signature; compute prices from the sitter's rate.
    3. Restore jwt.verify and the middleware redirect; add auth to the admin, checkout and profile actions; enable RLS on payments and replace the using (true) policy.
    4. Write the tests the description promises (schema, overlap regression, pricing) and remove .only.
    5. Re-run reviewgate.py review --baseline review/review.json; I will do the judgement pass again on the new diff.

    Full output: review/review.md (this, as a PR comment), review/report.html, review/findings.sarif.

    report.html

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    Your agent reviews its own code the way a senior engineer would: with evidence, not vibes.

    Every other review skill hands your agent a checklist and hopes. This one ships the tooling: tell your agent "review this PR before I merge" and it runs 120+ deterministic checks on the diff, verifies every claim in the PR description against what the code actually does, scores the change 0-100, gives a MERGE / FIX FIRST / BLOCK verdict, and writes a review you can paste straight into the pull request. Then SKILL.md walks it through the judgement pass no script can do: intent vs implementation, edge cases, concurrency, money, rollout order.

    On the bundled sample PR (a Next.js + Supabase + Stripe app, written by a coding agent whose description promises validation, error handling, tests and no breaking changes) the gate returns 0/100 BLOCK with 12 critical findings and 5 of 6 claims unsupported or contradicted. The fixed version of the same PR scores 97/100 MERGE, with 62 findings resolved against the baseline.

    What you get

    • One command, four outputs: review.md (PR-comment ready), report.html (printable: score ring, verdict, points by category, claims table, findings with the exact line, why it matters and the fix), review.json, and findings.sarif for GitHub code scanning. Exit code 2 on BLOCK so CI can fail.
    • Claims vs diff: "added input validation", "handles errors gracefully", "includes tests", "no breaking changes", "fixes #142", "refactor only" are each checked against evidence in the diff and reported VERIFIED / UNSUPPORTED / CONTRADICTED with the lines that prove it. A contradicted description blocks the merge.
    • Secrets that actually matter: 40 provider patterns (AWS, Stripe live/test/webhook, OpenAI, Anthropic, GitHub, Google, Slack, SendGrid, Twilio, npm, Supabase...), private-key blocks, database URLs with passwords, committed .env files, Supabase service_role JWTs (the payload is decoded; the public anon key is not flagged), and secret-named variables behind NEXT_PUBLIC_ / VITE_ prefixes that end up in the browser bundle.
    • Access control: Next.js route handlers and server actions, Express/Fastify and FastAPI/Flask mutating routes with no auth check, webhooks that never verify a signature, .delete().eq('id', param) without an owner check, Supabase tables created without RLS, USING (true) policies, GRANT ALL TO anon, Firebase rules open to everyone.
    • The classics, deterministically: SQL and shell built from strings, eval, dangerouslySetInnerHTML, pickle/yaml.load, open redirects, path traversal, wildcard CORS with credentials, TLS verification off, alg: none, jwt.decode without verify, weak hashes, Math.random() tokens, prices taken from the client, stack traces returned to users, env vars dumped to logs.
    • What AI code leaves behind: empty catch blocks, except: pass, promises never awaited, .only/.skip tests, tests without assertions, console.log/print, breakpoints, TODOs, commented-out code, merge-conflict markers, as any, duplicated blocks, 200-line functions, N+1 loops in for + await.
    • Change-aware checks: exported symbols removed or re-signed (callers break at runtime), endpoint files deleted, auth / rate-limit / validation / security lines that were removed, destructive migrations (DROP, RENAME, type changes, NOT NULL without default, mass UPDATE), latest/* dependencies, postinstall scripts, unpinned GitHub Actions and script injection.
    • Test deltas: 15+ lines of code and no test touched, new functions no test references, test files deleted, snapshot-only tests.
    • Baselines: --baseline previous/review.json reports fixed / new / unchanged after a fix loop.
    • CI in one command: ci --github prints a workflow that diffs against the base branch, uploads SARIF, comments the review on the PR and fails on BLOCK; ci --pre-push prints a hook. GitLab snippet in the docs.
    • Whole-repo audit (--full) for the "what did the agent leave in my codebase" question.
    • Noise control: .reviewgate.json (ignored paths, disabled rules, severity overrides, intentionally public routes, allow-listed test values) and // reviewgate-ignore RG-xxx reason on a line. Severity says impact; confidence says how sure the matcher is.

    Why it beats prompting

    Prompting a chat agentCode Review Gate
    "Looks good, a few suggestions"0-100 score, verdict, every finding at file:line with the snippet and the fix
    Trusts "includes tests" in the descriptionFinds that the tests have no assertions and marks the claim unsupported
    Misses the service-role key because it looks like the anon keyDecodes the JWT, sees role: service_role, flags it critical
    "Consider adding error handling"Points at the empty catch on line 41 and the stack trace returned on line 52
    Different answer every runSame diff, same findings; diffable with --baseline
    Nothing for CISARIF upload, PR comment, exit code 2 on BLOCK

    Honest by design

    The scripts produce the score and verdict; the agent's judgement findings are listed separately and may override the recommendation, and the review says when they do. Every rule cites its reference (CWE, OWASP, Supabase, Firebase, Stripe, PostgreSQL, GitHub docs) and carries a confidence level. "No findings" means the checks found nothing, not that the code is correct. This is a review aid, not a security assessment.

    What's inside

    SKILL.md (7-step workflow, judgement pass, honesty rules, quality checklist) · 10 Python scripts (unified-diff parser, 90 line rules, secrets engine, structural checks, test deltas, claim verifier, scoring, Markdown/HTML/JSON/SARIF writers, CLI) · 6 references (every check with severity, confidence and fix; the judgement-pass method and review template; claim types; scoring; config and suppressions; CI recipes) · a sample PR in three states (before, as submitted, fixed) with diffs and descriptions · pre-built sample output.

    Requirements

    An agent that can run code with Python 3.8+. Standard library only: no installs, no API keys, no network. Works on diffs from git, GitHub (gh pr diff), GitLab or any unified diff.

    • Pattern-based: rules are practitioner heuristics with references and a confidence level, not a full static analyser or a security assessment. Expect occasional false positives (suppress with a reason) and false negatives (the judgement pass exists for those).
    • Deepest coverage for JavaScript/TypeScript, Python and SQL; Go, Ruby, PHP, Java, Kotlin, C# get the language-agnostic rules (secrets, config, migrations, leftovers) plus a subset of code rules.
    • Route-handler auth detection recognises common patterns (Next.js, Express/Fastify, FastAPI/Flask, Supabase, Clerk, Auth.js, JWT); unusual auth layers may need public_routes or a suppression.
    • Claim patterns are English; a claim phrased unusually is not checked and nothing is reported for it.
    • Breaking-change detection compares exported symbols within the diff; it does not search call sites across other repositories.
    • Does not run tests, type checkers or linters, and does not fetch dependency advisories (offline by design); combine with those in CI.
    • The HTML report uses no external resources; the SARIF targets GitHub code scanning (SARIF 2.1).

    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

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Terminal / code execution: runs the bundled Python scripts (scripts/reviewgate.py, standard library only). It starts no other programs; git or gh commands that produce the diff are run by the agent separately. Read files: the repository you point it at (--repo), the diff and description files you pass, and the skill's own references and examples. Write files: only the output folder you choose (--out, default review-out): review.md, report.html, review.json, findings.sarif. The demo writes to its --out folder and only deletes a folder that contains its own DEMO.md. The ci command prints to stdout. Network access: none. The sample repository under examples/ contains fetch(...) calls as review material; nothing in it is executed. No environment variables, API keys, secrets, telemetry or installs. Every credential in the examples is fake.

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    It reads and reasons; this adds what reading cannot: 120+ deterministic checks with file:line evidence, JWT decoding, claim verification against the diff, a reproducible score, SARIF for CI. The SKILL.md then makes the agent do the reading part properly too.

    They are prompts. This ships scripts that find the same issue every time at the same line, prove or disprove the PR description, compare runs against a baseline, and plug into GitHub code scanning.

    It needs a unified diff, from anywhere (git diff, gh pr diff, GitLab, or a .diff file), plus the working tree for context. With no diff at all, --full audits a folder.

    Only if you wire the exit code into CI. The generated workflow fails on BLOCK (critical findings, a contradicted description or 3+ high findings); you can keep it advisory by removing that step.

    Every finding carries a confidence level and a rule id. Suppress a line with // reviewgate-ignore RG-xxx reason or tune .reviewgate.json; the review lists suppressions so nothing disappears silently.

    JavaScript/TypeScript (Next.js, Express, Fastify, Prisma, Supabase, Stripe), Python (FastAPI, Flask, Django, requests), SQL migrations (Postgres/Supabase), Firebase rules, Dockerfiles, GitHub Actions and package manifests.

    New in Code Quality & Review