More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Agent Rules Generator

    2

    Generate CLAUDE.md, AGENTS.md and Cursor rules for a new project from its real stack, or convert your rules between formats when you switch coding agents.

    Free

    9 usesSecurity scanned
    agent-rules-generator

    agent-rules-generator

    Example session with this skill installed

    "Set up agent config for this Next.js + Prisma + Tailwind project. I use both Cursor and Claude Code."

    • Read your context and instructions
    • Compiled the agent-rules-generator

    Project Discovery Complete

    tech_stack: [nextjs-app-router, typescript, tailwindcss, prisma]
    build_system: [npm, github-actions]
    test_framework: vitest
    existing_config: none

    Generated Files

    CLAUDE.MD (42 LINES)
    ════════════════════
    Safety Rules (lines 1-12):

    • Never modify prisma/migrations/ — they are auto-generated
    • Never modify node_modules/ or .next/ — rebuild instead

    Architecture (lines 13-28):

    • Next.js App Router (app/ directory). Server components by default.
    • Data fetching via server components + Prisma ORM, no useEffect for data
    • Route handlers in app/api/*/route.ts (one per HTTP method)

    Conventions (lines 29-42):

    • Path alias: @/ maps to src/
    • Tailwind only — no CSS modules, no styled-components
    • Components: PascalCase, named exports, one per file
    • Server actions: "use server" at file top or in dedicated action files

    .CURSOR/RULES/ (3 .MDC FILES)
    ═════════════════════════════

    • security-rules.md
    CLAUDE.MD

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

    About this skill

    The Problem

    Every new project starts the same way: your AI agent has zero context. It doesn't know you use App Router instead of Pages Router. It doesn't know your auth code uses JWT with a custom refresh flow, not session cookies. It doesn't know the path alias is @/, not ../../../. So you spend the first 15-30 minutes "teaching" it conventions that should already be in its config files — and by session 4, it's forgotten half of them anyway.

    Meanwhile, you're switching between Cursor on one project and Claude Code on another, maintaining separate rule files that drift apart. A Next.js 15 upgrade breaks your old rules. Your team lead writes a CLAUDE.md and nobody reads past line 200. The config becomes stale documentation nobody trusts.

    What You Get

    • Automated project discovery — detects tech stack, frameworks, build systems, and existing config files from project structure before generating any rules
    • Framework-specific rule templates — React+Next.js (App Router conventions, server components), Python+Django (service layer, migrations), TypeScript (strict mode, brand types), Go (module structure), Rust (cargo conventions)
    • Progressive disclosure architecture — safety rules in first 20 lines, architecture in 20-40, conventions in 40-70, nice-to-have beyond that; rules the agent actually processes first
    • Cross-tool rule translation — migrate .cursorrules JSON to CLAUDE.md markdown and back, preserving intent while adapting format (file-scoped .mdc rules ↔ section-organized CLAUDE.md)
    • Mono-repo multi-service support — root CLAUDE.md for shared conventions + per-service configs for stack-specific patterns across Go, Python, TypeScript services
    • Config drift detection — automated check comparing rule references against actual project structure; flags when a framework upgrade makes old rules give wrong advice

    Why This Beats Prompting It Yourself

    Writing "follow React best practices" is useless — the agent already knows React. The skill captures what's specific to your project that differs from framework defaults. Instead of a 300-line reference document the agent skims, you get a 50-line operating manual where every rule answers: "What would a senior dev who's been on this project for 6 months know that isn't obvious from the code?" Rules are phrased as actionable directives with trigger conditions, not vague suggestions.

    Example Session

    You: "Set up agent config for this Next.js + Prisma + Tailwind project. I use both Cursor and Claude Code."

    Agent:

    # Project Discovery Complete
    tech_stack: [nextjs-app-router, typescript, tailwindcss, prisma]
    build_system: [npm, github-actions]
    test_framework: vitest
    existing_config: none
    
    # Generated Files
    
    ## CLAUDE.md (42 lines)
    **Safety Rules (lines 1-12):**
    - Never modify prisma/migrations/ — they are auto-generated
    - Never modify node_modules/ or .next/ — rebuild instead
    
    **Architecture (lines 13-28):**
    - Next.js App Router (app/ directory). Server components by default.
    - Data fetching via server components + Prisma ORM, no useEffect for data
    - Route handlers in app/api/*/route.ts (one per HTTP method)
    
    **Conventions (lines 29-42):**
    - Path alias: @/ maps to src/
    - Tailwind only — no CSS modules, no styled-components
    - Components: PascalCase, named exports, one per file
    - Server actions: "use server" at file top or in dedicated action files
    
    ## .cursor/rules/ (3 .mdc files)
    - security-rules.md
    

    Use Cases

    • New project bootstrap — configure agent context in 30 seconds when cloning or creating a project
    • Tool migration — translate 15 Cursor .mdc files into a single CLAUDE.md when switching to Claude Code
    • Team standardization — generate consistent agent configs across a mono-repo with 8 microservices in different stacks
    • Framework upgrade — re-generate rules after a major version bump that changes APIs and conventions
    • Rule bloat reduction — take a 400-line CLAUDE.md that the agent ignores and restructure it into a focused, progressive-disclosure format

    Known Limitations

    This skill generates config files but cannot guarantee 100% agent compliance — some failures are model capability issues, not config quality issues. Framework-specific templates cover the most common stacks (React, Next.js, Django, FastAPI, Go, Rust, TypeScript); highly custom or niche frameworks may need manual rule additions.

    This skill generates config files but cannot guarantee 100% agent compliance — some failures are model capability issues, not config quality issues. Framework-specific templates cover the most common stacks (React, Next.js, Django, FastAPI, Go, Rust, TypeScript); highly custom or niche frameworks may need manual rule additions.

    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

    9 uses

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 4 months ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Listed4 months ago
    Updated1 month ago

    What's inside

    Frequently Asked Questions

    This skill enables your AI coding agents to automatically generate and maintain project-specific rule files (like .cursorrules or CLAUDE.md) that define your architecture, coding standards, and workflow preferences from the very first interaction.

    It is compatible with leading AI development environments including Cursor, Claude Code, Windsurf, and various CLI-based agents, offering seamless rule migration between these different platforms.

    Yes, it includes optimized patterns for a wide range of stacks, including React, Next.js, Django, Go, Rust, and TypeScript, ensuring the generated rules respect framework-specific best practices.

    The skill includes a "config drift detection" methodology, which helps your agent identify when project rules have become outdated as your codebase evolves, allowing for automated maintenance.

    You receive the core logic for the rules generator, a library of framework-specific templates, and the architecture for implementing "progressive disclosure" so your agents aren't overwhelmed by too much context at once.

    New in Agents & Orchestration