More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Requesting Code Review: Verification Before Merge

    1

    Turns code review into a deliberate step: size the diff, hand the reviewer a crafted packet, brief humans and agents differently, triage findings by severity.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Requesting Code Review: Verification Before Merge

    Requesting Code Review: Verification Before Merge

    Example session with this skill installed

    I just finished a session-token refactor — about 600 lines across 9 files, moves token storage and updates every call site. I need this reviewed properly before it merges. Set it up.

    • Read your context and instructions
    • Compiled the requesting code review

    REVIEW SETUP — produced by applying the skill.

    Step 1, size: 600 lines is over the careful-reading threshold, so the change splits into two chunks instead of going out as one diff. Chunk A: the new token store and its tests, about 240 lines, self-contained. Chunk B: the call-site migration, about 360 lines, mostly mechanical moves onto Chunk A's API. Chunk A reviews first; B is unreviewable until A's API is accepted.

    Step 2, packet for Chunk A (the one that matters):

    What changed and why: session tokens move out of the user record into a dedicated store with expiry enforced at read time. The old layout made revoking a single session impossible without logging the user out everywhere, which support has needed twice this quarter.
    What it should do: per the ticket — single-session revoke, expiry checked on every read, no change to login behavior.
    Scope: base 9f3ac21..head 4bd77e0, 4 files, ~240 lines. Chunk B follows separately.
    Verified: new unit tests for expiry and revoke (11 cases, passing); existing auth suite green; manual login/logout/revoke run against a staging build.
    Known concerns: the expiry check reads the clock at read time — I want a close look at whether the refresh path can race it and resurrect an expired token.
    Out of scope: the session cookie's attributes; unchanged here, owned by the platform team's in-flight work.

    Step 3, brief: an agent reviewer takes this packet first, briefed to check correctness, the refresh race, and edge cases around clock skew, and to skip style. A human teammate gets the same packet plus the social contract: correctness over style, no urgency, comments by tomorrow is fine.

    Expected loop, stated up front: findings triaged Critical / Important / Minor against the severity rubric; a structural fix to the refresh path would earn a spot re-review of that function only, not a second full pass.

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

    About this skill

    Reviews catch the bugs you are blind to because you wrote the code — but only when they are set up well. A reviewer handed a 2,000-line diff with no context will skim it; a reviewer handed a focused change with a clear brief will actually read. This skill covers the requesting side of that equation. It tells you when to ask (before merge, after a major feature, when stuck, before a risky refactor), how to size the diff so it can be read honestly — roughly 400 lines, split into named chunks above that — and how to assemble the six-part review packet: what changed and why, what it should do, the exact scope as a commit range, how it was verified, your known concerns flagged honestly, and what is out of scope. It briefs human teammates, agent reviewers, and future-you differently, then runs the loop after findings land: triage into Critical, Important, and Minor with a defined action for each, fix and re-verify, re-request only when a fix is structural, and harvest repeated findings into conventions or automated checks. Includes the packet template, a pre-request checklist, a severity rubric, and a complete worked example.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Workflow Automation.

    • It sets up and processes reviews; it does not perform the review itself — a reviewer (human, agent, or future-you) still has to read.
    • It cannot make an unreadable change readable by paperwork alone; over the size threshold, the honest deliverable is the split.
    • Severity calls still need judgment: the rubric defines the actions, not the classification of any specific finding.

    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 buying a skill.

    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 24 days ago

    Software
    Git

    Permissions

    Terminal / Shell
    Listed24 days ago
    Updated21 days ago

    What's inside

    Frequently Asked Questions

    The packet takes about five minutes and routinely saves each reviewer twenty minutes of archaeology — and it is the difference between a review that reads and a review that skims. The overhead is the point: small, deliberate, and cheaper than the bugs it catches.

    Review per logical chunk, lean harder on automated verification, and state in the packet which parts got human eyes and which got machine checks only. The skill's edge cases cover framework migrations and vendored upgrades explicitly.

    Push back with technical reasoning — the code, the test, the constraint the reviewer missed. If it's taste, the repo's conventions decide; if there's no convention, the discussion becomes a proposal for one, not a blocker on your change.

    New in Workflow Automation