c4-modeling

C4 architectural modeling for documenting software architecture. Use when creating architecture diagrams, planning new systems, communicating with stakeholders, or conducting architecture reviews.

25 stars

Best use case

c4-modeling is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

C4 architectural modeling for documenting software architecture. Use when creating architecture diagrams, planning new systems, communicating with stakeholders, or conducting architecture reviews.

Teams using c4-modeling should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/c4-modeling/SKILL.md --create-dirs "https://raw.githubusercontent.com/ComeOnOliver/skillshub/main/skills/aiskillstore/marketplace/consiliency/c4-modeling/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/c4-modeling/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How c4-modeling Compares

Feature / Agentc4-modelingStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

C4 architectural modeling for documenting software architecture. Use when creating architecture diagrams, planning new systems, communicating with stakeholders, or conducting architecture reviews.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# C4 Modeling Skill

Create hierarchical architecture diagrams at four abstraction levels using the C4 model and Mermaid syntax.

## Variables

| Variable | Default | Description |
|----------|---------|-------------|
| DEFAULT_LEVEL | context | Start with `context`, `container`, `component`, or `code` |
| OUTPUT_FORMAT | mermaid | `mermaid`, `structurizr`, `plantuml` |
| INCLUDE_LEGEND | true | Add legend to diagrams |

## Instructions

**MANDATORY** - Follow the Workflow steps below when creating C4 diagrams.

- Always start at Level 1 (Context) and zoom in as needed
- Never mix abstraction levels in a single diagram
- Include descriptions for all elements

## Red Flags - STOP and Reconsider

If you're about to:
- Create a container diagram without first creating a context diagram
- Mix containers and components in the same diagram
- Show implementation details at the context level
- Create a code-level diagram for non-critical code

**STOP** -> Check the appropriate level guidelines in `reference/level-guidelines.md` -> Then proceed

## Workflow

1. [ ] Determine the audience and purpose
2. [ ] **CHECKPOINT**: Start at Level 1 (Context) unless you have higher-level diagrams
3. [ ] Identify all actors and systems at current level
4. [ ] Define relationships with labeled arrows
5. [ ] Add technology choices (for Level 2+)
6. [ ] **CHECKPOINT**: Verify you haven't mixed abstraction levels
7. [ ] Include descriptions for clarity

## C4 Levels

| Level | Name | Purpose | Audience |
|-------|------|---------|----------|
| 1 | Context | System in environment | Everyone |
| 2 | Container | Major components | Technical stakeholders |
| 3 | Component | Internal structure | Developers |
| 4 | Code | Implementation | Developers (sparingly) |

## Quick Reference

### Level 1: Context

Show: System, users, external systems
Hide: Internal details, databases, technology

### Level 2: Container

Show: Applications, APIs, databases, queues
Hide: Internal structure, classes

### Level 3: Component

Show: Modules, services, repositories
Hide: Individual classes, functions

### Level 4: Code

Show: Classes, interfaces, key abstractions
Use: Only for complex/critical areas

See `reference/level-guidelines.md` for detailed guidance.
See `reference/mermaid-syntax.md` for Mermaid C4 syntax.

## Mermaid Quick Syntax

```mermaid
C4Context
    title System Context Diagram
    Person(user, "User", "Description")
    System(system, "System", "Description")
    System_Ext(ext, "External", "Description")
    Rel(user, system, "Uses")
```

```mermaid
C4Container
    title Container Diagram
    Container(web, "Web App", "React", "UI")
    Container(api, "API", "Node.js", "Backend")
    ContainerDb(db, "Database", "PostgreSQL", "Storage")
    Rel(web, api, "Calls", "REST")
```

See `reference/mermaid-syntax.md` for complete syntax reference.

## Output

Diagrams should include:
1. Title indicating level and system
2. All relevant elements with descriptions
3. Labeled relationships
4. Technology choices (Level 2+)
5. Clear boundaries for grouping

Related Skills

modeling-nosql-data

25
from ComeOnOliver/skillshub

This skill enables Claude to design NoSQL data models. It activates when the user requests assistance with NoSQL database design, including schema creation, data modeling for MongoDB or DynamoDB, or defining document structures. Use this skill when the user mentions "NoSQL data model", "design MongoDB schema", "create DynamoDB table", or similar phrases related to NoSQL database architecture. It assists in understanding NoSQL modeling principles like embedding vs. referencing, access pattern optimization, and sharding key selection.

powerbi-modeling

25
from ComeOnOliver/skillshub

Power BI semantic modeling assistant for building optimized data models. Use when working with Power BI semantic models, creating measures, designing star schemas, configuring relationships, implementing RLS, or optimizing model performance. Triggers on queries about DAX calculations, table relationships, dimension/fact table design, naming conventions, model documentation, cardinality, cross-filter direction, calculation groups, and data model best practices. Always connects to the active model first using power-bi-modeling MCP tools to understand the data structure before providing guidance.

cosmosdb-datamodeling

25
from ComeOnOliver/skillshub

Step-by-step guide for capturing key application requirements for NoSQL use-case and produce Azure Cosmos DB Data NoSQL Model design using best practices and common patterns, artifacts_produced: "cosmosdb_requirements.md" file and "cosmosdb_data_model.md" file

threat-modeling-expert

25
from ComeOnOliver/skillshub

Expert in threat modeling methodologies, security architecture review, and risk assessment. Masters STRIDE, PASTA, attack trees, and security requirement extraction. Use for security architecture reviews, threat identification, and secure-by-design planning.

startup-financial-modeling

25
from ComeOnOliver/skillshub

This skill should be used when the user asks to "create financial projections", "build a financial model", "forecast revenue", "calculate burn rate", "estimate runway", "model cash flow", or requests 3-5 year financial planning for a startup.

PyMC Bayesian Modeling

25
from ComeOnOliver/skillshub

Bayesian modeling with PyMC. Build hierarchical models, MCMC (NUTS), variational inference, LOO/WAIC comparison, posterior checks, for probabilistic programming and inference.

Blender 3D Modeling

25
from ComeOnOliver/skillshub

## Overview

Statsmodels: Statistical Modeling and Econometrics

25
from ComeOnOliver/skillshub

## Overview

ESM: Evolutionary Scale Modeling

25
from ComeOnOliver/skillshub

## Overview

Daily Logs

25
from ComeOnOliver/skillshub

Record the user's daily activities, progress, decisions, and learnings in a structured, chronological format.

Socratic Method: The Dialectic Engine

25
from ComeOnOliver/skillshub

This skill transforms Claude into a Socratic agent — a cognitive partner who guides

Sokratische Methode: Die Dialektik-Maschine

25
from ComeOnOliver/skillshub

Dieser Skill verwandelt Claude in einen sokratischen Agenten — einen kognitiven Partner, der Nutzende durch systematisches Fragen zur Wissensentdeckung führt, anstatt direkt zu instruieren.