skeleton-of-thought

INVOKE for planning and outlining before implementation. Produces visible skeleton then expansion. Use before implementing features or creating structured documents. Triggers: planning, outlining, structuring approaches, roadmaps, breaking into phases.

⭐2stars🔀1forks📁View on GitHub🕐Updated Jan 9, 2026⬇️1downloads

When & Why to Use This Skill

The Skeleton of Thought (SoT) skill is a strategic planning framework designed to enhance AI output quality by enforcing a 'structure-first' approach. It optimizes the generation of complex content by breaking tasks into two distinct phases: creating a high-level logical skeleton followed by a detailed expansion of each component. This methodology prevents cognitive drift, ensures comprehensive scope coverage, and is essential for technical architecture, long-form documentation, and multi-phase project execution.

Use Cases

  • Software Feature Planning: Designing the structural blueprint for new features, including database schemas, API contracts, and frontend components before implementation.
  • Technical Documentation: Outlining complex manuals, whitepapers, or research reports to ensure logical flow and that all technical requirements are addressed.
  • Project Roadmapping: Breaking down large-scale initiatives into manageable phases, sequences, and dependencies to provide a clear path to completion.
  • Complex Problem Solving: Deconstructing multi-faceted business or technical challenges into organized sub-problems to ensure a systematic and thorough solution.
nameskeleton-of-thought
description"INVOKE for planning and outlining before implementation. Produces visible skeleton then expansion. Use before implementing features or creating structured documents. Triggers: planning, outlining, structuring approaches, roadmaps, breaking into phases."

Skeleton of Thought (SoT)

Generates structure before content—outline first, then parallel expansion.

MUST Invoke When

  • Planning implementation of a feature
  • User asks for a "plan", "outline", or "roadmap"
  • Creating multi-section documents or responses
  • Structuring complex output before writing
  • Breaking work into phases or components

Output Commitment

This skill produces visible structured output:

  • Phase 1: Skeleton only (major sections, no details)
  • Phase 2: Expansion of each skeleton point
  • Clear separation between structure and content

Do NOT jump to implementation—invoke this skill to show skeleton first.

Core Mechanism

Two distinct phases:

  1. Skeleton phase: Generate only the high-level structure (headers, key points, sequence)
  2. Expansion phase: Flesh out each skeleton point independently

Process

Phase 1 - Skeleton:
1. Identify the major components/sections needed
2. Determine logical ordering and dependencies
3. Output ONLY the skeleton (no details yet)
4. Validate: Does this structure cover the full scope?

Phase 2 - Expansion:
1. Take each skeleton point in order
2. Expand with full detail
3. Maintain coherence with adjacent sections
4. Check: Does expansion stay true to skeleton's intent?

Key Principles

  • Separation of concerns: Structure and content are distinct cognitive tasks
  • Parallelization potential: Skeleton points can be expanded concurrently
  • Drift prevention: Skeleton constrains expansion, preventing tangents
  • Dependency visibility: Structure reveals what must come before what

When to Apply

  • Implementation planning (see full scope before diving in)
  • Document/report creation
  • Presentations and structured communication
  • Any multi-part output where order matters
  • Complex responses that need organization

Skeleton Pattern

Phase 1 - Generate skeleton only:

For [TASK], create a skeleton outline:
- Major sections/components only
- One line per item (no elaboration)
- Include sequencing/dependencies
- Do NOT expand yet

[Generate skeleton]

---

Phase 2 - Expand sequentially:

Now expand each skeleton point:
- Full detail for this section only
- Stay within the skeleton's scope
- Note dependencies on prior sections
- [Process in dependency order]

Planning Application

Skeleton:
1. Database schema changes
2. API endpoint modifications  
3. Frontend component updates
4. Integration tests
5. Migration script

Expansion (each becomes detailed task list with acceptance criteria)

Anti-Patterns

  • Expanding during skeleton phase (defeats the purpose)
  • Skeleton too detailed (it's not a full outline, just structure)
  • Skeleton too vague (should still capture all major components)
  • Ignoring dependencies during expansion
  • Not validating skeleton covers full scope before expanding