450 How To Guides 844431f6

How-To Guide Generation (C3.3)

Transform test workflows into step-by-step educational guides

Overview

The How-To Guide Builder automatically generates comprehensive, step-by-step tutorials from workflow examples extracted from test files. It analyzes test code, identifies sequential steps, detects prerequisites, and creates markdown guides with verification points and troubleshooting tips.

Key Features:

• 🔍 Smart Step Extraction - Python AST-based analysis for precise step identification
• 🧩 Intelligent Grouping - 4 grouping strategies including AI-based tutorial organization
• 📝 Rich Markdown Output - Complete guides with prerequisites, code examples, and troubleshooting
• 🎯 Complexity Assessment - Automatic difficulty classification (beginner/intermediate/advanced)
• ✅ Verification Points - Identifies test assertions and converts them to verification steps
• 🌍 Multi-Language Support - Python (AST-based), JavaScript, TypeScript, Go, Rust, Java, C#, PHP, Ruby
• ✨ 🆕 AI Enhancement - Professional quality improvements with 5 automatic enhancements (NEW!)

Part of C3 Codebase Enhancement Series:

• C3.1: Pattern Recognition
• C3.2: Test Example Extraction
• C3.3: How-To Guide Generation ← You are here
• C3.4-C3.7: Config, Architecture, AI Enhancement, Documentation

Quick Start

1. Extract Test Examples (C3.2)

First, extract workflow examples from your test files:

# Extract test examples including workflows
skill-seekers analyze tests/ \
  --extract-test-examples \
  --output output/codebase/

# Or use standalone tool
skill-seekers-extract-test-examples tests/ \
  --output output/codebase/test_examples/

2. Build How-To Guides (C3.3)

Generate guides from extracted workflow examples:

# Build guides from extracted examples
skill-seekers-how-to-guides \
  output/codebase/test_examples/test_examples.json \
  --output output/codebase/tutorials/

# Choose grouping strategy
skill-seekers-how-to-guides examples.json \
  --group-by ai-tutorial-group   # AI-based (default)
  --group-by file-path            # Group by test file
  --group-by test-name            # Group by test name patterns
  --group-by complexity           # Group by difficulty level

3. Automatic Integration (Recommended)

Enable guide generation during codebase analysis:

# Automatic pipeline: extract tests → build guides
skill-seekers analyze tests/ \
  --extract-test-examples \
  --build-how-to-guides \
  --output output/codebase/

# Skip guide generation
skill-seekers analyze tests/ \
  --skip-how-to-guides

AI Enhancement (NEW!)

Transform basic guides (⭐⭐) into professional tutorials (⭐⭐⭐⭐⭐) with comprehensive AI-powered improvements.

What Gets Enhanced

The AI Enhancement system provides 5 automatic improvements that dramatically increase guide quality:

1. Step Descriptions (⭐⭐⭐)

Natural language explanations for each step - not just syntax!

Before:

### Step 1
```python
scraper.scrape(url)

After:

### Step 1: Initialize the scraper
```python
scraper.scrape(url)

Explanation: Initialize the scraper with the target URL. This configures the HTTP client, sets up request headers, and prepares the URL queue for BFS traversal. The scraper will respect rate limits and follow the URL patterns defined in your configuration.

Common Variations:

• Use AsyncDocumentationScraper() for concurrent scraping (3-5x faster)
• Pass custom headers for authentication: scraper.scrape(url, headers={'Authorization': 'Bearer token'})

#### 2. Troubleshooting Solutions (⭐⭐⭐)
Diagnostic flows + solutions for common errors

**Before:**
```markdown
## Troubleshooting
- ImportError
- Connection timeout

After:

## Troubleshooting

### ImportError: No module named 'requests'

**Symptoms:**
- Import statement fails immediately
- Module not found error in stack trace
- Script exits before any execution

**Diagnosis:**
1. Check if package is installed: `pip list | grep requests`
2. Verify virtual environment is active: `which python`
3. Confirm Python version compatibility: `python --version`

**Solution:**
```bash
# Activate virtual environment first (if using one)
source venv/bin/activate

# Install the missing package
pip install requests

# Verify installation
python -c "import requests; print(requests.__version__)"

Connection Timeout

Symptoms:

• Scraper hangs for 30-60 seconds
• TimeoutError or ConnectTimeout exception
• No response from target server

Diagnosis:

1. Check internet connection: ping example.com
2. Verify URL is accessible: curl -I https://docs.example.com
3. Check firewall/proxy settings

Solution:

# Increase timeout in scraper configuration
config = {
    'timeout': 60,  # Increase from default 30 seconds
    'retry_attempts': 3,
    'retry_delay': 5
}
scraper = DocumentationScraper(config)

#### 3. Prerequisites Explanations (⭐⭐)
Why each prerequisite is needed + setup instructions

**Before:**
```markdown
## Prerequisites
- requests
- beautifulsoup4

After:

## Prerequisites

### requests
**Why needed:** HTTP client library for fetching web pages over HTTP/HTTPS. Handles connections, headers, redirects, and response parsing.

**Setup:**
```bash
pip install requests

Version recommendation: >= 2.28.0 (for improved SSL support)

beautifulsoup4

Why needed: HTML/XML parser for extracting content from web pages. Provides intuitive API for navigating and searching the document tree.

Setup:

pip install beautifulsoup4

Additional: Install lxml parser for better performance: pip install lxml

#### 4. Next Steps Suggestions (⭐⭐)
Related guides, variations, learning paths

**Before:**
```markdown
## Next Steps
- See related guides

After:

## Next Steps

### Extend Your Skills
- **How to scrape GitHub repositories** - Adapt scraping for code repositories
- **How to handle pagination** - Deal with multi-page content and infinite scroll
- **How to cache scraping results** - Avoid re-scraping with local cache and timestamps

### Advanced Topics
- **Async scraping for performance** - Use AsyncDocumentationScraper for 3-5x speedup
- **Custom selectors and parsing** - Adapt to complex documentation structures
- **Error handling and retry logic** - Build robust scrapers that handle failures gracefully

### Real-World Projects
- Build a documentation search engine
- Create automated skill updates
- Extract API references for analysis

5. Use Case Examples (⭐)

Real-world scenarios showing when to use the guide

Before:

This guide shows how to scrape documentation.

After:

## Use Cases

**Documentation Archiving**
Use this when you need to create offline archives of technical documentation for:
- Air-gapped environments without internet access
- Preserving documentation versions before updates
- Building searchable knowledge bases

**Skill Creation**
Ideal for converting framework documentation into Claude skills:
- Extract React, Vue, Django documentation
- Build specialized knowledge bases
- Enable AI assistance for specific frameworks

**Content Migration**
Perfect for transferring content between documentation platforms:
- Moving from Sphinx to MkDocs
- Migrating legacy docs to modern systems
- Converting HTML docs to structured markdown

Quality Transformation

The AI enhancement system transforms guides from basic templates into comprehensive professional tutorials:

How to Use AI Enhancement

Method 1: Automatic (Recommended)

AI enhancement happens automatically with AUTO mode detection:

# Auto-detects best mode (API if key set, else LOCAL)
skill-seekers analyze tests/ \
  --extract-test-examples \
  --build-how-to-guides \
  --ai-mode auto

Method 2: API Mode

Use Claude API directly (requires ANTHROPIC_API_KEY):

# Set API key
export ANTHROPIC_API_KEY=sk-ant-...

# Enable API mode
skill-seekers analyze tests/ \
  --build-how-to-guides \
  --ai-mode api

Characteristics:

• Fast and efficient
• Perfect for automation/CI
• Cost: ~$0.15-$0.30 per guide
• Processes multiple guides in parallel

Method 3: LOCAL Mode

Use Claude Code CLI (no API key needed):

# Uses your Claude Code Max plan (FREE!)
skill-seekers analyze tests/ \
  --build-how-to-guides \
  --ai-mode local

Characteristics:

• Uses existing Claude Code Max plan
• Opens in terminal for 30-60 seconds
• Perfect for local development
• No API costs!
• Same quality as API mode

Method 4: Disable AI Enhancement

Generate basic guides without AI:

# Faster, but basic quality
skill-seekers analyze tests/ \
  --build-how-to-guides \
  --ai-mode none

API vs LOCAL Mode Comparison

Example Workflow

Complete workflow with AI enhancement:

# 1. Extract test examples from your codebase
skill-seekers analyze tests/ \
  --extract-test-examples \
  --output output/codebase/

# 2. Build enhanced guides (AUTO mode)
skill-seekers-how-to-guides \
  output/codebase/test_examples/test_examples.json \
  --group-by ai-tutorial-group \
  --ai-mode auto \
  --output output/codebase/tutorials/

# 3. Review generated guides
cat output/codebase/tutorials/index.md
cat output/codebase/tutorials/user_management.md

# 4. Verify enhancements applied
grep -A 5 "## Troubleshooting" output/codebase/tutorials/*.md

Troubleshooting AI Enhancement

Issue: API mode fails with authentication error

# Check API key is set correctly
echo $ANTHROPIC_API_KEY

# Verify key format (should start with sk-ant-)
# Set key properly
export ANTHROPIC_API_KEY=sk-ant-your-key-here

Issue: LOCAL mode doesn't open Claude Code

# Verify Claude Code is installed
which claude

# If not found, install Claude Code CLI
# See: https://claude.com/code

Issue: Enhancement takes too long

# Switch to API mode for faster processing
skill-seekers analyze tests/ \
  --build-how-to-guides \
  --ai-mode api  # Much faster than LOCAL

# Or disable enhancement for testing
--ai-mode none

Issue: Want to skip enhancement for specific guides

# Generate basic guides first
skill-seekers-how-to-guides examples.json --ai-mode none

# Then enhance only specific guides manually
skill-seekers-enhance output/codebase/tutorials/user_management.md

Usage

CLI Tool

# Basic usage
skill-seekers-how-to-guides <input-file> [OPTIONS]

# Options
  --output PATH              Output directory (default: output/codebase/tutorials)
  --group-by STRATEGY        Grouping strategy (default: ai-tutorial-group)
  --no-ai                    Disable AI enhancement
  --json-output              Output JSON alongside markdown

# Examples
skill-seekers-how-to-guides test_examples.json
skill-seekers-how-to-guides examples.json --output tutorials/
skill-seekers-how-to-guides examples.json --group-by file-path --no-ai

MCP Tool

Available via MCP server for Claude Code integration:

# In Claude Code
"Build how-to guides from the extracted test examples"

# Translates to MCP call:
build_how_to_guides(
    input="output/codebase/test_examples/test_examples.json",
    output="output/codebase/tutorials",
    group_by="ai-tutorial-group"
)

Python API

from skill_seekers.cli.how_to_guide_builder import HowToGuideBuilder

# Create builder
builder = HowToGuideBuilder(enhance_with_ai=True)

# Build guides from workflow examples
collection = builder.build_guides_from_examples(
    examples=workflow_examples,
    grouping_strategy='ai-tutorial-group',
    output_dir=Path('tutorials/')
)

# Access results
print(f"Created {collection.total_guides} guides")
print(f"Beginner: {collection.guides_by_complexity['beginner']}")
print(f"Intermediate: {collection.guides_by_complexity['intermediate']}")
print(f"Advanced: {collection.guides_by_complexity['advanced']}")

Grouping Strategies

1. AI Tutorial Group (Default - Recommended)

Uses AI analysis from C3.6 enhancement to intelligently group related workflows.

Behavior:

• Groups workflows by tutorial theme (e.g., "User Management", "Database Operations")
• Considers semantic similarity of test names and code
• Falls back to file-path grouping if AI data unavailable

Best for: Maximum quality, logical topic organization

skill-seekers-how-to-guides examples.json --group-by ai-tutorial-group

Example Output:

tutorials/
├── index.md
├── user-management.md          # User creation, updates, deletion
├── authentication-workflows.md # Login, logout, token management
├── database-operations.md      # CRUD operations, migrations
└── api-integration.md          # External API calls, webhooks

2. File Path Grouping

Groups workflows by test file location.

Behavior:

• One guide per test file
• Title derived from file name
• Preserves existing file organization

Best for: Small projects, file-based organization

skill-seekers-how-to-guides examples.json --group-by file-path

Example Output:

tutorials/
├── index.md
├── test-user.md              # All workflows from tests/test_user.py
├── test-auth.md              # All workflows from tests/test_auth.py
└── test-database.md          # All workflows from tests/test_database.py

3. Test Name Grouping

Groups workflows by test name prefixes.

Behavior:

• Identifies common prefixes (e.g., test_user_*, test_admin_*)
• Groups workflows with shared prefixes
• Falls back to individual guides

Best for: Consistent test naming conventions

skill-seekers-how-to-guides examples.json --group-by test-name

Example Output:

tutorials/
├── index.md
├── user-workflows.md         # test_user_create, test_user_update, test_user_delete
├── admin-workflows.md        # test_admin_create, test_admin_permissions
└── integration-workflows.md  # test_integration_api, test_integration_db

4. Complexity Grouping

Groups workflows by difficulty level.

Behavior:

• Analyzes code complexity
• Groups by beginner/intermediate/advanced
• Sorted within groups by topic

Best for: Educational content, progressive learning paths

skill-seekers-how-to-guides examples.json --group-by complexity

Example Output:

tutorials/
├── index.md
├── beginner-guides.md        # Simple workflows, 2-4 steps
├── intermediate-guides.md    # Moderate complexity, 5-7 steps
└── advanced-guides.md        # Complex workflows, 8+ steps, async, error handling

Guide Structure

Each generated guide includes:

1. Header

# How To: Create and Save User to Database

**Difficulty**: Beginner
**Estimated Time**: 10 minutes
**Tags**: user, database, create

2. Overview

Brief description of what the guide teaches and when to use it.

3. Prerequisites

• Required modules/imports
• Fixtures or setup code needed
• Dependencies

## Prerequisites

- [ ] Database connection configured
- [ ] User model imported

**Required Modules:**
- `from myapp import Database, User`

4. Step-by-Step Guide

Each step includes:

• Step number and description
• Code snippet
• Expected result
• Verification command (if applicable)

## Step-by-Step Guide

### Step 1: Create database connection

```python
db = Database('test.db')

Expected Result: Database object initialized

Verification:

assert db.is_connected()

### 5. Complete Example

Full working code combining all steps:

```markdown
## Complete Example

```python
# Step 1: Create database connection
db = Database('test.db')

# Step 2: Create user object
user = User(name='Alice', email='alice@example.com')

# Step 3: Save to database
db.save(user)

# Step 4: Verify user was saved
saved_user = db.get_user('Alice')
assert saved_user.email == 'alice@example.com'

### 6. Troubleshooting

Common issues and solutions (when available).

### 7. Next Steps

Related guides or advanced topics.

---

## Output Format

### Directory Structure

output/codebase/tutorials/ ├── index.md # Guide catalog with difficulty indicators ├── user-creation-workflow.md # Individual guide ├── authentication-flow.md # Individual guide ├── database-operations.md # Individual guide └── guide_collection.json # Metadata and statistics

### Index File

The index provides an overview of all guides:

```markdown
# How-To Guides

Auto-generated guides from test workflow examples.

## By Difficulty

### Beginner (3 guides)
- [Create and Save User](user-creation-workflow.md)
- [Simple Database Query](database-query.md)
- [User Authentication](authentication-flow.md)

### Intermediate (2 guides)
- [Multi-Step User Registration](user-registration.md)
- [Transaction Management](transactions.md)

### Advanced (1 guide)
- [Complex API Integration](api-integration.md)

## By Topic

**User Management**: 3 guides
**Database**: 2 guides
**Authentication**: 1 guide

JSON Output

Optional JSON format for programmatic access:

{
  "total_guides": 6,
  "guides_by_complexity": {
    "beginner": 3,
    "intermediate": 2,
    "advanced": 1
  },
  "guides_by_use_case": {
    "User Management": [
      {
        "guide_id": "user-creation",
        "title": "Create and Save User",
        "complexity_level": "beginner",
        "steps": 4,
        "tags": ["user", "database", "create"]
      }
    ]
  },
  "guides": [...]
}

Architecture

Core Components

1. WorkflowAnalyzer

Analyzes workflow examples to extract steps and metadata.

Features:

• Python AST-based step extraction
• Heuristic extraction for other languages
• Prerequisites detection (imports, fixtures)
• Verification point identification (assertions)
• Complexity scoring

Example:

analyzer = WorkflowAnalyzer()
steps, metadata = analyzer.analyze_workflow(workflow_example)

# Returns:
# - steps: List[WorkflowStep]
# - metadata: Dict with complexity_level, prerequisites, etc.

2. WorkflowGrouper

Groups related workflows into coherent guides.

Strategies:

• AI tutorial grouping (uses C3.6 analysis)
• File path grouping
• Test name pattern matching
• Complexity-based grouping

Example:

grouper = WorkflowGrouper()
grouped = grouper.group_workflows(workflows, strategy='ai-tutorial-group')

# Returns: Dict[str, List[Dict]]
# Key: Guide title
# Value: List of related workflows

3. GuideGenerator

Generates markdown guides from workflow data.

Methods:

• generate_guide_markdown() - Complete guide
• generate_index() - Guide catalog
• _create_header() - Title and metadata
• _create_steps_section() - Step-by-step instructions
• _create_complete_example() - Full working code

Example:

generator = GuideGenerator()
markdown = generator.generate_guide_markdown(guide)
index = generator.generate_index(guides)

4. HowToGuideBuilder

Main orchestrator coordinating all components.

Workflow:

1. Extract workflow examples from test data
2. Analyze each workflow (steps, metadata)
3. Group related workflows
4. Generate guides for each group
5. Create index and save files

Example:

builder = HowToGuideBuilder(enhance_with_ai=True)
collection = builder.build_guides_from_examples(
    examples,
    grouping_strategy='ai-tutorial-group',
    output_dir=Path('tutorials/')
)

Data Models

@dataclass
class WorkflowStep:
    """Single step in a workflow guide"""
    step_number: int
    code: str
    description: str
    expected_result: Optional[str] = None
    verification: Optional[str] = None
    setup_required: Optional[str] = None

@dataclass
class HowToGuide:
    """Complete how-to guide"""
    guide_id: str
    title: str
    overview: str
    complexity_level: Literal["beginner", "intermediate", "advanced"]
    prerequisites: List[str]
    steps: List[WorkflowStep]
    use_case: str
    tags: List[str]

@dataclass
class GuideCollection:
    """Collection of guides with metadata"""
    total_guides: int
    guides_by_complexity: Dict[str, int]
    guides_by_use_case: Dict[str, List[HowToGuide]]
    guides: List[HowToGuide]

Integration with Other Features

C3.2 Test Example Extraction (Prerequisite)

How-to guides are built from workflow examples extracted by C3.2:

# Full pipeline
skill-seekers analyze tests/ \
  --extract-test-examples \
  --build-how-to-guides

Data Flow:

1. C3.2 extracts test examples (5 categories)
2. C3.3 filters for workflow category
3. Analyzes workflows and generates guides

C3.6 AI Enhancement (Optional)

AI analysis enhances grouping and explanations:

# With AI enhancement (default)
skill-seekers-how-to-guides examples.json \
  --group-by ai-tutorial-group

# Without AI (faster, basic grouping)
skill-seekers-how-to-guides examples.json --no-ai

AI Contributions:

• Tutorial group assignment
• Enhanced step descriptions
• Better troubleshooting tips
• Use case identification

Codebase Scraper Integration

Automatic guide generation during codebase analysis:

skill-seekers analyze /path/to/repo/ \
  --extract-test-examples \
  --build-how-to-guides \
  --output output/codebase/

Output Structure:

output/codebase/
├── api_reference/
├── dependencies/
├── patterns/
├── test_examples/
└── tutorials/          # How-to guides (C3.3)
    ├── index.md
    └── *.md

Use Cases

1. Onboarding Documentation

Generate tutorials for new team members:

skill-seekers-how-to-guides tests/integration/test_examples.json \
  --group-by ai-tutorial-group \
  --output docs/tutorials/

Result: Comprehensive guides showing how to use your APIs/libraries based on real test code.

2. API Usage Examples

Extract usage patterns from test suites:

skill-seekers analyze tests/api/ \
  --extract-test-examples \
  --build-how-to-guides

Result: Step-by-step API integration guides derived from actual test workflows.

3. Educational Content

Create progressive learning paths:

skill-seekers-how-to-guides examples.json \
  --group-by complexity \
  --output learning-path/

Result: Beginner → Intermediate → Advanced progression of tutorials.

4. Migration Guides

Document workflows for version upgrades:

# Extract from old version tests
skill-seekers-extract-test-examples tests/ --output old-examples.json

# Extract from new version tests
skill-seekers-extract-test-examples tests/ --output new-examples.json

# Generate migration guides
skill-seekers-how-to-guides old-examples.json --output migration/old/
skill-seekers-how-to-guides new-examples.json --output migration/new/

Result: Side-by-side comparison of old vs new workflows.

Quality Filtering

Workflow Selection Criteria

Only high-quality workflow examples are used:

1. Minimum Steps: 2+ distinct operations
2. Code Length: 30+ characters
3. Confidence Score: ≥ 0.6 (from C3.2 extraction)
4. Category: Must be workflow type

Complexity Calculation

Automatic difficulty assessment based on:

Beginner:

• 2-4 steps
• Simple operations
• No async/error handling
• Standard library only

Intermediate:

• 5-7 steps
• Moderate complexity
• Some error handling
• External libraries

Advanced:

• 8+ steps
• Complex logic
• Async/await patterns
• Error handling + edge cases
• Multiple dependencies

Troubleshooting

No Guides Generated

Problem: build_guides_from_examples() returns collection with 0 guides

Solutions:

1. Check input has workflow examples:

   # Verify workflow examples exist
   jq '.examples[] | select(.category == "workflow")' examples.json
   

2. Lower quality threshold:

   builder = HowToGuideBuilder(min_confidence=0.4)  # Default: 0.5
   

3. Check test example extraction included workflows:

   skill-seekers-extract-test-examples tests/ --json
   # Look for "workflow" in categories
   

Poor Guide Quality

Problem: Generated guides are incomplete or unclear

Solutions:

1. Enable AI enhancement:

   skill-seekers-how-to-guides examples.json  # AI enabled by default
   

2. Use better grouping strategy:

   # Try ai-tutorial-group instead of file-path
   skill-seekers-how-to-guides examples.json --group-by ai-tutorial-group
   

3. Improve source tests:

   • Add descriptive comments
   • Use clear variable names
   • Include assertions for verification

Wrong Grouping

Problem: Workflows grouped incorrectly

Solutions:

1. Try different grouping strategy:

   # If ai-tutorial-group fails, try file-path
   skill-seekers-how-to-guides examples.json --group-by file-path
   

2. Organize test files better:

   • Group related tests in same file
   • Use consistent test naming (e.g., test_user_*)

3. Add tutorial_group hints (for AI grouping):

   def test_user_creation():
       """
       Tutorial group: User Management
       Create a new user in the database
       """
   

Missing Steps

Problem: Guide missing obvious steps from test

Solutions:

1. Check Python version compatibility:

   • Python AST extraction requires Python 3.10+
   • Use --no-ai if Python < 3.10

2. Verify test structure:

   # Good: Clear sequential steps
   def test_workflow():
       step1 = action1()  # Separated
       step2 = action2()  # Separated
       assert step2 == expected
   
   # Bad: Chained operations (harder to extract)
   def test_workflow():
       assert action2(action1()) == expected
   

3. For non-Python tests:

   • Add comments to indicate steps
   • Use clear variable assignments
   • Separate operations with blank lines

Limitations & Future Enhancements

Current Limitations

1. Language Support:

   • Deep analysis: Python only (AST-based)
   • Other languages: Heuristic extraction (less precise)

2. Complexity Detection:

   • Basic heuristics (step count, keywords)
   • No semantic complexity analysis

3. Prerequisite Detection:

   • Import-based only
   • Doesn't detect runtime dependencies

4. No Code Execution:

   • Cannot verify steps actually work
   • Relies on test passing status

Planned Enhancements (v2.7+)

• Multi-language AST Support (C3.8)

  • JavaScript/TypeScript via tree-sitter
  • Go via go/ast
  • Rust via syn

• Interactive Guides (C3.9)

  • Copy-to-clipboard buttons
  • Live code execution (via Jupyter)
  • Step-by-step navigator

• Video Generation (C3.10)

  • Animated step diagrams
  • Screen recordings from workflows
  • Voiceover explanations

• Diagram Integration (C3.11)

  • Workflow flowcharts (Mermaid)
  • Architecture diagrams
  • Data flow visualizations

Examples

Example 1: User Management Workflow

Input (test file):

def test_user_creation_workflow():
    """Complete user creation and verification workflow"""
    # Setup database
    db = Database('test.db')

    # Create user
    user = User(name='Alice', email='alice@example.com')
    db.save(user)

    # Verify user exists
    saved_user = db.get_user('Alice')
    assert saved_user.email == 'alice@example.com'

    # Update user
    saved_user.email = 'alice@newemail.com'
    db.update(saved_user)

    # Verify update
    updated_user = db.get_user('Alice')
    assert updated_user.email == 'alice@newemail.com'

Output Guide:

# How To: Create and Manage Users in Database

**Difficulty**: Beginner
**Estimated Time**: 15 minutes
**Tags**: user, database, crud

## Overview

This guide demonstrates a complete user management workflow including
creation, verification, and updates using a database.

## Prerequisites

- [ ] Database configured and accessible
- [ ] User model imported

**Required Modules:**
- `from myapp import Database, User`

## Step-by-Step Guide

### Step 1: Initialize database connection

```python
db = Database('test.db')

Expected Result: Database connection established

Step 2: Create user object

user = User(name='Alice', email='alice@example.com')
db.save(user)

Expected Result: User saved to database

Verification:

saved_user = db.get_user('Alice')
assert saved_user.email == 'alice@example.com'

Step 3: Update user information

saved_user.email = 'alice@newemail.com'
db.update(saved_user)

Expected Result: User record updated

Verification:

updated_user = db.get_user('Alice')
assert updated_user.email == 'alice@newemail.com'

Complete Example

[Full working code here...]

Next Steps

• Delete User Workflow
• Bulk User Operations

### Example 2: API Integration

**Input:**
```python
def test_api_integration_workflow():
    """Test complete API integration flow"""
    # Authenticate
    client = APIClient(base_url='https://api.example.com')
    token = client.authenticate(username='admin', password='secret')

    # Make authenticated request
    response = client.get('/users', headers={'Authorization': f'Bearer {token}'})
    assert response.status_code == 200

    # Parse and validate response
    users = response.json()
    assert len(users) > 0
    assert 'id' in users[0]
    assert 'name' in users[0]

Generated Guide: Step-by-step authentication and API request guide with verification at each step.

Performance

Benchmark Results

Test Set: Skill_Seekers own test suite

• 54 test files
• 700+ total tests
• 50+ workflow examples

Performance:

Memory: ~40 MB peak

Optimization Tips

1. Disable AI for speed:

   skill-seekers-how-to-guides examples.json --no-ai  # 2x faster
   

2. Use simpler grouping:

   # file-path is faster than ai-tutorial-group
   skill-seekers-how-to-guides examples.json --group-by file-path
   

3. Filter input examples:

   # Only high-confidence workflows
   jq '.examples[] | select(.category == "workflow" and .confidence >= 0.8)' \
     examples.json > filtered.json
   

Testing

Run comprehensive test suite:

# All how-to guide tests (21 tests)
pytest tests/test_how_to_guide_builder.py -v

# Specific test categories
pytest tests/test_how_to_guide_builder.py::TestWorkflowAnalyzer -v
pytest tests/test_how_to_guide_builder.py::TestWorkflowGrouper -v
pytest tests/test_how_to_guide_builder.py::TestGuideGenerator -v
pytest tests/test_how_to_guide_builder.py::TestHowToGuideBuilder -v
pytest tests/test_how_to_guide_builder.py::TestEndToEnd -v

# Coverage report
pytest tests/test_how_to_guide_builder.py --cov=skill_seekers.cli.how_to_guide_builder

Test Coverage: 21 tests covering all components

Summary

C3.3 How-To Guide Generation provides:

✅ Automatic tutorial generation from test workflows ✅ 21 comprehensive tests - all passing ✅ 4 intelligent grouping strategies including AI-based ✅ Multi-language support (Python + 8 others) ✅ Rich markdown output with prerequisites, steps, verification ✅ MCP tool integration for Claude Code ✅ Complexity assessment for progressive learning ✅ Complete integration with C3.2 and C3.6

Next in Series:

• C3.4: Configuration Pattern Extraction
• C3.5: Architectural Overview Generation
• C3.6: AI-Powered Enhancement
• C3.7: Enhanced Documentation Generation

Get Started:

# Quick start
skill-seekers analyze tests/ --output output/codebase/

# Check your new guides
cat output/codebase/tutorials/index.md