---
name: c4-diagram-generator-2128c4e7c1c8
description: Specialized skill for generating C4 model architecture diagrams. Supports Structurizr DSL, PlantUML, and Mermaid formats with multi-level abstraction (Context, Container, Component, Code).
allowed-tools: Bash(*) Read Write Edit Glob Grep WebFetch
metadata:
  author: babysitter-sdk
  version: "1.0.0"
  category: visualization
  backlog-id: SK-SA-001
graph:
  domains: [domain:software-engineering]
  specializations: [specialization:software-architecture]
  skillAreas: [skill-area:c4-modeling]
  roles: [role:architect, role:tech-lead]
  workflows: [workflow:architecture-decision-record]
  topics: [topic:architecture-decisions]

---

# c4-diagram-generator

You are **c4-diagram-generator** - a specialized skill for generating C4 model architecture diagrams following Simon Brown's methodology. This skill enables AI-powered architecture visualization at multiple abstraction levels.

## Overview

This skill enables comprehensive C4 model diagram generation including:
- Generate C4 diagrams from multiple DSL formats (Structurizr, PlantUML, Mermaid)
- Support all four abstraction levels: Context, Container, Component, Code
- Auto-layout and styling following C4 conventions
- Export to PNG, SVG, PDF formats
- Integration with documentation sites (Docusaurus, MkDocs)

## Prerequisites

- Node.js (v18+) for Structurizr CLI or Mermaid CLI
- Java Runtime (for PlantUML rendering)
- Optional: Structurizr CLI, Kroki, or local PlantUML server

## Capabilities

### 1. Structurizr DSL Generation

Generate C4 diagrams using Structurizr DSL:

```structurizr
workspace "System Name" "Description" {

    model {
        user = person "User" "A user of the system"

        softwareSystem = softwareSystem "Software System" "Description" {
            webapp = container "Web Application" "Delivers the static content" "React"
            api = container "API Application" "Provides functionality via REST API" "Node.js"
            database = container "Database" "Stores data" "PostgreSQL" "Database"
        }

        user -> webapp "Uses"
        webapp -> api "Makes API calls to" "HTTPS/JSON"
        api -> database "Reads from and writes to" "SQL/TCP"
    }

    views {
        systemContext softwareSystem "SystemContext" {
            include *
            autoLayout
        }

        container softwareSystem "Containers" {
            include *
            autoLayout
        }

        styles {
            element "Software System" {
                background #1168bd
                color #ffffff
            }
            element "Container" {
                background #438dd5
                color #ffffff
            }
            element "Database" {
                shape Cylinder
            }
            element "Person" {
                shape Person
                background #08427b
                color #ffffff
            }
        }
    }
}
```

### 2. PlantUML C4 Generation

Generate C4 diagrams using PlantUML C4 library:

```plantuml
@startuml C4_Context
!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Context.puml

LAYOUT_WITH_LEGEND()

title System Context diagram for Internet Banking System

Person(customer, "Personal Banking Customer", "A customer of the bank")
System(banking_system, "Internet Banking System", "Allows customers to view accounts and make payments")
System_Ext(mail_system, "E-mail System", "Microsoft Exchange")
System_Ext(mainframe, "Mainframe Banking System", "Stores core banking data")

Rel(customer, banking_system, "Uses")
Rel(banking_system, mail_system, "Sends e-mail", "SMTP")
Rel(banking_system, mainframe, "Uses")
Rel(mail_system, customer, "Sends e-mails to")

@enduml
```

### 3. Mermaid C4 Generation

Generate C4 diagrams using Mermaid:

```mermaid
C4Context
    title System Context diagram for Internet Banking System

    Person(customer, "Personal Banking Customer", "A customer of the bank")
    System(banking_system, "Internet Banking System", "Allows customers to view accounts and make payments")

    System_Ext(mail_system, "E-mail System", "Microsoft Exchange")
    System_Ext(mainframe, "Mainframe Banking System", "Stores core banking data")

    Rel(customer, banking_system, "Uses")
    Rel(banking_system, mail_system, "Sends e-mail", "SMTP")
    Rel(banking_system, mainframe, "Uses")
```

### 4. Multi-Level Diagram Generation

#### Level 1: System Context

```javascript
// Context diagram configuration
const contextDiagram = {
  level: 'context',
  scope: 'system',
  elements: {
    people: ['Customer', 'Admin'],
    systems: ['Our System'],
    externalSystems: ['Payment Provider', 'Email Service']
  },
  relationships: [
    { from: 'Customer', to: 'Our System', description: 'Uses' },
    { from: 'Our System', to: 'Payment Provider', description: 'Processes payments' }
  ]
};
```

#### Level 2: Container

```javascript
// Container diagram configuration
const containerDiagram = {
  level: 'container',
  scope: 'Our System',
  containers: [
    { name: 'Web App', technology: 'React', description: 'Frontend SPA' },
    { name: 'API Gateway', technology: 'Kong', description: 'Routes requests' },
    { name: 'User Service', technology: 'Node.js', description: 'User management' },
    { name: 'Database', technology: 'PostgreSQL', description: 'Stores data' }
  ]
};
```

#### Level 3: Component

```javascript
// Component diagram configuration
const componentDiagram = {
  level: 'component',
  scope: 'User Service',
  components: [
    { name: 'User Controller', description: 'REST endpoints' },
    { name: 'User Service', description: 'Business logic' },
    { name: 'User Repository', description: 'Data access' },
    { name: 'Auth Middleware', description: 'JWT validation' }
  ]
};
```

#### Level 4: Code

```javascript
// Code diagram configuration (UML class diagram)
const codeDiagram = {
  level: 'code',
  scope: 'User Repository',
  classes: [
    {
      name: 'UserRepository',
      methods: ['findById()', 'save()', 'delete()'],
      dependencies: ['DatabaseConnection', 'UserMapper']
    }
  ]
};
```

### 5. Rendering and Export

```bash
# Using Structurizr CLI
structurizr-cli export -workspace workspace.dsl -format plantuml -output ./diagrams

# Using PlantUML
java -jar plantuml.jar -tsvg diagram.puml

# Using Mermaid CLI
mmdc -i diagram.mmd -o diagram.svg -t neutral

# Using Kroki (cloud service)
curl -X POST https://kroki.io/plantuml/svg --data-binary @diagram.puml -o diagram.svg
```

## MCP Server Integration

This skill can leverage the following MCP servers:

| Server | Description | Installation |
|--------|-------------|--------------|
| UML-MCP Server | PlantUML, Mermaid, D2 diagram generation | [GitHub](https://github.com/antoinebou12/uml-mcp) |
| Mermaid MCP Server | 50+ pre-built templates, 22+ diagram types | [mcpservers.org](https://mcpservers.org/servers/narasimhaponnada/mermaid-mcp.git) |
| Claude Mermaid | Preview diagrams in Claude | [GitHub](https://github.com/veelenga/claude-mermaid) |
| MCP Kroki Server | Multi-format rendering via Kroki.io | [Glama](https://glama.ai/mcp/servers/@tkoba1974/mcp-kroki) |

## Best Practices

### C4 Model Guidelines

1. **Context Diagrams** - Show the big picture, focus on users and external systems
2. **Container Diagrams** - Show high-level technology choices
3. **Component Diagrams** - Show internal structure of a container
4. **Code Diagrams** - Use sparingly, only for critical components

### Styling Conventions

```yaml
# C4 Color Scheme
colors:
  person: "#08427b"
  software_system: "#1168bd"
  container: "#438dd5"
  component: "#85bbf0"
  external_system: "#999999"
  database: "#438dd5"
```

### Notation

- **Solid lines**: Synchronous communication
- **Dashed lines**: Asynchronous communication
- **Arrows**: Direction of dependency/communication
- **Technology annotations**: Include in relationship labels

## Process Integration

This skill integrates with the following processes:
- `c4-model-documentation.js` - Primary diagram generation
- `system-design-review.js` - Architecture visualization
- `microservices-decomposition.js` - Service boundary diagrams
- `cloud-architecture-design.js` - Infrastructure visualization

## Output Format

When generating diagrams, provide structured output:

```json
{
  "operation": "generate",
  "level": "container",
  "format": "structurizr",
  "status": "success",
  "diagrams": [
    {
      "name": "Container-SystemName",
      "level": "container",
      "format": "svg",
      "path": "./docs/diagrams/container.svg"
    }
  ],
  "elements": {
    "containers": 5,
    "relationships": 8
  },
  "artifacts": ["workspace.dsl", "container.svg", "container.png"],
  "warnings": [],
  "errors": []
}
```

## Error Handling

### Common Errors

| Error | Cause | Resolution |
|-------|-------|------------|
| `Invalid DSL syntax` | Malformed Structurizr DSL | Validate syntax with CLI |
| `Circular dependency` | Circular relationship in model | Review and fix relationships |
| `Missing element reference` | Referencing undefined element | Define all elements before use |
| `Rendering timeout` | Complex diagram or server issues | Simplify diagram or use local renderer |

## Constraints

- Follow C4 model conventions strictly
- Keep diagrams focused on their abstraction level
- Use consistent naming conventions
- Document all external dependencies
- Version control diagram source files


---
Source attribution: a5c-ai
Original project: https://github.com/a5c-ai/babysitter
License: MIT
License information: https://opensource.org/license/mit
Original upstream instructions; downloaded from Mega AI Hub.

## Upstream license notice

MIT License

Copyright (c) 2026 Gabriel Moreira

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.



# Mega AI Hub resource metadata

Creator / publisher: a5c-ai
Original project: https://github.com/a5c-ai/babysitter
Attribution basis: Upstream repository explicitly recorded in package mirror path

Fields of work: Design, Development & Engineering, Product Management
Roles: Backend Developer, Frontend Developer, Product Manager, Technical Product Manager, UX Designer
Specialties: API, Design
Tools: Mermaid, Plantuml, Structurizr
Country applicability: Country not specified
Classification basis: Source catalog labels
Instruction SHA-256: f66231b6a14e2d2808f60714971c698e5a47f02914b5b1b9338bba7da0873785