
Architecture Diagram
- 84 installs
- 325 repo stars
- Updated August 2, 2026
- athola/claude-night-market
architecture-diagram is an agent skill that generates Mermaid flowcharts of high-level module and plugin relationships from codebase exploration.
About
architecture-diagram is an agent skill for solo builders who need a fast, accurate system map without hand-drawing every package edge in a growing repo. It pairs a structured codebase exploration step with Mermaid generation rules—top-down for hierarchies, left-right for pipelines, subgraphs by package, and a hard cap near 15–20 nodes so diagrams stay readable in READMEs and PRs. Use it during Build when documenting new plugins or services, during Ship review when reviewers need context, or during Idea/Validate when you are still mapping an unfamiliar fork. It does not replace deep security or performance analysis; it makes relationships legible so the next implementation or refactor conversation starts aligned.
- Two-step workflow: dispatch codebase-explorer agent, then emit Mermaid flowchart TD or LR
- 15–20 node cap with subgraph grouping and shape conventions for modules, entry points, and data stores
- Designed for plugin/module relationship questions and "how does this fit together" onboarding
- Explicit rules for labeled edges, aggregation of small modules, and PR-ready architecture snippets
Architecture Diagram by the numbers
- 84 all-time installs (skills.sh)
- Ranked #677 of 1,879 Documentation skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/athola/claude-night-market --skill architecture-diagramAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 84 |
|---|---|
| repo stars | ★ 325 |
| Security audit | 3 / 3 scanners passed |
| Last updated | August 2, 2026 |
| Repository | athola/claude-night-market ↗ |
What it does
Produce a capped Mermaid architecture flowchart from a codebase exploration so you can onboard, document modules, or explain structure in PRs.
Who is it for?
Best when you're documenting plugin architectures, monorepos, or agent toolchains and want Mermaid without manual graph editing.
Skip if: Deep sequence diagrams of every RPC, or production infra monitoring views that need live metrics rather than structural maps.
When should I use this skill?
Visualizing how plugins or modules relate, onboarding to system structure, or documenting architecture for PR reviews.
What you get
You get a PR- or README-ready Mermaid architecture diagram that summarizes component relationships within the skill’s node limits.
- Mermaid flowchart snippet (TD or LR)
- Grouped subgraphs with labeled relationships
By the numbers
- 15–20 nodes maximum in generated diagrams
Files
Architecture Diagram
Generate a Mermaid flowchart showing high-level component relationships in a codebase.
When To Use
- Visualizing how plugins/modules relate to each other
- Onboarding to understand system structure
- Documenting architecture for PR reviews
- Answering "how does this system fit together?"
Workflow
Step 1: Explore the Codebase
Dispatch the codebase explorer agent to analyze the scope:
Agent(cartograph:codebase-explorer)
Prompt: Explore [scope] and return a structural model.
Focus on packages, modules, and their relationships
for an architecture diagram.If no scope is provided, use the project root.
Step 2: Generate Mermaid Syntax
Transform the structural model into a Mermaid flowchart.
Rules for architecture diagrams:
- Use
flowchart TD(top-down) for hierarchical systems - Use
flowchart LR(left-right) for pipeline/flow systems - Group related modules into subgraphs by package
- Use descriptive edge labels for relationships
- Limit to 15-20 nodes maximum (aggregate small modules)
- Use shapes to distinguish component types:
[Rectangle]for modules/packages([Stadium])for entry points/commands[(Database)]for data stores{Diamond}for decision points
Example output:
flowchart TD
subgraph sanctum[Sanctum Plugin]
commit[Commit Messages]
pr[PR Preparation]
workspace[Workspace Review]
end
subgraph leyline[Leyline Plugin]
git[Git Platform]
patterns[Error Patterns]
end
commit --> git
pr --> workspace
pr --> git
workspace --> patternsStep 3: Render via MCP
Call the Mermaid Chart MCP to render:
mcp__claude_ai_Mermaid_Chart__validate_and_render_mermaid_diagram
prompt: "Architecture diagram of [scope]"
mermaidCode: [generated syntax]
diagramType: "flowchart"
clientName: "claude-code"If rendering fails, fix the Mermaid syntax based on the error message and retry (max 2 retries).
Step 4: Present Results
Show the rendered diagram to the user with a brief summary of what it depicts (2-3 sentences).
Exit Criteria
- [ ] Mermaid
flowchartsyntax generated containing at least
one subgraph block grouping related modules
- [ ]
mcp__claude_ai_Mermaid_Chart__validate_and_render_mermaid_diagram
called and returns without error (or retry attempted on first failure and result reported)
- [ ] Diagram node count is between 3 and 20 (per skill rules)
- [ ] A 2-3 sentence description of what the diagram depicts is shown
alongside the rendered output
- [ ] If the MCP render fails after 2 retries, the Mermaid syntax is
still presented as a code block with the error surfaced
Related skills
How it compares
Lightweight structural diagram generator—not a full C4 modeling suite or automatic dependency license audit.
FAQ
Who is architecture-diagram for?
Developers and small teams using Claude Code or similar agents who need onboarding diagrams and PR context for how modules relate.
When should I use architecture-diagram?
In Build docs when adding plugins, during Ship review before merge, or in Idea research when mapping an unfamiliar repo’s layout.
Is architecture-diagram safe to install?
It instructs codebase exploration and diagram output—review the Security Audits panel on this page and scope exploration to repos you trust.