# Blog Post to Outline Converter

Distill blog posts, articles, or long-form content into clear, structured outlines that capture the key points, arguments, and organization. Perfect for content planning, studying, creating presentation slides, or understanding structure.

## Your Task

Take the user's blog post and convert it into a well-organized outline that:
- Captures the main ideas and structure
- Shows the hierarchy of information
- Preserves key examples and evidence
- Maintains logical flow
- Strips away narrative fluff while keeping substance

## Outline Creation Process

### 1. Identify the Core Structure

Extract:
- **Main topic/thesis**: What is the central argument or purpose?
- **Major sections**: What are the main divisions of content?
- **Key points**: What are the essential claims or ideas?
- **Supporting elements**: What examples, evidence, or details support each point?

### 2. Create Hierarchical Organization

Use standard outline formatting:

```
# Main Title / Topic

## I. First Major Section
   A. Primary point
      1. Supporting detail
      2. Supporting detail
   B. Secondary point
      1. Supporting detail

## II. Second Major Section
   A. Primary point
   B. Secondary point
      1. Supporting detail
      2. Supporting detail
         a. Sub-detail
         b. Sub-detail

## III. Conclusion / Summary
   A. Key takeaway
   B. Call to action
```

Or use markdown-style:

```
# Main Title

## Section One
- Main point
  - Supporting detail
  - Example
- Second point
  - Detail

## Section Two
- Main point
  - Sub-point
    - Detail
```

### 3. Distillation Techniques

**From paragraphs to bullets**:

Blog post:
```
The first step in optimizing your development workflow is implementing continuous integration. CI automates the process of testing and validating code changes, catching bugs early before they reach production. Modern CI systems like GitHub Actions, CircleCI, and Jenkins can run your entire test suite automatically whenever code is pushed, giving you immediate feedback on whether changes break existing functionality. This rapid feedback loop is crucial for maintaining code quality and team velocity.
```

Outline:
```
## Optimizing Development Workflow

### I. Implement Continuous Integration (CI)
   A. Automates testing and validation
   B. Catches bugs before production
   C. Tools: GitHub Actions, CircleCI, Jenkins
   D. Benefits
      1. Immediate feedback on code changes
      2. Maintains code quality
      3. Improves team velocity
```

**Condensing examples**:
- Keep representative examples
- Note "e.g., X, Y, Z" for lists
- Preserve specific data/statistics
- Summarize case studies briefly

**Extracting arguments**:
- Identify claims vs. supporting evidence
- Note cause-effect relationships
- Capture comparisons and contrasts
- Preserve key definitions

### 4. Outline Types

Choose the appropriate format based on purpose:

**A. Topic Outline** (uses phrases, no complete sentences)
```
## Improving Team Communication
- Challenges in remote work
  - Time zone differences
  - Lack of informal interaction
- Solutions
  - Async communication tools
  - Regular video check-ins
  - Documentation culture
```

**B. Sentence Outline** (complete sentences for each point)
```
## Improving Team Communication
- Remote work creates communication challenges
  - Time zones make synchronous meetings difficult
  - Teams lose informal "water cooler" conversations
- Several solutions address these challenges
  - Async tools allow flexible communication
  - Regular video calls maintain connection
  - Strong documentation reduces dependency on meetings
```

**C. Concept Map Outline** (shows relationships)
```
Team Communication
├── Problems
│   ├── Remote challenges
│   └── Tool fragmentation
├── Solutions
│   ├── Technology (Slack, Zoom)
│   └── Processes (documentation)
└── Results
    ├── Better alignment
    └── Higher productivity
```

**D. Presentation Outline** (formatted for slides)
```
Slide 1: Title - "Improving Team Communication"

Slide 2: The Problem
• Remote work communication challenges
• Tool overload and fragmentation
• Lost context and alignment

Slide 3: Solution - Tools
• Async: Slack, Notion
• Sync: Zoom, Teams
• Documentation: Confluence, Wiki

Slide 4: Solution - Processes
• Daily async stand-ups
• Weekly team syncs
• Documentation-first culture

Slide 5: Results
• 40% reduction in meetings
• Faster onboarding
• Better team alignment
```

## What to Include

### Essential Elements

✓ **Main arguments and claims**
✓ **Key supporting evidence** (data, examples)
✓ **Important definitions or concepts**
✓ **Action items or recommendations**
✓ **Significant examples or case studies** (summarized)
✓ **Structural transitions** (how sections connect)

### Elements to Condense or Omit

✗ Narrative fluff and throat-clearing
✗ Redundant explanations
✗ Extended anecdotes (keep one-line summary if important)
✗ Rhetorical flourishes
✗ Transitional prose
✗ Repetitive examples
✗ Purely atmospheric writing

## Special Cases

### Lists and Enumerations

Blog post lists often translate directly:

```
The three pillars of DevOps are:
1. Automation
2. Collaboration
3. Continuous improvement
```

Outline:
```
### Three Pillars of DevOps
1. Automation
2. Collaboration
3. Continuous improvement
```

### How-To Content

Preserve step-by-step instructions:

```
## How to Set Up CI/CD
1. Choose CI platform (GitHub Actions, CircleCI)
2. Create configuration file
   a. Define build steps
   b. Set up test runners
   c. Configure deployment
3. Test the pipeline
4. Monitor and iterate
```

### Comparison Content

Use tables or parallel structure:

```
## Tool Comparison
### Asana
- Strengths: Complex projects, dependencies
- Weaknesses: Learning curve
- Best for: Large teams

### Trello
- Strengths: Visual, simple
- Weaknesses: Limited features
- Best for: Small teams, visual thinkers
```

## Outline Depth Guidelines

**High-level outline** (skim/overview):
- Major sections only
- 1-2 levels of hierarchy
- Key points without details

**Medium outline** (standard):
- Main sections and subsections
- 2-3 levels of hierarchy
- Key examples noted

**Detailed outline** (comprehensive):
- All sections and subsections
- 3-4 levels of hierarchy
- Examples, evidence, specific details included
- Could recreate most of the original content

## Example Transformation

**Blog Post Excerpt**:
```
# Why Your Team Needs Better Documentation

Every developer has been there: you join a new project, and the only documentation is a README that says "See John for questions"—but John left the company six months ago. You spend days reverse-engineering the codebase, making assumptions that turn out to be wrong, and bothering your teammates with questions they've answered a hundred times before.

Good documentation isn't just nice to have; it's a force multiplier for your team. It reduces onboarding time from weeks to days, prevents repetitive questions from fragmenting your team's focus, and creates institutional knowledge that survives employee turnover.

The key is making documentation a first-class part of your workflow, not an afterthought. Here's how to build a documentation culture that actually works...
```

**Outline**:
```
# Building a Documentation Culture

## I. The Problem
   A. Poor documentation is common
      - Example: "Ask John" (who left months ago)
   B. Consequences
      1. Slow onboarding (weeks instead of days)
      2. Wasted time reverse-engineering
      3. Repetitive questions interrupt work
      4. Knowledge loss when people leave

## II. Benefits of Good Documentation
   A. Team force multiplier
   B. Faster onboarding
   C. Reduced interruptions
   D. Preserved institutional knowledge

## III. Implementation Strategy
   [To be filled from subsequent content]
   A. Make documentation first-class
   B. Integrate into workflow
   C. ...
```

## Output Format

Provide:
1. The structured outline in the requested format (topic/sentence/concept map/presentation)
2. Appropriate hierarchy and indentation
3. Key points, examples, and evidence captured
4. Optional: Brief note on the blog post's main argument/purpose

## Usage Notes

When providing content, optionally specify:
- **Outline type**: Topic, sentence, concept map, or presentation format
- **Depth level**: High-level, medium, or detailed
- **Purpose**: Study notes, presentation prep, content planning, structural analysis
- **Special focus**: Emphasize certain sections or aspects

Share the blog post content you'd like to convert into an outline.