From documentation
Creates in-depth explanatory documentation for complex concepts, design decisions, and system architecture. Also supports topic scoping and context research.
How this command is triggered — by the user, by Claude, or both
Slash command
/documentation:docs-explanation [concept to explain] [--architecture|--design|--theory|--comparison]The summary Claude sees in its command listing — used to decide when to auto-load this command
# Diataxis Explanation Command You are in the **EXPLANATION** phase of the Diataxis documentation workflow. Your mission is to create understanding-oriented documentation that provides context, background, and deeper insights into concepts, designs, and decisions. ⚠️ **IMPORTANT**: This command is for creating EXPLANATORY documentation ONLY. Focus exclusively on: - Providing conceptual understanding and context - Explaining the "why" behind decisions - Discussing alternatives and trade-offs - Offering broader perspectives and connections - Documenting everything in `docs/explanation/[topi...
You are in the EXPLANATION phase of the Diataxis documentation workflow. Your mission is to create understanding-oriented documentation that provides context, background, and deeper insights into concepts, designs, and decisions.
⚠️ IMPORTANT: This command is for creating EXPLANATORY documentation ONLY. Focus exclusively on:
docs/explanation/[topic-slug].md$ARGUMENTS
If no specific concept was provided above, ask the user: "What concept, architecture, or design decision would you like explained in depth?"
Deploy concurrent documentation specialists: @docs-explanation-agent @architecture-documenter @system-designer @business-analyst
All subagents work in parallel to create comprehensive explanations:
## About [Topic]
### Overview
[High-level introduction to the concept]
### Why This Matters
- [Business impact]
- [Technical significance]
- [User benefits]
### Scope of This Explanation
This document explains:
- [Aspect 1]
- [Aspect 2]
- [Aspect 3]
This document does not cover:
- [Out of scope 1]
- [Out of scope 2]
## Background and Context
### Historical Perspective
[How we got here - evolution of the concept]
### Current State
[Where we are now - current implementation/understanding]
### Industry Context
[How others approach this - standards and practices]
### Our Approach
[Why we chose this path - specific context]
## Understanding [Core Concept]
### The Fundamental Idea
[Explain the core concept in simple terms]
### Analogy
Think of [concept] like [familiar analogy]. Just as [analogy explanation],
[concept] works by [parallel explanation].
### Key Principles
1. **Principle 1**: [Explanation]
- Why it matters
- How it works
- Implications
2. **Principle 2**: [Explanation]
- Why it matters
- How it works
- Implications
### Mental Model
[Visual or conceptual model] Component A → Process → Component B ↓ ↓ Storage Output
## Design Decisions and Trade-offs
### Decision: [Specific Choice Made]
#### Options Considered
1. **Option A** (Chosen)
- Pros: [Benefits]
- Cons: [Drawbacks]
- Why chosen: [Reasoning]
2. **Option B**
- Pros: [Benefits]
- Cons: [Drawbacks]
- Why not: [Reasoning]
3. **Option C**
- Pros: [Benefits]
- Cons: [Drawbacks]
- Why not: [Reasoning]
#### Trade-offs Accepted
- We prioritized [quality] over [quality]
- We accepted [limitation] to gain [benefit]
- We chose [approach] knowing [consequence]
#### Future Considerations
- This decision allows for [future possibility]
- We may revisit if [condition changes]
- Migration path exists to [alternative]
## How This Relates to Other Concepts
### Relationship to [Related Concept 1]
[Explain connection and interaction]
### Relationship to [Related Concept 2]
[Explain connection and interaction]
### Part of Larger System
[Broader Context] ├── [This Concept] ├── [Related System] └── [Connected Component]
### Dependencies
- Depends on: [What this needs]
- Depended on by: [What needs this]
- Interfaces with: [What it connects to]
All explanation documentation will be generated in the docs/explanation/ directory with descriptive filenames based on the concept being explained.
# Understanding [Topic]
## Introduction
[Accessible introduction that draws readers in]
## The Big Picture
[Context and significance in the broader landscape]
## Core Concepts
### What Is [Concept]?
[Clear, accessible explanation]
### Why [Concept] Exists
[Problem it solves, need it addresses]
### How [Concept] Works
[Conceptual overview, not implementation details]
## Design Philosophy
### Guiding Principles
[What drives the design]
### Architectural Decisions
[Key choices and their rationale]
### Trade-offs
[What we optimized for vs. what we sacrificed]
## Alternatives and Comparisons
### Alternative Approaches
[Other ways to solve the same problem]
### When to Use Which
[Decision framework for choosing approaches]
### Evolution and History
[How approaches have evolved]
## Practical Implications
### Impact on Development
[How this affects day-to-day work]
### Impact on Users
[How this affects end users]
### Impact on Operations
[How this affects deployment and maintenance]
## Common Misconceptions
### Misconception 1: [Statement]
**Reality**: [Correction and explanation]
### Misconception 2: [Statement]
**Reality**: [Correction and explanation]
## Future Directions
### Current Limitations
[Honest assessment of current state]
### Planned Improvements
[Roadmap and vision]
### Industry Trends
[Where the field is heading]
## Summary
[Key takeaways and main points]
## Further Reading
- [Related explanation documents]
- [External resources]
- [Academic papers or industry articles]
Before finalizing explanation documentation:
# Basic explanation creation
/diataxis-explanation "microservices architecture"
# Specify explanation type
/diataxis-explanation "database design" --architecture
/diataxis-explanation "algorithm choice" --design
/diataxis-explanation "CAP theorem" --theory
/diataxis-explanation "REST vs GraphQL" --comparison
# Specific concepts
/diataxis-explanation "event-driven architecture"
/diataxis-explanation "zero-trust security model"
Tutorial → How-to → Reference → Explanation (You are here)
Doing → Achieving → Looking up → Understanding deeply
## Understanding Our Architecture
### Why This Architecture?
[Problems it solves]
### Core Design Principles
[What guides decisions]
### Component Relationships
[How parts work together]
### Evolution Story
[How we got here]
## The [Pattern Name] Pattern
### Problem It Solves
[Context and challenge]
### How It Works
[Conceptual mechanism]
### When to Use It
[Appropriate contexts]
### Trade-offs
[Benefits vs. costs]
## Why We Chose [Technology]
### Requirements That Led Here
[What we needed]
### Alternatives Considered
[What else we looked at]
### Decision Factors
[What tipped the scales]
### Living with the Choice
[Experience and lessons]
## Understanding [Model]
### Mental Model
[How to think about it]
### Real-World Analogy
[Familiar comparison]
### Key Insights
[Aha moments]
### Common Pitfalls
[Misconceptions to avoid]
Upon completion, generate docs/explanation/[topic-slug].md containing:
Remember: Your job is to deepen understanding and provide the "why" behind everything!
🚫 DO NOT: Provide instructions, list specifications, avoid complexity ✅ DO: Explain concepts, discuss trade-offs, provide context, make connections
2plugins reuse this command
First indexed Dec 31, 2025
npx claudepluginhub smartnews/guidance-for-claude-code-with-amazon-bedrock --plugin documentation/explainExplains code, concepts, or system behavior with adaptive depth, persona-based roles, and MCP integration for accurate educational explanations.
/sc-explainExplains code, concepts, and system behavior with multi-persona educational clarity. Supports --level, --format, and --context arguments for tailored explanations.
/write-rationaleGenerates a structured design rationale document: identifies key decisions, documents alternatives and evidence, and formats for handoff or presentation.
/explainExplains code, concepts, or architectures with adjustable depth from beginner to expert, covering big picture, component breakdown, execution flow, and design patterns.
/explainProvides detailed, customized explanations of code, architecture, or concepts in the codebase, saving output as markdown reports.