Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    architecture copilot

    1

    Enforce architectural patterns and scaffold project modules using codebase graph analysis.

    $3

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    architecture copilot

    architecture copilot

    Example session with this skill installed

    I need to create a new authentication module. Can you scaffold it and tell me the rules for our Clean Architecture setup?

    • Read your context and instructions
    • Compiled the architecture copilot

    I have scaffolded the new authentication module and retrieved the architectural rules from your project graph.

    Authentication Module Scaffold & Rules

    Structure Created
    The following structure was generated at /src/modules/auth:

    • domain/entities/auth_user.ts
    • domain/repositories/i_auth_repository.ts
    • application/use_cases/login_use_case.ts
    • infrastructure/repositories/auth_repository_impl.ts
    • infrastructure/controllers/auth_controller.ts

    Architectural Rules (Clean Architecture)

    Rule TypeConstraint
    Dependency DirectionOuter layers (Infrastructure) may depend on Inner layers (Domain), never the reverse.
    Data FlowUse Data Transfer Objects (DTOs) when crossing layer boundaries.
    Naming ConventionInterfaces must be prefixed with I, implementations suffixed with Impl.
    Logic PlacementBusiness rules strictly in domain, orchestration in application.

    Style Manual Summary

    • Use functional programming patterns for use cases.
    • Inversion of Control (IoC) via constructor injection is required for all repository implementations.
    • Error handling must use the internal Result wrapper type found in shared/core.

    Next steps

    1. Define the AuthUser entity in domain/entities/auth_user.ts.
    2. Implement the LoginUseCase logic using the IAuthRepository interface.
    3. Register the new module in the main dependency injection container.

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

    About this skill

    Manual folder creation often ignores the underlying design patterns of a complex codebase. This skill enforces architectural consistency by analyzing your project graph and scaffolding new modules that strictly mirror your existing structure and rules.

    What it does

    • Automatic scaffolding creates the physical folder and file structure based on your project's real-world graph.
    • Architectural enforcement retrieves specific rules like Clean Architecture or Layered patterns directly from your context.
    • Style extraction identifies coding styles and patterns from similar modules to ensure new code matches the old.
    • Template analysis decomposes existing modules into their constituent classes and functions for replication.
    • Context discovery provides a style manual for any new feature intent before a single line of logic is written.

    How it works

    1. Use scaffold_module with your intent and project path to generate the initial folder and file tree.
    2. Call get_generation_context to retrieve the architectural "style manual" and project-specific constraints.
    3. Search for similar modules using search_similar_modules to understand how the project handles related logic.
    4. Implement the logic within the scaffolded files, adhering to the retrieved rules and patterns.

    Frameworks & tools

    This skill requires an MCP server capable of codebase graph analysis and the provided node execution script for CLI tool access. It works across any stack where architectural patterns like Clean Architecture are defined in the project graph.

    Why this beats prompting it yourself

    Generic prompts often produce "hallucinated" folder structures that don't match your project's specific implementation of a pattern. This skill uses actual graph analysis to physically scaffold files first, ensuring zero drift between your existing architecture and new modules.

    Use cases

    • Scaffold a new domain module like "payments" or "billing" in a Clean Architecture project.
    • Analyze a legacy module to understand its internal structure and dependencies.
    • Onboard new developers by generating code that automatically follows local style guides.
    • Enforce consistency across a microservices repository with many contributors.

    Known limitations

    Requires an MCP server with access to the project's codebase graph. Physical file creation depends on the scaffold_module tool having write permissions to the target path.

    Requires an MCP server for codebase graph analysis. Needs write permissions for scaffolding. Best suited for projects with established architectural 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

    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 6 days ago

    Permissions

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

    What's inside

    Frequently Asked Questions

    Enforce architectural patterns and scaffold project modules using codebase graph analysis.

    This skill uses the open SKILL.md standard. Use it through an MCP-compatible agent connected to Agensi, and check the compatibility information on this page for confirmed agents and required capabilities.

    Connect your AI agent to Agensi through MCP, then ask it to use architecture copilot on your task. Your agent loads the latest approved version each time. Paid skills require a purchase or active subscription. Skill files are not available for download; your licence does not allow you to save, copy or export any part of a skill.

    New in Agents & Orchestration