PluginBench
Skill
Pass
Audit score 90

architecture-diagrams

aj-geddes/useful-ai-prompts

Create system architecture diagrams using Mermaid, PlantUML, and C4 models for design documentation.

What is architecture-diagrams?

Generate code-based architecture diagrams for system design, data flows, and technical workflows. Use this skill when documenting microservices, deployment architecture, component relationships, or integration patterns.

  • Create system architecture diagrams with multiple layers (client, API, service, data)
  • Generate sequence diagrams for interaction flows
  • Build C4 model diagrams for context and component views
  • Design data flow and deployment diagrams
  • Produce class and component relationship diagrams
  • Support Mermaid and PlantUML syntax

How to install architecture-diagrams

npx skills add https://github.com/aj-geddes/useful-ai-prompts --skill architecture-diagrams
Claude Code
Cursor
Windsurf
Cline

How to use architecture-diagrams

  1. 1.Choose your diagram type (system architecture, sequence, C4, data flow, deployment, or class diagram)
  2. 2.Use Mermaid or PlantUML syntax to define your diagram structure
  3. 3.Define layers or components using subgraphs and nodes
  4. 4.Add connections and labels to show relationships and data flow
  5. 5.Include titles, legends, and descriptions for clarity
  6. 6.Version control your diagram code alongside your documentation

Use cases

Good for
  • Document microservices architecture with service dependencies
  • Visualize API gateway and authentication flows in system design
  • Create C4 context diagrams for stakeholder communication
  • Map data flow between databases, caches, and message queues
  • Design deployment architecture across infrastructure environments
Who it's for
  • Software architects
  • Backend engineers
  • DevOps engineers
  • Technical leads
  • System designers

architecture-diagrams FAQ

What diagram types are supported?

System architecture, sequence diagrams, C4 context/component diagrams, data flow diagrams, deployment diagrams, class diagrams, and component relationship diagrams.

Should I use Mermaid or PlantUML?

Both are supported. Mermaid is simpler and integrates well with GitHub/GitLab. PlantUML offers more advanced features for complex diagrams.

How do I keep diagrams synchronized with code?

Store diagram definitions as text files in version control alongside your code, and update them during architecture reviews or when system design changes.

Can I include multiple abstraction levels in one diagram?

No—best practice is to keep diagrams focused on one aspect. Use separate diagrams for different abstraction levels (e.g., system overview vs. component details).

What should I include in architecture diagrams?

Use consistent notation, include legends for complex diagrams, show data flow direction clearly, add titles and descriptions, and document all relationships between components.

Full instructions (SKILL.md)

Source of truth, from aj-geddes/useful-ai-prompts.


name: architecture-diagrams description: > Create system architecture diagrams using Mermaid, PlantUML, C4 model, flowcharts, and sequence diagrams. Use when documenting architecture, system design, data flows, or technical workflows.

Architecture Diagrams

Table of Contents

Overview

Create clear, maintainable architecture diagrams using code-based diagramming tools like Mermaid and PlantUML for system design, data flows, and technical documentation.

When to Use

  • System architecture documentation
  • C4 model diagrams
  • Data flow diagrams
  • Sequence diagrams
  • Component relationships
  • Deployment diagrams
  • Infrastructure architecture
  • Microservices architecture
  • Database schemas (visual)
  • Integration patterns

Quick Start

Minimal working example:

graph TB
    subgraph "Client Layer"
        Web[Web App]
        Mobile[Mobile App]
        CLI[CLI Tool]
    end

    subgraph "API Gateway Layer"
        Gateway[API Gateway<br/>Rate Limiting<br/>Authentication]
    end

    subgraph "Service Layer"
        Auth[Auth Service]
        User[User Service]
        Order[Order Service]
        Payment[Payment Service]
        Notification[Notification Service]
    end

    subgraph "Data Layer"
        UserDB[(User DB<br/>PostgreSQL)]
        OrderDB[(Order DB<br/>PostgreSQL)]
        Cache[(Redis Cache)]
        Queue[Message Queue<br/>RabbitMQ]
    end
// ... (see reference guides for full implementation)

Reference Guides

Detailed implementations in the references/ directory:

GuideContents
System Architecture DiagramSystem Architecture Diagram
Sequence DiagramSequence Diagram
C4 Context DiagramC4 Context Diagram
Component DiagramComponent Diagram
Deployment DiagramDeployment Diagram
Data Flow DiagramData Flow Diagram
Class DiagramClass Diagram
Component DiagramComponent Diagram
Deployment DiagramDeployment Diagram

Best Practices

✅ DO

  • Use consistent notation and symbols
  • Include legends for complex diagrams
  • Keep diagrams focused on one aspect
  • Use color coding meaningfully
  • Include titles and descriptions
  • Version control your diagrams
  • Use text-based formats (Mermaid, PlantUML)
  • Show data flow direction clearly
  • Include deployment details
  • Document diagram conventions
  • Keep diagrams up-to-date with code
  • Use subgraphs for logical grouping

❌ DON'T

  • Overcrowd diagrams with details
  • Use inconsistent styling
  • Skip diagram legends
  • Create binary image files only
  • Forget to document relationships
  • Mix abstraction levels in one diagram
  • Use proprietary formats