Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    devflow review

    1

    Reviews your changes on three separate axes (correctness, standards, and conformance to the plan in docs/plan/) with independent reviewers, then reports them side by side with a clear ready / fix-first verdict.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    devflow review

    devflow review

    Example session with this skill installed

    Review my current changes against the plan for the authentication-refactor branch.

    • Read your context and instructions
    • Compiled the devflow review

    I have reviewed the uncommitted changes in the auth-provider.ts and session-store.ts files against the plan found in docs/plan/authentication-refactor.md.

    Review: authentication-refactor — Working Tree vs HEAD, 2 files

    Correctness

    • 🔴

    CRITICAL: The SessionStore.clear() method does not invalidate the underlying Redis key, leading to stale sessions remaining active after logout.

    • 🟡

    WARNING: tokenAge calculation uses Date.now() without accounting for potential server clock drift in distributed environments.

    Standards

    • 🟢 INFO: Successfully follows repo-specific CODING_STANDARDS.md regarding naming conventions.
    • 🟡

    WARNING: Found a code smell in auth-provider.ts: the handleAuth function has a cyclomatic complexity of 12, exceeding the bundled clean-code limit of 10.

    • 🟢 INFO: Test configuration verified; new tests follow the Vitest patterns defined in package.json.

    Plan

    • ✅ Requirement 1: Migrate session storage to Redis — Implemented.
    • ✅ Requirement 2: Implement token rotation — Implemented.
    • ❌

    Missing: The requirement "Add audit logging for failed login attempts" (Plan item 4.2) was not found in the diff.

    Summary

    • Correctness: 1 blocking, 1 warning — worst: Session invalidation failure.
    • Standards: 0 blocking, 1 warning — worst: High function complexity.
    • Plan: 2/3 requirements met — worst: Missing audit logging.

    Verdict: ❌ Fix blocking items first

    Next steps

    1. Fix the Redis key invalidation in session-store.ts.
    2. Implement the missing audit logging as specified in the plan.
    3. Refactor handleAuth to reduce complexity before re-reviewing.

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

    About this skill

    Code review often fails because reviewers conflate functionality with style. An implementation might match the spec perfectly but contain a critical security vulnerability, or it might be bug-free but violate every internal coding convention. This skill enforces separation of concerns by auditing changes across three distinct axes: correctness, standards, and plan conformance.

    What it does

    • Multi-axis auditing reviews changes for logic bugs, security flaws, repo-specific standards, and alignment with project plans.
    • Plan conformance checks the docs/plan/ directory to ensure the implementation delivers exactly what was scoped—no more, no less.
    • Standards enforcement applies bundled clean-code rules for JS/TS and checks for repo-specific configs like Biome, ESLint, or Prettier.
    • Automated scope detection determines the diff between the working tree, staged files, or branch bases without manual input.
    • Subagent orchestration runs reviewers in parallel using subagents to prevent cognitive bias and speed up feedback.

    How it works

    1. Scope detection: Run the skill to identify the diff, whether it is uncommitted work or a full branch comparison against main.
    2. Context gathering: The skill locates the relevant plan in docs/plan/ and pulls repo-specific coding standards and tooling configurations.
    3. Parallel review: Three independent reviewer prompts are generated and dispatched to subagents (or run sequentially) to audit the code.
    4. Synthesis: Reviewers return individual reports for Correctness, Standards, and Plan, which are presented side-by-side with a final "Ready" or "Fix" verdict.

    Frameworks & tools

    Uses git and bash. Bundled standards are optimized for JavaScript and TypeScript projects. Compatible with agents supporting subagents like Claude Code for parallel execution.

    Why this beats prompting it yourself

    Manual prompts often result in "hallucinated" style guides or generic feedback that ignores your specific project plan. This skill forces the LLM to verify changes against your actual docs/plan/ files and local configuration files, ensuring the review is grounded in your project's reality.

    Use cases

    • Auditing uncommitted work for bugs and code smells before a local commit.
    • Comparing a feature branch against the base branch before opening a Pull Request.
    • Verifying that a completed task matches the requirements defined in a technical plan.
    • Checking test configurations and adherence to repo-specific CONTRIBUTING.md guidelines.

    Known limitations

    Requires a git environment and bash. Plan conformance review requires plans to be located in docs/plan/. Parallel execution depends on the host agent's capability to spawn subagents.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Code Quality & Review.

    Requires git and bash. Plan review needs files in docs/plan/. Parallel subagent execution requires specific agent support.

    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 today

    Software
    biomeNode.jseslinttscGit

    Permissions

    Terminal / Shell
    Browser
    Read Files
    Write Files
    Network Access
    Environment Variables
    Listedtoday

    What's inside

    Frequently Asked Questions

    This skill uses a "separation of concerns" strategy, employing parallel subagents to audit code specifically for logic (Correctness), style (Standards), and project requirements (Plan Conformance) rather than providing generic, one-size-fits-all feedback.

    While the bundled clean-code rules are optimized for JavaScript and TypeScript, the tool is language-agnostic regarding Plan Conformance and can audit any codebase that uses git and maintains a `docs/plan/` directory.

    The skill is designed for agents that support subagent orchestration (like Claude Code) to enable parallel reviews, but it can also run sequentially in standard bash-capable LLM environments.

    No, the skill automatically detects the diff between your working tree, staged files, or branch bases using git, so you don't have to manually copy and paste code into the chat.

    The 'Plan Conformance' feature specifically audits your changes against the technical requirements located in your `docs/plan/` folder to ensure the implementation hasn't missed any features or introduced unnecessary scope creep.

    You will receive the skill definition, the logic for automated scope detection, the multi-axis reviewer prompts, and the synthesis engine that generates the final 'Ready' or 'Fix' verdict.

    New in Code Quality & Review