More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Self Learning Code Reviewer

    1

    A senior code reviewer that adapts to team preferences using an auditable, structured feedback loop.

    $9.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Self Learning Code Reviewer

    Self Learning Code Reviewer

    Example session with this skill installed

    Review this Python function. Note: Finding CR-002 was marked as a false positive in my last two reviews because we use a custom decorator for auth. Use this log: [JSONL log data]

    • Read your context and instructions
    • Compiled the self learning code

    The code has been reviewed against general engineering standards and the provided preference log.

    Adaptation status

    Adapted: 1 active suppression (auth decorator pattern), 0 severity adjustments, 0 conflicts.

    Findings

    CR-001 — Unhandled Database Connection Timeout

    • Location: db_utils.py:42 in fetch_user_data
    • Severity: High
    • Confidence: High

    Issue: The connect() call lacks a timeout parameter and is not wrapped in a try-except block for connection errors.

    Why it matters: A hanging database connection can exhaust the connection pool, leading to a service-wide denial of service.

    Suggested fix: Add a timeout=5 parameter to the connection call and implement a retry mechanism or a graceful failure.

    CR-002 — Missing Input Validation on UserID

    • Location: routes.py:12 in get_profile
    • Severity: Medium
    • Confidence: High
    • Issue: The user_id from the URL segment is passed directly to the query without type checking.

    Why it matters: While the ORM prevents SQL injection, invalid types will cause 500 errors instead of clean 400 Bad Request responses.

    • Suggested fix: Cast user_id to int and handle the ValueError.

    Review summary

    • Critical: 0
    • High: 1
    • Medium: 1
    • Low: 0
    • Info: 0
      Note: One finding related to authentication was suppressed based on your historical preference log.

    Next steps

    1. Apply the timeout fix to db_utils.py to prevent connection pooling issues.
    2. Review the routes.py input handling to improve API error responses.
    3. Provide feedback on these findings to update your preference log.

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

    About this skill

    The problem

    Every code reviewer you've ever used has told you the same wrong thing more than once. You correct it, it forgets, next PR it's back — and eventually you stop reading the findings at all, which is exactly when the real bug slips through.

    What it does

    Runs a full baseline review — correctness, security, performance, maintainability — the first time, no setup required. From there, every correction you give it becomes part of a permanent, visible record: what was wrong, why, and what your team actually wants instead. Tell it something's a false positive twice and it stops raising it — once isn't enough, so a single bad call from you can't accidentally blind it to a real issue. Every adjustment is logged as clean, structured data you can export and use to fine-tune your own model later.

    Why this beats prompting it yourself

    A pasted style guide is a snapshot — it doesn't get smarter, and it doesn't remember last week's correction. This does both. You're not re-teaching it the same lesson every session; you're building an actual record of how your team reviews code, one real correction at a time.

    Use cases

    A team tired of explaining the same architectural exception in every PR. A legacy codebase where the "known issues" list is longer than the changelog. An engineering org where nobody agrees on what counts as High severity. A team quietly building toward their own fine-tuned review model, one correction at a time.

    Known limitations

    It adapts in context, not by retraining itself — no weights change on their own. It has a long memory, not a new brain.

    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 a preference log for adaptation. Does not modify model weights. Pattern suppression requires at least two identical corrections.

    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 1 month ago

    Permissions

    No special permissions declared or detected

    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Traditional tools repeat the same errors, leading to alert fatigue. This skill features a 'learning loop' that remembers your corrections, ensuring that once you flag a false positive or style preference, the agent adapts its future reviews accordingly.

    The agent is language-agnostic and performs best with Python and JavaScript, but it can review any language supported by your underlying LLM. It focuses on correctness, security, performance, and maintainability out of the box.

    Absolutely. Every correction and preference you provide is stored as structured data that can be exported, providing a perfect dataset for teams planning to fine-tune their own proprietary models in the future.

    To prevent 'accidental blinding,' the agent requires two consistent corrections before it permanently alters its behavior on a specific rule. This ensures a single outlier comment doesn't stop the agent from catching genuine bugs.

    Setup is instant with no initial configuration or style guide uploading required. The agent begins with a baseline review and builds its understanding of your team's specific architectural preferences dynamically as you interact with it.

    This skill is compatible with major AI agent platforms and can be integrated into most CI/CD workflows via API. Check the 'Compatibility' section of the listing for specific supported hosting environments.

    New in Code Quality & Review