More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    craft review

    1

    A strict read-only quality gate that enforces complexity limits, SOLID principles, and design patterns.

    Free

    1 useSecurity scanned
    craft review

    craft review

    Example session with this skill installed

    Review my changes in user_service.ts and check against the acceptance criteria:

    1. Password must be hashed before saving, 2. No direct DB calls in the controller.
    • Read your context and instructions
    • Compiled the craft review

    I have completed the read-only quality gate review for user_service.ts comparing the current diff against your acceptance criteria and the craft-gates standards.

    Code Quality Audit

    VERDICT: CHANGES_REQUIRED
    BLOCKERS: 1  MAJORS: 1  MINORS: 2
    
    GATES CHECKED (per function):
    - user_service.ts:registerUser — lines: 42, nesting: 3, complexity: 8, callback-depth: 1  [VIOLATION]
    - user_service.ts:validateInput — lines: 12, nesting: 1, complexity: 3, callback-depth: 0  [ok]
    
    FINDINGS:
    - [BLOCKER] user_service.ts:38 — Acceptance Criteria — Password is saved as plain text from the request body; hash the password using the crypto provider.
    - [MAJOR] user_service.ts:40 — IO in Domain Layer — Direct call to `db.users.save()` found in service logic; inject a repository interface instead.
    - [MINOR] user_service.ts:15 — Long Function — Method exceeds 30-line threshold (§1); extract validation logic to a private helper.
    - [MINOR] user_service.ts:22 — Primitive Obsession — Passing 5 raw strings; wrap in a `UserRegistrationRequest` DTO.
    
    ACCEPTANCE CRITERIA:
    1. Password hashed: not met
    2. No direct DB calls: not met
    

    Next steps

    • Move the database persistence logic into a dedicated repository class to satisfy the domain layer gate.
    • Implement the bcrypt.hash call before the persistence step to meet the primary acceptance criterion.
    • Refactor registerUser by extracting the validation block to reduce the line count below the §1 limit.

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

    About this skill

    Standard AI coding assistants often provide vague suggestions without checking your specific team standards. This skill acts as a strict, read-only quality gate that enforces hard metrics and architectural principles on every pull request or file change. It eliminates the subjectivity of code reviews by measuring exact complexity, nesting depth, and SOLID violations.

    What it does

    • Hard Metric Validation measures function length, cyclomatic complexity, nesting levels, and callback depth against defined thresholds.
    • Architectural Auditing scans for SOLID principle violations and specific code smells at the diff boundary.
    • Pattern Enforcement identifies missed opportunities for design patterns or flags speculative generality where patterns are applied without a trigger.
    • Automated Verdicts issues a formal APPROVED or CHANGES_REQUIRED status based on the count of blockers and major findings.

    How it works

    1. Target Identification analyzes specified files or runs git diff to determine the scope of the review.
    2. Contextual Analysis reads callers and callees to ensure domain logic is separated from IO and infrastructure.
    3. Metric Calculation performs static analysis to generate a report of lines, nesting, and complexity for every function.
    4. Gate Evaluation checks findings against the gate rulebook and any user-provided acceptance criteria.

    Frameworks & tools

    This skill works with any codebase where static analysis can be performed. It uses tools like lint, tsc --noEmit, and complexity analyzers to gather raw data before applying its internal logic.

    Why this beats prompting it yourself

    Generic prompts often miss subtle architectural rot or fail to provide the exact line counts needed for a objective gate. This skill forces a structured output that cites specific rules, ensuring reviews are consistent, data-driven, and repeatable across different developers.

    Use cases

    • CI/CD Gating to block merges that exceed complexity thresholds.
    • Refactoring Audits to ensure new changes don't introduce technical debt.
    • Architectural Reviews to verify SOLID compliance in domain layers.
    • Acceptance Verification to confirm all feature requirements are met.

    Known limitations

    Requires read access to the local file system and basic dev tools like git or compilers for full context. It does not perform auto-fixes or modify code.

    Requires local environment access for git diff and static analysis tools. Does not perform automated refactoring. Logic depends on citations from the craft-gates rulebook.

    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

    Git

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    This skill acts as an automated, read-only quality gate that enforces strict metrics like cyclomatic complexity and SOLID principles to eliminate subjective or vague feedback during code reviews.

    The skill works with any codebase where static analysis can be performed and is compatible with major AI agents that have local file system and CLI access (e.g., git, compilers).

    No, this is a read-only auditing tool designed to prevent 'ghost changes.' It identifies blockers and issues verdicts, but it will never modify your source code.

    Setup is minimal: once the skill is added to your agent, you simply provide read access to your local directory and ensure your standard build tools (like tsc or lint) are accessible.

    Yes, you can define specific thresholds for function length, nesting depth, and other metrics within your gate rulebook to match your team's specific coding standards.

    The purchase includes the full 'craft review' skill logic, the gate rulebook framework, and access to all future version updates as new architectural patterns are added.

    New in Code Quality & Review