Codebase Architecture Map

    1

    Analyze codebase structure, map dependencies, and calculate change impact using local AST and git analysis.

    Free

    2 usesSecurity scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    codebase-architecture-map

    Example session with this skill installed

    Run an architecture overview and impact analysis on the current repository to see what happens if I modify the database utility module.

    • Read your context and instructions
    • Compiled the codebase-architecture-map

    I have analyzed the repository structure and the potential impact of modifying the database utility.

    Architecture and Impact Analysis

    MetricDetails
    Primary StackPython 3.11, FastAPI, SQLAlchemy, PostgreSQL
    Codebase Size42 files, ~8,500 LOC
    Entry Pointsapp/main.py, workers/sync_node.py
    Target Moduleapp/db/utils.py
    Direct Importersapp/models/user.py, app/api/v1/auth.py, app/crud/base.py
    Transitive Blast Radius12 modules (High Impact)
    Risk LevelHigh - This is a central hub module with 18 incoming dependencies.
    Circular DependenciesNone detected in the database path.

    Next steps

    1. Review app/crud/base.py as it is the most complex direct consumer of this utility.
    2. Run the integration test suite in tests/db/ before committing any changes to the utility.
    3. Use the explain tool on app/models/user.py to see how it utilizes the session decorator.

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

    About this skill

    Large or unfamiliar repositories often paralyze agents with too much context and not enough structure. This skill provides a structural map of a codebase to prevent blind edits and excessive file reads. It gives you a clear understanding of tech stacks, module relationships, and the potential blast radius of your changes.

    What it does

    • Architectural mapping Identifies core languages, frameworks, entry points, and top-level project structure.
    • Dependency analysis Maps internal import graphs to reveal circular dependencies and central "hub" modules.
    • Risk assessment Locates hotspots by identifying the largest, most complex, and most frequently changed files.
    • Impact analysis Calculates the transitive blast radius before you edit a file to see what else will break.
    • Codebase orientation Generates summaries of specific folders, classes, functions, and external requirements.

    How it works

    1. Orient Run architecture_overview to identify the tech stack and entry points.
    2. Map Execute dependency_graph to see how modules connect and find circular imports.
    3. Analyze Use hotspots and impact_analysis to identify high-risk files and the ripple effects of proposed changes.
    4. Explain Trigger explain on specific sub-directories to understand local implementation details before reading source code.

    Frameworks & tools

    This skill requires the mcp-architect server. It supports full AST parsing for Python and import parsing for JavaScript and TypeScript. It provides file statistics for over 25 other languages.

    Why this beats prompting it yourself

    Standard agents try to read every file to understand structure, which wastes tokens and misses hidden dependencies. This skill uses specialized local tools to build a graph of the codebase, identifying circular imports and high-risk hubs that a simple file search would overlook.

    Use cases

    • Onboard onto a massive legacy codebase without reading every file manually.
    • Identify circular dependencies that are causing runtime or build issues.
    • Calculate the blast radius of a refactor before touching a shared utility module.
    • Find tech debt by listing files with the highest complexity and change frequency.

    Known limitations

    Full AST parsing is limited to Python. JavaScript and TypeScript support import parsing. Other languages return basic file and line statistics only. Complexity data requires a local git history.

    Full AST parsing only for Python. JS/TS limited to import parsing. Other languages get stats only. Requires local mcp-architect server and git history for hotspot data.

    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

    2 uses

    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

    Architect MCP
    uv (Python tool runner)

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    The skill uses local AST parsing and git history to map dependencies and calculate "blast radius," preventing agents from wasting tokens on unnecessary file reads or making blind edits to high-risk modules.

    It offers full AST parsing for Python, import-level mapping for JavaScript and TypeScript, and basic file statistics for over 25 other programming languages.

    Yes, the skill requires the installation of the `mcp-architect` server to perform local analysis, ensuring your source code is processed locally before insights are sent to the agent.

    The 'Impact Analysis' feature calculates the transitive dependencies of a file, showing you exactly which other modules or functions might break if you modify a shared utility or core component.

    The complexity and hotspot analysis features require a local git history to identify which files are changed most frequently and represent the highest technical debt.

    New in Agents & Orchestration