writing-outline
Internal skill for creating detailed section outlines. Called by /writing workflow after PRECIS and master OUTLINE are complete.
What this skill does
# Writing Outline
Create a detailed outline for a specific section/part before drafting prose. This is Level 3 of the progressive expansion workflow.
## Progressive Expansion Context
```
.planning/PRECIS.md # Level 1: Thesis, claims, audience
↓
.planning/OUTLINE.md # Level 2: Master structure (sections, goals)
↓
outlines/Part I.md # Level 3: THIS STEP - Detailed section outline
↓
drafts/Part I.md # Level 4: Prose expansion
```
**Never skip to prose drafting without a detailed outline first.**
## Shared Enforcement
Auto-load all constraints matching `applies-to: writing-outline`:
!`uv run python3 ${CLAUDE_SKILL_DIR}/../../scripts/load-constraints.py writing-outline`
**You MUST have these constraints loaded before proceeding. No claiming you "remember" them.**
## Outline Flowchart (This IS the Spec)
```
START (PRECIS + master OUTLINE exist)
│
├─ Step 1: Load context (PRECIS, OUTLINE, ACTIVE_WORKFLOW)
│
├─ Step 2: Select section (user choice or next unoutlined)
│
├─ Step 3: Gather structure/depth preferences
│
├─ Step 4: Create detailed outline
│ └─ For each subsection: POINT + EVIDENCE + LOGIC
│ Opening → Body (subsections with transitions) → Closing
│
├─ Step 5: Cross-reference with PRECIS claims
│ └─ Verify: advances claim, within scope, thesis thread
│
├─ Step 6: Update ACTIVE_WORKFLOW.md
│
└─ More sections remaining?
├─ YES → Loop to Step 2 (NO pause, NO "should I continue?")
└─ NO → GATE: Every OUTLINE section has outlines/ file?
├─ NO → Report missing, loop back
└─ YES → Outline Review Gate
└─ Dispatch writing-outline-reviewer subagent
├─ APPROVED → IMMEDIATELY load writing-draft (no pause)
└─ ISSUES_FOUND → fix outlines → re-dispatch (max 5)
```
If text and flowchart disagree, the flowchart wins.
<EXTREMELY-IMPORTANT>
## The Iron Law of Outline Before Prose
**NO PROSE WITHOUT OUTLINE. Never skip to prose drafting without a detailed outline in `outlines/` first. This is not negotiable.**
If you find yourself writing prose without a matching outline file:
1. STOP immediately
2. DELETE the prose
3. Create the outline first
4. THEN draft
Thin outlines produce thin drafts. Each outline must have POINT, EVIDENCE, and LOGIC for every subsection.
</EXTREMELY-IMPORTANT>
## Why Skipping Hurts the Thing You Care About Most
| Your Drive | Why You Skip | What Actually Happens | The Drive You Failed |
|------------|--------------|----------------------|---------------------|
| **Helpfulness** | "Thin outlines let us get to drafting faster" | The draft has no structure to expand. Every section wanders. You redraft from scratch. Your speed produced chaos and rework. | **Anti-helpful** |
| **Competence** | "I know this topic well enough to skip detail" | Without mapped evidence, the draft section makes unsupported assertions. Without planned transitions, the argument fragments. Your confidence was incompetence. | **Incompetent** |
| **Honesty** | "The outline covers the main points" | You listed topics without POINT, EVIDENCE, or LOGIC. The user drafts from a skeleton — every section is improvised and needs rewriting. | **Anti-helpful** |
## Session Resume Detection
Before starting, check for an existing handoff:
1. Check if `.planning/HANDOFF.md` exists
2. **If found:** Read it and present to user:
- Show the phase, section in progress, and Next Action
- Ask: "Resume from handoff, or start fresh?"
- If resume: skip to the recorded section
- If fresh: proceed normally
3. **If not found:** Proceed normally
## Process
### Step 1: Load Context
```
Read(".planning/ACTIVE_WORKFLOW.md")
Read(".planning/PRECIS.md")
Read(".planning/OUTLINE.md")
```
If master OUTLINE.md is missing, run writing-brainstorm first.
### Step 2: Select Section
If not specified by user, present available sections:
```
AskUserQuestion(questions=[
{
"question": "Which section should I outline in detail?",
"header": "Section",
"options": [
{"label": "Part I / Introduction", "description": "Hook, thesis, roadmap"},
{"label": "Part II / Background", "description": "Context and precedents"},
{"label": "Part III / Argument", "description": "Main claims and evidence"},
{"label": "Part IV / Counterarguments", "description": "Objections and responses"}
],
"multiSelect": false
}
])
```
### Step 3: Gather Section Details
For the selected section, ask clarifying questions:
```
AskUserQuestion(questions=[
{
"question": "How should this section be structured?",
"header": "Structure",
"options": [
{"label": "Chronological", "description": "Events/developments in time order"},
{"label": "Thematic", "description": "Grouped by topic or concept"},
{"label": "Problem-Solution", "description": "Issue then resolution"},
{"label": "Comparative", "description": "Side-by-side analysis"}
],
"multiSelect": false
},
{
"question": "What level of detail do you want?",
"header": "Depth",
"options": [
{"label": "Paragraph-level", "description": "One bullet per paragraph"},
{"label": "Sentence-level", "description": "Key sentences mapped out"},
{"label": "Full skeleton", "description": "Nearly complete argument structure"}
],
"multiSelect": false
}
])
```
### Step 4: Create Detailed Outline
Create directory if needed and write the detailed outline:
```bash
mkdir -p outlines
```
Write to `outlines/[Section Name] (Outline).md`:
```markdown
# [Section Name] - Detailed Outline
## Section Goal
[From master OUTLINE.md - what this section accomplishes]
## Claim Supported
[Which claim from PRECIS.md this section advances]
## Structure: [Chronological/Thematic/Problem-Solution/Comparative]
---
## Opening
**Lead sentence**: [Draft or TBD]
**Context needed**: [What reader must know]
**Transition from previous**: [How we got here]
---
## Body
### Subsection A: [Name]
**Point**: [Main argument of this subsection]
**Evidence**:
- [Source 1]: "[key quote or fact]"
- [Source 2]: "[key quote or fact]"
**Logic**: [How evidence supports point]
**Transition**: [Bridge to next subsection]
### Subsection B: [Name]
**Point**: [Main argument]
**Evidence**:
- [Source]: "[key quote or fact]"
**Logic**: [How evidence supports point]
**Anticipated objection**: [If applicable]
- Response: [How to address]
**Transition**: [Bridge to next]
### Subsection C: [Name]
[Continue pattern...]
---
## Closing
**Section summary**: [One sentence recap]
**Bridge to next section**: [How this leads to what follows]
**Thesis thread**: [How this connects to main thesis from PRECIS]
---
## Sources Used in This Section
- [Source 1] - used for [what]
- [Source 2] - used for [what]
## Open Questions
- [Anything unresolved before drafting]
## Estimated Length
[Paragraph count or word count target]
```
### Step 5: Cross-Reference with PRECIS
Verify the detailed outline against PRECIS.md:
- [ ] Advances at least one claim from PRECIS
- [ ] Addresses relevant counterarguments (if applicable)
- [ ] Stays within IN scope
- [ ] Avoids OUT scope items
- [ ] Maintains thesis thread
Report any misalignments.
### Step 6: Update Workflow State
Update `.planning/ACTIVE_WORKFLOW.md`:
```yaml
phase: outline
current_section: [section name]
outlines_complete:
- [list of completed outlines]
```
### Step 7: Continue or Proceed
After completing a section outline, IMMEDIATELY start the next section. Do NOT:
- Ask "should I continue?"
- Summarize what you just outlined
- Wait for confirmation
**Pausing between section outlines is procrastination disguised as courtesy.**
When ALL sections from OUTLINE.md have detailed outlines in `outlines/`, proceed to the draft phase.
---
## Deviation Rules (Outline Phase)
When outlining reveals unplanned issues, follow the deviation rules fRelated in Writing & Docs
jax-development
IncludedUse this skill when the user is writing, debugging, profiling, refactoring, reviewing, benchmarking, parallelising, exporting, or explaining JAX code, or when they mention JAX, jax.numpy, jit, grad, value_and_grad, vmap, scan, lax, random keys, pytrees, jax.Array, sharding, Mesh, PartitionSpec, NamedSharding, pmap, shard_map, Pallas, XLA, StableHLO, checkify, profiler, or the JAX repo. It helps turn NumPy or PyTorch-style code into pure functional JAX, fix tracer/control-flow/shape/PRNG bugs, remove recompiles and host-device syncs, choose transforms and sharding strategies, inspect jaxpr/lowering/IR, and benchmark compiled code correctly.
nature-article-writer
IncludedDrafts, rewrites, diagnostically critiques, and style-calibrates primary research manuscripts for Nature and Nature Portfolio journals. Use when the user wants a Nature-style title, summary paragraph or abstract, introduction, results, discussion, methods, figure legends, presubmission enquiry, cover letter, reviewer response, or when a scientific draft sounds generic, jargon-heavy, structurally weak, or AI-ish and needs precise, broad-reader-friendly prose without inventing data, analyses, or references. Best for primary research articles and letters rather than reviews or press releases unless explicitly adapting one.
deckrd
IncludedDocument-driven framework that derives requirements, specifications, implementation plans, and executable tasks from goals through structured AI dialogue. Use when user says "write requirements", "create spec", "plan implementation", "derive tasks", "structure this feature", "break down into tasks", or "document this module". Also use for reverse engineering existing code into docs (/deckrd rev). Do NOT use for direct code writing — use /deckrd-coder after tasks are generated. Do NOT use when the user only wants to run or fix existing code without planning.
clinical-decision-support
IncludedGenerate professional clinical decision support (CDS) documents for pharmaceutical and clinical research settings, including patient cohort analyses (biomarker-stratified with outcomes) and treatment recommendation reports (evidence-based guidelines with decision algorithms). Supports GRADE evidence grading, statistical analysis (hazard ratios, survival curves, waterfall plots), biomarker integration, and regulatory compliance. Outputs publication-ready LaTeX/PDF format optimized for drug development, clinical research, and evidence synthesis.
handling-sf-data
IncludedSalesforce data operations with 130-point scoring. Use this skill to create, update, delete, bulk import/export, generate test data, and clean up org records using sf CLI and anonymous Apex. TRIGGER when: user creates test data, performs bulk import/export, uses sf data CLI commands, needs data factory patterns for Apex tests, or needs to seed/clean records in a Salesforce org. DO NOT TRIGGER when: SOQL query writing only (use querying-soql), Apex test execution (use running-apex-tests), or metadata deployment (use deploying-metadata).
accelint-ac-to-playwright
IncludedConvert and validate acceptance criteria for Playwright test automation. Use when user asks to (1) review/evaluate/check if AC are ready for automation, (2) assess if AC can be converted as-is, (3) validate AC quality for Playwright, (4) turn AC into tests, (5) generate tests from acceptance criteria, (6) convert .md bullets or .feature Gherkin files to Playwright specs, (7) create test automation from requirements. Handles both bullet-style markdown and Gherkin syntax with JSON test plan generation and validation.