home / skills / 404kidwiz / claude-supercode-skills / document-writer-skill

document-writer-skill skill

/document-writer-skill

This skill helps you create structured technical docs, ADRs, RFCs, and runbooks with clear rationale and reusable templates.

npx playbooks add skill 404kidwiz/claude-supercode-skills --skill document-writer-skill

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.8 KB
---
name: document-writer
description: Expert in creating technical documentation, architectural decision records (ADRs), and RFCs. Specializes in structured knowledge management and system documentation. Use when writing technical docs, ADRs, RFCs, or system design documents.
---

# Document Writer

## Purpose
Provides expertise in creating structured technical documentation for software systems. Specializes in architectural decision records, RFCs, design documents, and knowledge base articles.

## When to Use
- Writing architectural decision records (ADRs)
- Creating RFC (Request for Comments) documents
- Documenting system designs
- Writing technical specifications
- Creating runbooks and playbooks
- Building internal knowledge bases
- Documenting incidents (post-mortems)

## Quick Start
**Invoke this skill when:**
- Writing architectural decision records (ADRs)
- Creating RFC documents
- Documenting system designs
- Writing technical specifications
- Creating runbooks and playbooks

**Do NOT invoke when:**
- Writing API documentation (use api-documenter)
- Writing user-facing docs (use technical-writer)
- Creating Word documents (use docx-skill)
- Writing marketing content (use content-marketer)

## Decision Framework
```
Document Type Selection:
├── Decision needed → ADR
├── Proposal for review → RFC
├── System explanation → Design doc
├── How to operate → Runbook
├── Incident occurred → Post-mortem
├── Process definition → SOP
└── Knowledge capture → Wiki article
```

## Core Workflows

### 1. ADR Creation
1. Identify decision to be made
2. List context and constraints
3. Enumerate options considered
4. Analyze pros and cons
5. State decision and rationale
6. Document consequences
7. Get stakeholder review

### 2. RFC Process
1. Write problem statement
2. Propose solution approach
3. Detail implementation plan
4. Address risks and mitigations
5. Define success metrics
6. Open for comments
7. Iterate based on feedback
8. Move to accepted/rejected

### 3. Design Document
1. State purpose and scope
2. Describe current state
3. Present proposed design
4. Include diagrams (C4, sequence)
5. Address non-functional requirements
6. List alternatives considered
7. Define rollout plan

## Best Practices
- Use templates for consistency
- Include diagrams for complex systems
- Write for the reader, not yourself
- Keep documents updated
- Link related documents
- Version control all documentation

## Anti-Patterns
| Anti-Pattern | Problem | Correct Approach |
|--------------|---------|------------------|
| No template | Inconsistent docs | Use standard templates |
| Write-only docs | Never updated | Schedule reviews |
| Missing context | Readers confused | Include background |
| Too verbose | Nobody reads | Be concise, link details |
| Undiscoverable | Docs go unused | Organize and index |

Overview

This skill excels at creating structured technical documentation, including architectural decision records (ADRs), RFCs, design documents, runbooks, and knowledge base articles. It focuses on clarity, traceability, and maintainability so teams can make, review, and implement system decisions consistently. Use it to capture rationale, alternatives, and operational guidance that survives staff turnover.

How this skill works

The skill inspects the document goal and selects a suitable template (ADR, RFC, design doc, runbook, post-mortem, SOP, or wiki article). It prompts for context, constraints, options, and consequences, then drafts clear sections with decision rationale, implementation steps, risks, and success metrics. It structures content for review, links related artifacts, and produces reviewer-ready outputs with suggestions for diagrams and versioning.

When to use it

  • Recording a technical decision and its rationale (ADR)
  • Proposing a system change for team review (RFC)
  • Documenting system architecture or design for onboarding
  • Creating runbooks or operational playbooks
  • Capturing incident analysis and post-mortems
  • Building internal knowledge base or SOP entries

Best practices

  • Start with a clear template matched to the document type
  • Include context, constraints, and alternatives — don’t skip trade-offs
  • Add diagrams (C4, sequence) for complex flows and interfaces
  • Define rollout steps, success metrics, and rollback plans
  • Link to related docs and keep versions in source control
  • Schedule periodic reviews to keep content accurate

Example use cases

  • Author an ADR when choosing a database or service mesh
  • Draft an RFC to propose a significant backend or infra change
  • Produce a design doc for a new microservice including diagrams and NFRs
  • Create a runbook for on-call engineers with step-by-step remediation
  • Write a post-mortem capturing timeline, root causes, and corrective actions

FAQ

When should I choose an ADR versus an RFC?

Use an ADR for recording a final decision and rationale; use an RFC to propose and gather feedback on a solution before a final decision is made.

Can this skill generate diagrams?

The skill suggests diagram types and includes textual diagram descriptions (C4, sequence) suitable for rendering with diagram tools; it does not produce image files directly.