ai Agent Kit

    1

    A multi-repo governance kit for deep code auditing, rule enforcement, and structured task implementation.

    Free

    1 use3.0 (1 review)

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    ai-agent-kit

    Example session with this skill installed

    /x-check --severity high

    • Read your context and instructions
    • Compiled the ai-agent-kit

    I have audited the staged and unstaged changes in the backend and frontend repos against the project rules.

    /x-check report — High/Critical Severities

    Repos scanned: backend, frontend
    Files checked: 4
    Rules applied: 12 (Filter: high)
    Violations found: 2


    🔴 Critical (1)

    Line 45: S-02 No Hardcoded Secrets
    const API_KEY = "sk-live-51MzS...";
    

    Fix: Move all secrets to environment variables or a secure vault. Use process.env.STRIPE_SECRET.


    🟡 High (1)

    Line 102: A-05 Missing CSRF Protection
    @Post('/update-profile')
    async updateProfile(@Body() data: UpdateDto) {
    

    Fix: Ensure all state-changing routes have the @UseGuards(CsrfGuard) decorator or equivalent middleware.


    Violations by rule

    RuleLines
    S-02 No Hardcoded Secretsbackend/src/config.ts:45
    A-05 Missing CSRF Protectionbackend/src/user.controller.ts:102

    Next steps

    • Apply the fixes to the identified lines in backend.
    • Run /x-check --staged-only after fixing to verify compliance.
    • Call /x-add-rule if this audit surfaced a new pattern to block.

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

    About this skill

    Codebases often suffer from "rule drift" where architectural constraints and security standards are documented in wikis but ignored in PRs. Manual code reviews are slow, inconsistent, and prone to missing non-obvious violations like Unicode homoglyphs or specific AI-generated patterns.

    What it does

    • Multi-repo Auditing: Performs line-by-line senior-level code reviews across NestJS, Laravel, Next.js, and Flutter projects.
    • Rule Enforcement: Checks uncommitted or staged changes against a central rules.md file using regex and semantic analysis.
    • Automated Implementation: Executes complex coding tasks in three phases: scope-locking, implementation, and automated self-correction.
    • Rule Lifecycle Management: Appends new project-specific rules with structured Why/Detect/Fix fields and auto-updates project metadata.
    • Change Verification: Generates clickable reports for rule violations, including specific line numbers and required fixes.

    How it works

    1. Audit: Use /x-audit to map the codebase and generate structured architecture and findings reports.
    2. Implement: Use /x-implement for tasks, which triggers a Phase 0 scope contract before writing any code.
    3. Check: Run /x-check or /x-check-file to scan local changes against the project's security and quality rules.
    4. Govern: Use /x-add-rule to codify new constraints learned from audits or bugs into the master rule file.

    Frameworks & tools

    This kit supports major stacks including NestJS, Express, Laravel, Django, Next.js, React, Flutter, and Go. It utilizes standard CLI tools like grep, bash, and git for deep inspection.

    Why this beats prompting it yourself

    Generic prompts forget project-specific constraints after a few turns. This skill forces every interaction through a persistent, version-controlled rules.md file, ensuring that architectural "laws" are enforced pedantically across entire sessions and multi-repo environments.

    Use cases

    • Enforce strict authentication patterns across a monorepo.
    • Perform a deep security audit of a legacy PHP or Node.js codebase.
    • Scaffold features with mandatory Phase 0 planning to prevent scope creep.
    • Automatically scan for "AI-tell" vocabulary and non-standard Unicode in PRs.

    Known limitations

    Audits of files exceeding 2000 lines require chunked reading. Rule detection depends on the quality of the plain-English 'Detect' instructions in the master rules file.

    Requires a RULES_PATH file to exist. Large files (>2000 lines) are processed in chunks. Unicode scanning requires specific grep patterns.

    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

    3.0
    1 review
    5
    0
    4
    0
    3
    1
    2
    0
    1
    0

    This skill has been used 1 time.

    Trust & safety

    Security scan

    Security scan passed 17 days ago

    • Free with an Agensi account

    Requires

    Git

    Permissions

    Terminal / Shell
    Read Files
    Browser
    Network Access
    Write Files
    Environment Variables
    Listed17 days ago

    What's inside

    Frequently Asked Questions

    The kit uses a persistent 'rules.md' file that acts as a codebase constitution, forcing the AI to check every change against specific architectural laws rather than relying on its short-term memory or generic training data.

    It is compatible with any AI agent or IDE extension that supports custom instructions and file system access, and it utilizes standard CLI tools like bash and grep for deep codebase inspection.

    Yes, it is designed for multi-repo environments and monorepos, allowing you to enforce consistent authentication, security, and styling patterns across different frameworks like NestJS, Laravel, and Flutter simultaneously.

    Phase 0 is a mandatory 'scope-locking' step where the agent defines the plan and constraints before writing code, preventing common AI issues like scope creep, hallucinated dependencies, or logic errors.

    You receive the complete governance framework, including the specialized command set (/x-audit, /x-check, etc.), the structured rule lifecycle templates, and the multi-repo auditing logic.

    While highly scalable, individual files exceeding 2000 lines should be processed using the kit's chunked reading utility to ensure the AI maintains full context and doesn't miss granular violations.

    New in Agents & Orchestration