arch-lens-deployment
Skill1 starsChanged 8 months agoMITView on GitHub
Create Deployment/Physical architecture diagram showing infrastructure topology, process boundaries, and network communication. Physical lens answering "Where does it run?
In this repository59 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- arch-lens-c4-containerSkill
- arch-lens-concurrencySkill
- arch-lens-data-lineageSkill
- arch-lens-developmentSkill
- arch-lens-error-resilienceSkill
- arch-lens-module-dependencySkill
- arch-lens-operationalSkill
- arch-lens-process-flowSkill
- arch-lens-repository-accessSkill
- arch-lens-scenariosSkill
- arch-lens-securitySkill
- arch-lens-state-lifecycleSkill
- audit-archSkill
- audit-bugsSkill
- audit-cohesionSkill
- audit-defense-standardsSkill
- audit-frictionSkill
- audit-implSkill
- audit-testsSkill
- design-guardsSkill
- dry-walkthroughSkill
- elaborate-phaseSkill
- exp-lens-benchmark-representativenessSkill
- exp-lens-causal-assumptionsSkill
- exp-lens-comparator-constructionSkill
- exp-lens-error-budgetSkill
- exp-lens-estimand-claritySkill
- exp-lens-exploratory-confirmatorySkill
- exp-lens-fair-comparisonSkill
- exp-lens-governance-riskSkill
- exp-lens-iterative-learningSkill
- exp-lens-measurement-validitySkill
- exp-lens-pipeline-integritySkill
- exp-lens-randomization-blockingSkill
- exp-lens-reproducibility-artifactsSkill
- exp-lens-sensitivity-robustnessSkill
- exp-lens-severity-testingSkill
- exp-lens-unit-interferenceSkill
- exp-lens-validity-threatsSkill
- exp-lens-variance-stabilitySkill
- id-slopSkill
- implement-worktreeSkill
- investigateSkill
- make-arch-diagSkill
- make-experiment-diagSkill
- make-groupsSkill
- make-planSkill
- make-reqSkill
- make-scenariosSkill
- mermaidSkill
- plan-arcSkill
- rectifySkill
- review-approachSkill
- update-architectureSkill
- update-reqsSkill
- update-specsSkill
- verify-diagSkill
- verify-proposed-diagSkill
The file
We split this skill into the rules it gives an agent
9 rules. About 0 are common, 6 are distinctive, and 3 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈6
Distinctive · estimate
This author's own choices. Worth a look.
3
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 38
BEFORE creating any diagram, LOAD the /mermaid skill using the Skill tool - this is MANDATORY
- Distinctive: line 51
Look for: main, entry_points, subprocess, process spawning, daemon processes
- Very specific: line 56
Look for: Dockerfile, docker-compose.yml, container definitions, Kubernetes configs
- Distinctive: line 61
Look for: data directories, database files, storage volumes, persistent storage
- Distinctive: line 66
Look for: port, bind, listen, server, API, endpoint, network services
- Distinctive: line 71
Look for: external APIs, cloud services, third-party integrations
- Distinctive: line 76
Look for: web servers, frontend builds, static assets, CDN
- Very specific: line 131
Write the diagram to: temp/arch-lens-deployment/arch_diag_deployment_{YYYY-MM-DD_HHMMSS}.md
- Distinctive: line 235
Before creating the diagram, verify:
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Deployment/Physical Architecture Lens
Cognitive Mode: Physical Primary Question: "Where does it run?" Focus: Infrastructure Topology, Process Boundaries, Data Storage Locations, Network Communication
When to Use
- Need to understand physical deployment
- Documenting infrastructure and processes
- Analyzing where components execute
- User invokes
/arch-lens-deploymentor/make-arch-diag deployment
Critical Constraints
NEVER:
- Modify any source code files
- Include code-level details
- Show internal logic
ALWAYS:
- Focus on PHYSICAL deployment
- Show process boundaries
- Include network/communication protocols
- Document storage locations
- BEFORE creating any diagram, LOAD the
/mermaidskill using the Skill tool - this is MANDATORY
Analysis Workflow
Step 1: Launch Parallel Exploration Subagents
Spawn Explore subagents to investigate:
Process Boundaries
- Find main process entry points
- Identify subprocess spawning
- Look for: main, entry_points, subprocess, process spawning, daemon processes
Container/Docker
- Find containerization config
- Identify services
- Look for: Dockerfile, docker-compose.yml, container definitions, Kubernetes configs
Local Storage
- Find file storage locations
- Identify database paths
- Look for: data directories, database files, storage volumes, persistent storage
Network Services
- Find service definitions
- Identify ports and protocols
- Look for: port, bind, listen, server, API, endpoint, network services
External Services
- Find external API calls
- Identify cloud services
- Look for: external APIs, cloud services, third-party integrations
Web/Frontend
- Find frontend deployment
- Identify static file serving
- Look for: web servers, frontend builds, static assets, CDN
Step 2: Map Physical Topology
| Component | Location | Technology | Port/Protocol |
| {name} | {where} | {tech} | {port/protocol} |
CRITICAL - Analyze Read/Write Direction: For EVERY process and storage location:
- Reads from: What does this process READ? (files, databases, APIs)
- Writes to: What does this process WRITE? (files, databases, APIs)
- Network direction: Client->Server or bidirectional?
For storage locations:
- Read/write storage: Process both reads and writes (databases, state files)
- Write-only storage: Process writes, humans or other systems read (logs, artifacts)
- Read-only sources: Process reads, doesn't modify (config, external APIs)
Label all connections with direction (reads, writes, or both)
Step 3: Identify Communication Paths
- Process-to-process (IPC, subprocess)
- Network (HTTP, WebSocket, gRPC)
- File system (shared files)
- Database (connections)
Step 4: Create the Diagram
Use flowchart with:
Direction: TB for infrastructure layers
Subgraphs by Physical Location:
- Developer Machine (local processes)
- Local Storage (files, DBs)
- Docker Stack (if containerized)
- Web Stack (if applicable)
- External Services (cloud, APIs)
Node Styling:
cliclass: Main processesstateNodeclass: Local storage, databasesoutputclass: File artifactshandlerclass: Services, APIsphaseclass: Frontend, web UIintegrationclass: External services
Connection Labels:
- Show protocols (HTTP, subprocess, file)
- Show ports where relevant
Step 5: Write Output
Write the diagram to: temp/arch-lens-deployment/arch_diag_deployment_{YYYY-MM-DD_HHMMSS}.md
Output Template
# Deployment Diagram: {System Name}
**Lens:** Deployment/Physical
**Question:** Where does it run?
**Date:** {YYYY-MM-DD}
**Scope:** {What was analyzed}
## Deployment Topology
| Component | Port | Technology | Purpose |
|-----------|------|------------|---------|
| {name} | {port} | {tech} | {purpose} |
## Deployment Diagram
```mermaid
%%{init: {'flowchart': {'nodeSpacing': 50, 'rankSpacing': 60, 'curve': 'basis'}}}%%
flowchart TB
%% CLASS DEFINITIONS %%
classDef cli fill:#1a237e,stroke:#7986cb,stroke-width:2px,color:#fff;
classDef stateNode fill:#004d40,stroke:#4db6ac,stroke-width:2px,color:#fff;
classDef handler fill:#e65100,stroke:#ffb74d,stroke-width:2px,color:#fff;
classDef phase fill:#6a1b9a,stroke:#ba68c8,stroke-width:2px,color:#fff;
classDef output fill:#00695c,stroke:#4db6ac,stroke-width:2px,color:#fff;
classDef integration fill:#c62828,stroke:#ef9a9a,stroke-width:2px,color:#fff;
subgraph LocalMachine ["LOCAL MACHINE"]
direction TB
MAIN["Main Process<br/>━━━━━━━━━━<br/>Runtime<br/>Orchestration"]
SUB["Subprocess<br/>━━━━━━━━━━<br/>Isolated execution"]
end
subgraph LocalStorage ["LOCAL STORAGE"]
direction TB
DB[("Database<br/>━━━━━━━━━━<br/>Technology<br/>Location")]
FILES["Files<br/>━━━━━━━━━━<br/>Artifacts<br/>Path"]
end
subgraph Docker ["DOCKER STACK"]
direction TB
SERVICE1["Service<br/>━━━━━━━━━━<br/>:port<br/>Purpose"]
end
subgraph Web ["WEB STACK"]
direction TB
API["API Server<br/>━━━━━━━━━━<br/>:port<br/>Protocol"]
FRONTEND["Frontend<br/>━━━━━━━━━━<br/>:port<br/>Technology"]
end
subgraph External ["EXTERNAL"]
direction TB
CLOUD["Cloud API<br/>━━━━━━━━━━<br/>Protocol<br/>Third-party"]
end
%% CONNECTIONS %%
MAIN -->|"spawns"| SUB
MAIN -->|"reads/writes"| DB
MAIN -->|"writes"| FILES
MAIN -->|"HTTPS"| CLOUD
SERVICE1 -->|"connects"| DB
API -->|"REST"| FRONTEND
%% CLASS ASSIGNMENTS %%
class MAIN,SUB cli;
class DB,FILES stateNode;
class SERVICE1,API handler;
class FRONTEND phase;
class CLOUD integration;Color Legend:
| Color | Category | Description |
| Dark Blue | Processes | Local CLI and subprocess |
| Teal | Storage | Databases and file storage |
| Orange | Services | Backend services and APIs |
| Purple | Frontend | Web UI |
| Red | External | External/cloud services |
Communication Protocols
| From | To | Protocol | Purpose |
| {source} | {target} | {protocol} | {purpose} |
Storage Locations
| Data | Location | Technology |
| {data} | {path} | {tech} |
---
## Pre-Diagram Checklist
Before creating the diagram, verify:
- [ ] LOADED `/mermaid` skill using the Skill tool
- [ ] Using ONLY classDef styles from the mermaid skill (no invented colors)
- [ ] Diagram will include a color legend table
---
## Related Skills
- `/make-arch-diag` - Parent skill for lens selection
- `/mermaid` - MUST BE LOADED before creating diagram
- `/arch-lens-c4-container` - For container-level viewDoes it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

