docs/
|
+-- index.md                              # Landing page / documentation home
|
+-- tutorials/                            # LEARNING-ORIENTED
|   |
|   +-- index.md                          # Tutorials overview
|   |
|   +-- getting-started/                  # Level 1: Beginner Tutorials
|   |   +-- index.md                      # Getting started overview
|   |   +-- prerequisites.md              # Environment preparation
|   |   +-- installation.md               # Step-by-step installation
|   |   +-- your-first-run.md             # First babysitter execution
|   |   +-- understanding-results.md      # Reading run output and artifacts
|   |
|   +-- building-features/                # Level 2: Intermediate Tutorials
|   |   +-- index.md                      # Building features overview
|   |   +-- tdd-calculator.md             # Build calculator with TDD
|   |   +-- todo-api.md                   # Build a todo API end-to-end
|   |   +-- auth-feature.md               # Add authentication with TDD
|   |   +-- refactoring-legacy.md         # Refactor legacy code safely
|   |
|   +-- advanced-projects/                # Level 3: Advanced Tutorials
|       +-- index.md                      # Advanced projects overview
|       +-- ci-integration-tutorial.md    # GitHub Actions integration project
|       +-- team-onboarding.md            # Onboard your team tutorial
|       +-- custom-process-tutorial.md    # Create your first custom process
|
+-- how-to/                               # TASK-ORIENTED
|   |
|   +-- index.md                          # How-to guides overview
|   |
|   +-- workflows/                        # Workflow How-tos
|   |   +-- index.md                      # Workflows overview
|   |   +-- resume-interrupted-work.md    # Resume after session ends
|   |   +-- manage-multiple-runs.md       # Work with several concurrent runs
|   |   +-- review-run-history.md         # Analyze past runs via journal
|   |   +-- cancel-running-workflow.md    # Stop a workflow in progress
|   |
|   +-- quality/                          # Quality Management How-tos
|   |   +-- index.md                      # Quality management overview
|   |   +-- set-quality-targets.md        # Configure quality thresholds
|   |   +-- tune-iteration-limits.md      # Optimize max iterations
|   |   +-- customize-scoring.md          # Adjust quality scoring criteria
|   |   +-- debug-quality-issues.md       # When quality doesn't converge
|   |
|   +-- integration/                      # Integration How-tos
|   |   +-- index.md                      # Integration overview
|   |   +-- github-actions.md             # GitHub Actions CI/CD
|   |   +-- gitlab-ci.md                  # GitLab CI integration
|   |   +-- jenkins.md                    # Jenkins pipeline integration
|   |   +-- scripting-with-cli.md         # Bash/shell automation
|   |   +-- node-sdk-automation.md        # Node.js programmatic use
|   |
|   +-- methodologies/                    # Methodology How-tos
|   |   +-- index.md                      # Methodologies overview
|   |   +-- use-tdd-workflow.md           # TDD quality convergence
|   |   +-- use-gsd-workflow.md           # Get Shit Done rapid mode
|   |   +-- use-spec-kit.md               # Specification-driven workflow
|   |   +-- choose-methodology.md         # Select the right approach
|   |
|   +-- troubleshooting/                  # Troubleshooting How-tos
|   |   +-- index.md                      # Troubleshooting overview
|   |   +-- installation-issues.md        # Fix installation problems
|   |   +-- runtime-errors.md             # Resolve runtime issues
|   |   +-- breakpoint-issues.md          # Breakpoint not resolving
|   |   +-- performance-problems.md       # Slow iterations, memory issues
|   |   +-- journal-recovery.md           # Recover from journal corruption
|   |
|   +-- customization/                    # Customization How-tos
|       +-- index.md                      # Customization overview
|       +-- create-custom-process.md      # Build a process definition
|       +-- create-custom-hooks.md        # Develop lifecycle hooks
|       +-- create-team-templates.md      # Shared team process templates
|       +-- extend-quality-scoring.md     # Custom quality evaluators
|
+-- reference/                            # INFORMATION-ORIENTED
|   |
|   +-- index.md                          # Reference overview
|   |
|   +-- cli/                              # CLI Reference
|   |   +-- index.md                      # CLI overview
|   |   +-- run-create.md                 # run:create command
|   |   +-- run-iterate.md                # run:iterate command
|   |   +-- run-status.md                 # run:status command
|   |   +-- run-list.md                   # run:list command
|   |   +-- run-cancel.md                 # run:cancel command
|   |   +-- effects-get.md                # effects:get command
|   |   +-- effects-post.md               # effects:post command
|   |   +-- journal-commands.md           # journal:* commands
|   |   +-- global-options.md             # Global CLI flags
|   |   +-- exit-codes.md                 # Exit codes reference
|   |   +-- output-formats.md             # JSON/text output schemas
|   |
|   +-- api/                              # SDK API Reference
|   |   +-- index.md                      # API overview
|   |   +-- babysitter-class.md           # Main Babysitter class
|   |   +-- run-class.md                  # Run object API
|   |   +-- journal-api.md                # Journal access API
|   |   +-- effect-types.md               # Effect type specifications
|   |   +-- task-types.md                 # Task type specifications
|   |   +-- event-types.md                # Event type definitions
|   |
|   +-- configuration/                    # Configuration Reference
|   |   +-- index.md                      # Configuration overview
|   |   +-- environment-variables.md      # All env vars
|   |   +-- config-files.md               # Configuration file formats
|   |   +-- process-parameters.md         # Process definition parameters
|   |   +-- breakpoint-config.md          # Breakpoint service configuration
|   |
|   +-- file-structure/                   # File Structure Reference
|   |   +-- index.md                      # File structure overview
|   |   +-- run-directory.md              # .a5c/runs/<runId>/ structure
|   |   +-- journal-format.md             # Journal file format
|   |   +-- state-file.md                 # State.json specification
|   |   +-- artifact-types.md             # Artifact file types
|   |
|   +-- glossary.md                       # Complete terminology reference
|   +-- error-catalog.md                  # All error messages and solutions
|   +-- keyboard-shortcuts.md             # UI and CLI shortcuts
|   +-- version-history.md                # Changelog and migration guides
|
+-- explanation/                          # UNDERSTANDING-ORIENTED
|   |
|   +-- index.md                          # Explanation overview
|   |
|   +-- core-concepts/                    # Foundational Concepts
|   |   +-- index.md                      # Core concepts overview
|   |   +-- what-is-babysitter.md         # Introduction and positioning
|   |   +-- event-sourcing.md             # Event sourcing explained
|   |   +-- quality-convergence.md        # Iterative quality improvement
|   |   +-- human-in-the-loop.md          # Why human approval matters
|   |   +-- deterministic-execution.md    # Predictability and replay
|   |
|   +-- architecture/                     # Architecture Concepts
|   |   +-- index.md                      # Architecture overview
|   |   +-- system-architecture.md        # High-level system design
|   |   +-- journal-system.md             # Journal internals and design
|   |   +-- process-engine.md             # Process execution engine
|   |   +-- task-execution.md             # How tasks are executed
|   |   +-- breakpoint-architecture.md    # Breakpoint system design
|   |
|   +-- methodologies/                    # Methodology Concepts
|   |   +-- index.md                      # Methodology philosophy
|   |   +-- tdd-philosophy.md             # Why TDD with AI
|   |   +-- gsd-philosophy.md             # When speed matters
|   |   +-- spec-kit-philosophy.md        # Specification-driven rationale
|   |   +-- methodology-comparison.md     # Detailed comparison
|   |
|   +-- governance/                       # Governance and Compliance
|   |   +-- index.md                      # Governance overview
|   |   +-- audit-trails.md               # Audit trail design and usage
|   |   +-- compliance-patterns.md        # Meeting compliance requirements
|   |   +-- security-model.md             # Security boundaries and trust
|   |   +-- access-control.md             # Permission and access patterns
|   |
|   +-- best-practices/                   # Best Practices
|       +-- index.md                      # Best practices overview
|       +-- workflow-patterns.md          # Effective workflow patterns
|       +-- quality-optimization.md       # Optimizing for quality
|       +-- team-adoption.md              # Team rollout strategies
|       +-- process-design.md             # Custom process best practices

+------------------------------------------------------------------+
|  [Logo] Babysitter Docs                                           |
+------------------------------------------------------------------+
|  Tutorials  |  How-to Guides  |  Reference  |  Explanation  | [Search] |
+------------------------------------------------------------------+

TUTORIALS

Getting Started
  - Overview
  - Prerequisites
  - Installation
  - Your First Run
  - Understanding Results

Building Features
  - Overview
  - TDD Calculator
  - Todo API
  - Auth Feature
  - Refactoring Legacy Code

Advanced Projects
  - Overview
  - CI Integration Tutorial
  - Team Onboarding
  - Custom Process Tutorial

HOW-TO GUIDES

Workflows
  - Overview
  - Resume Interrupted Work
  - Manage Multiple Runs
  - Review Run History
  - Cancel Running Workflow

Quality Management
  - Overview
  - Set Quality Targets
  - Tune Iteration Limits
  - Customize Scoring
  - Debug Quality Issues

Integration
  - Overview
  - GitHub Actions
  - GitLab CI
  - Jenkins
  - Scripting with CLI
  - Node SDK Automation

Methodologies
  - Overview
  - Use TDD Workflow
  - Use GSD Workflow
  - Use Spec-Kit
  - Choose Methodology

Troubleshooting
  - Overview
  - Installation Issues
  - Runtime Errors
  - Breakpoint Issues
  - Performance Problems
  - Journal Recovery

Customization
  - Overview
  - Create Custom Process
  - Create Custom Hooks
  - Create Team Templates
  - Extend Quality Scoring

REFERENCE

CLI Reference
  - Overview
  - run:create
  - run:iterate
  - run:status
  - run:list
  - run:cancel
  - effects:get
  - effects:post
  - journal:* Commands
  - Global Options
  - Exit Codes
  - Output Formats

SDK API
  - Overview
  - Babysitter Class
  - Run Class
  - Journal API
  - Effect Types
  - Task Types
  - Event Types

Configuration
  - Overview
  - Environment Variables
  - Config Files
  - Process Parameters
  - Breakpoint Config

File Structure
  - Overview
  - Run Directory
  - Journal Format
  - State File
  - Artifact Types

Quick Reference
  - Glossary
  - Error Catalog
  - Keyboard Shortcuts
  - Version History

EXPLANATION

Core Concepts
  - Overview
  - What is Babysitter?
  - Event Sourcing
  - Quality Convergence
  - Human-in-the-Loop
  - Deterministic Execution

Architecture
  - Overview
  - System Architecture
  - Journal System
  - Process Engine
  - Task Execution
  - Breakpoint Architecture

Methodologies
  - Overview
  - TDD Philosophy
  - GSD Philosophy
  - Spec-Kit Philosophy
  - Methodology Comparison

Governance
  - Overview
  - Audit Trails
  - Compliance Patterns
  - Security Model
  - Access Control

Best Practices
  - Overview
  - Workflow Patterns
  - Quality Optimization
  - Team Adoption
  - Process Design

+---------------------------+
| [Hamburger] Babysitter    |
+---------------------------+
| [Search icon]             |
+---------------------------+

[Hamburger expanded:]
+---------------------------+
| Tutorials           [>]   |
| How-to Guides       [>]   |
| Reference           [>]   |
| Explanation         [>]   |
+---------------------------+
| Quick Links               |
| - Getting Started         |
| - CLI Reference           |
| - Glossary                |
+---------------------------+

+------------------------------------------------------------------+
| Tutorials          | How-to          | Reference    | Explanation |
| - Getting Started  | - Workflows     | - CLI        | - Concepts  |
| - Building         | - Quality       | - API        | - Architecture |
|   Features         | - Breakpoints   | - Config     | - Methodologies |
| - Advanced         | - Integration   | - Files      | - Governance |
|   Projects         | - Troubleshoot  | - Glossary   | - Best Practices |
+------------------------------------------------------------------+
| Resources                                                          |
| GitHub | Community | Blog | Changelog | Support                   |
+------------------------------------------------------------------+

TUTORIALS
|
+-- Level 1: Getting Started (Beginner)
|   |
|   +-- L1.1 Prerequisites
|   |   +-- Node.js requirements
|   |   +-- Claude Code setup
|   |   +-- Optional tools
|   |   +-- Knowledge checklist
|   |
|   +-- L1.2 Installation
|   |   +-- SDK installation
|   |   +-- Plugin installation
|   |   +-- Verification steps
|   |
|   +-- L1.3 Your First Run
|   |   +-- Starting Claude Code
|   |   +-- Running /babysitter:call command
|   |   +-- Observing iteration
|   |   +-- Viewing results
|   |
|   +-- L1.4 Understanding Results
|       +-- Run directory structure
|       +-- Reading the journal
|       +-- Viewing artifacts
|       +-- Quality scores
|
+-- Level 2: Building Features (Intermediate)
|   |
|   +-- L2.1 TDD Calculator
|   |   +-- Project setup
|   |   +-- Defining requirements
|   |   +-- Running TDD workflow
|   |   +-- Test-first iteration
|   |   +-- Quality convergence
|   |   +-- Final review
|   |
|   +-- L2.2 Todo API
|   |   +-- API design
|   |   +-- Database setup
|   |   +-- Endpoint creation
|   |   +-- Testing integration
|   |   +-- Breakpoint approval
|   |   +-- Deployment preparation
|   |
|   +-- L2.3 Auth Feature
|   |   +-- JWT concepts
|   |   +-- Security requirements
|   |   +-- TDD implementation
|   |   +-- Security review breakpoint
|   |   +-- Integration testing
|   |
|   +-- L2.4 Refactoring Legacy Code
|       +-- Analysis phase
|       +-- Test coverage first
|       +-- Incremental refactoring
|       +-- Quality validation
|       +-- Safe deployment
|
+-- Level 3: Advanced Projects (Expert)
    |
    +-- L3.1 CI Integration Tutorial
    |   +-- GitHub Actions setup
    |   +-- Workflow configuration
    |   +-- Automated quality gates
    |   +-- Breakpoint handling in CI
    |   +-- Reporting and notifications
    |
    +-- L3.2 Team Onboarding
    |   +-- Planning rollout
    |   +-- Creating team processes
    |   +-- Training materials
    |   +-- Governance setup
    |   +-- Success metrics
    |
    +-- L3.3 Custom Process Tutorial
        +-- Process definition basics
        +-- Task orchestration
        +-- Quality scoring
        +-- Breakpoint integration
        +-- Testing and deployment

HOW-TO GUIDES
|
+-- Workflows
|   +-- Resume Interrupted Work
|   |   +-- Identifying paused runs
|   |   +-- Resume command
|   |   +-- State verification
|   |
|   +-- Manage Multiple Runs
|   |   +-- Listing active runs
|   |   +-- Switching contexts
|   |   +-- Run isolation
|   |
|   +-- Review Run History
|   |   +-- Journal exploration
|   |   +-- Event filtering
|   |   +-- Artifact analysis
|   |
|   +-- Cancel Running Workflow
|       +-- Graceful cancellation
|       +-- Force stop
|       +-- Cleanup procedures
|
+-- Quality Management
|   +-- Set Quality Targets
|   |   +-- Target selection
|   |   +-- Per-process configuration
|   |   +-- Dynamic adjustment
|   |
|   +-- Tune Iteration Limits
|   |   +-- Max iterations setting
|   |   +-- Early exit conditions
|   |   +-- Performance balance
|   |
|   +-- Customize Scoring
|   |   +-- Scoring criteria
|   |   +-- Weight adjustment
|   |   +-- Custom evaluators
|   |
|   +-- Debug Quality Issues
|       +-- Score analysis
|       +-- Iteration review
|       +-- Target adjustment
|
|
+-- Integration
|   +-- GitHub Actions
|   |   +-- Workflow file setup
|   |   +-- Secrets configuration
|   |   +-- Job definitions
|   |   +-- Artifact handling
|   |
|   +-- GitLab CI
|   |   +-- .gitlab-ci.yml setup
|   |   +-- Variables configuration
|   |   +-- Stage definitions
|   |
|   +-- Jenkins
|   |   +-- Jenkinsfile creation
|   |   +-- Credentials setup
|   |   +-- Pipeline stages
|   |
|   +-- Scripting with CLI
|   |   +-- Bash patterns
|   |   +-- JSON parsing
|   |   +-- Error handling
|   |
|   +-- Node SDK Automation
|       +-- SDK installation
|       +-- Programmatic usage
|       +-- Event handling
|
+-- Methodologies
|   +-- Use TDD Workflow
|   |   +-- Process selection
|   |   +-- Configuration
|   |   +-- Execution
|   |
|   +-- Use GSD Workflow
|   |   +-- When to use GSD
|   |   +-- Configuration
|   |   +-- Speed optimization
|   |
|   +-- Use Spec-Kit
|   |   +-- Specification input
|   |   +-- Configuration
|   |   +-- Validation
|   |
|   +-- Choose Methodology
|       +-- Decision criteria
|       +-- Comparison table
|       +-- Recommendations
|
+-- Troubleshooting
|   +-- Installation Issues
|   |   +-- CLI not found
|   |   +-- Plugin not appearing
|   |   +-- Version mismatches
|   |
|   +-- Runtime Errors
|   |   +-- Session timeouts
|   |   +-- API errors
|   |   +-- Memory issues
|   |
|   +-- Breakpoint Issues
|   |   +-- Service not starting
|   |   +-- Approval not resolving
|   |   +-- Connection problems
|   |
|   +-- Performance Problems
|   |   +-- Slow iterations
|   |   +-- High memory usage
|   |   +-- Large journal files
|   |
|   +-- Journal Recovery
|       +-- Corruption detection
|       +-- State rebuild
|       +-- Manual recovery
|
+-- Customization
    +-- Create Custom Process
    |   +-- Process structure
    |   +-- Task definitions
    |   +-- Testing
    |
    +-- Create Custom Hooks
    |   +-- Hook types
    |   +-- Implementation
    |   +-- Registration
    |
    +-- Create Team Templates
    |   +-- Template design
    |   +-- Parameterization
    |   +-- Distribution
    |
    +-- Extend Quality Scoring
        +-- Evaluator interface
        +-- Custom metrics
        +-- Integration

REFERENCE
|
+-- CLI Reference
|   +-- run:create
|   |   +-- Synopsis
|   |   +-- Options
|   |   +-- Examples
|   |   +-- Exit codes
|   |
|   +-- run:iterate
|   |   +-- Synopsis
|   |   +-- Options
|   |   +-- Examples
|   |   +-- Exit codes
|   |
|   +-- run:status
|   |   +-- Synopsis
|   |   +-- Options
|   |   +-- Output format
|   |
|   +-- run:list
|   |   +-- Synopsis
|   |   +-- Filtering options
|   |   +-- Output format
|   |
|   +-- run:cancel
|   |   +-- Synopsis
|   |   +-- Options
|   |   +-- Behavior
|   |
|   +-- effects:get
|   |   +-- Synopsis
|   |   +-- Options
|   |   +-- Output format
|   |
|   +-- effects:post
|   |   +-- Synopsis
|   |   +-- Options
|   |   +-- Input format
|   |
|   +-- journal:* Commands
|   |   +-- journal:list
|   |   +-- journal:get
|   |   +-- journal:export
|   |
|   +-- Global Options
|   |   +-- --help
|   |   +-- --version
|   |   +-- --json
|   |   +-- --verbose
|   |   +-- --cwd
|   |
|   +-- Exit Codes
|   |   +-- Success codes
|   |   +-- Error codes
|   |   +-- Signal handling
|   |
|   +-- Output Formats
|       +-- JSON schema
|       +-- Text format
|       +-- Table format
|
+-- SDK API Reference
|   +-- Babysitter Class
|   |   +-- Constructor
|   |   +-- Methods
|   |   +-- Properties
|   |   +-- Events
|   |
|   +-- Run Class
|   |   +-- Properties
|   |   +-- Methods
|   |   +-- State transitions
|   |
|   +-- Journal API
|   |   +-- Reading events
|   |   +-- Writing events
|   |   +-- Querying
|   |
|   +-- Effect Types
|   |   +-- TaskEffect
|   |   +-- BreakpointEffect
|   |   +-- SleepEffect
|   |
|   +-- Task Types
|   |   +-- AgentTask
|   |   +-- SkillTask
|   |   +-- NodeTask
|   |   +-- ShellTask
|   |
|   +-- Event Types
|       +-- RunCreated
|       +-- IterationStarted
|       +-- EffectRequested
|       +-- EffectCompleted
|       +-- RunCompleted
|
+-- Configuration Reference
|   +-- Environment Variables
|   |   +-- BABYSITTER_*
|   |   +-- A5C_*
|   |   +-- NODE_*
|   |
|   +-- Config Files
|   |   +-- .a5c/config.json
|   |   +-- Process config
|   |   +-- Breakpoint config
|   |
|   +-- Process Parameters
|   |   +-- Required parameters
|   |   +-- Optional parameters
|   |   +-- Parameter types
|   |
|   +-- Breakpoint Config
|       +-- Service settings
|       +-- UI settings
|       +-- Notification settings
|
+-- File Structure Reference
|   +-- Run Directory
|   |   +-- Directory layout
|   |   +-- File purposes
|   |   +-- Lifecycle
|   |
|   +-- Journal Format
|   |   +-- File naming
|   |   +-- Event structure
|   |   +-- Ordering guarantees
|   |
|   +-- State File
|   |   +-- Schema
|   |   +-- Derivation rules
|   |   +-- Caching behavior
|   |
|   +-- Artifact Types
|       +-- Plans
|       +-- Reports
|       +-- Specs
|       +-- Logs
|
+-- Quick Reference
    +-- Glossary
    |   +-- A-Z term definitions
    |   +-- Related term links
    |
    +-- Error Catalog
    |   +-- Error codes
    |   +-- Error messages
    |   +-- Resolution steps
    |
    +-- Keyboard Shortcuts
    |   +-- CLI shortcuts
    |   +-- UI shortcuts
    |
    +-- Version History
        +-- Changelog
        +-- Migration guides
        +-- Deprecation notices

EXPLANATION
|
+-- Core Concepts
|   +-- What is Babysitter?
|   |   +-- Problem statement
|   |   +-- Solution overview
|   |   +-- Key differentiators
|   |   +-- Use case examples
|   |
|   +-- Event Sourcing
|   |   +-- What is event sourcing?
|   |   +-- Benefits for AI workflows
|   |   +-- Journal as source of truth
|   |   +-- State derivation
|   |   +-- Replay and recovery
|   |
|   +-- Quality Convergence
|   |   +-- The iteration loop
|   |   +-- Quality scoring
|   |   +-- Convergence criteria
|   |   +-- When to stop iterating
|   |
|   +-- Human-in-the-Loop
|   |   +-- Why human approval matters
|   |   +-- Breakpoint philosophy
|   |   +-- Trust and automation balance
|   |   +-- Use case patterns
|   |
|   +-- Deterministic Execution
|       +-- Reproducibility goals
|       +-- Journal-based replay
|       +-- Non-determinism handling
|       +-- Testing implications
|
+-- Architecture
|   +-- System Architecture
|   |   +-- Component overview
|   |   +-- Data flow
|   |   +-- Integration points
|   |   +-- Deployment options
|   |
|   +-- Journal System
|   |   +-- Design principles
|   |   +-- Append-only guarantees
|   |   +-- Event ordering
|   |   +-- Storage considerations
|   |
|   +-- Process Engine
|   |   +-- Process lifecycle
|   |   +-- Effect scheduling
|   |   +-- Dependency management
|   |   +-- Error handling
|   |
|   +-- Task Execution
|   |   +-- Task types deep dive
|   |   +-- Execution environment
|   |   +-- Result handling
|   |   +-- Retry behavior
|   |
|   +-- Breakpoint Architecture
|       +-- Service design
|       +-- Resolution flow
|       +-- Persistence
|       +-- Multi-approver patterns
|
+-- Methodologies
|   +-- TDD Philosophy
|   |   +-- Test-first rationale
|   |   +-- AI and TDD synergy
|   |   +-- Quality through tests
|   |   +-- When TDD works best
|   |
|   +-- GSD Philosophy
|   |   +-- Speed over perfection
|   |   +-- Appropriate use cases
|   |   +-- Trade-offs
|   |
|   +-- Spec-Kit Philosophy
|   |   +-- Specification-driven development
|   |   +-- Contract-first approach
|   |   +-- Validation strategies
|   |
|   +-- Methodology Comparison
|       +-- Feature matrix
|       +-- Use case mapping
|       +-- Decision framework
|       +-- Hybrid approaches
|
+-- Governance
|   +-- Audit Trails
|   |   +-- Compliance requirements
|   |   +-- What is logged
|   |   +-- Retention policies
|   |   +-- Access patterns
|   |
|   +-- Compliance Patterns
|   |   +-- SOC 2 considerations
|   |   +-- GDPR implications
|   |   +-- Industry-specific guidance
|   |
|   +-- Security Model
|   |   +-- Trust boundaries
|   |   +-- Data handling
|   |   +-- Network security
|   |   +-- Secret management
|   |
|   +-- Access Control
|       +-- Permission model
|       +-- Role definitions
|       +-- Enforcement points
|
+-- Best Practices
    +-- Workflow Patterns
    |   +-- Effective prompting
    |   +-- Iteration optimization
    |   +-- Breakpoint placement
    |
    +-- Quality Optimization
    |   +-- Target setting
    |   +-- Scoring tuning
    |   +-- Convergence acceleration
    |
    +-- Team Adoption
    |   +-- Rollout strategies
    |   +-- Training approaches
    |   +-- Success metrics
    |
    +-- Process Design
        +-- Reusable patterns
        +-- Parameterization
        +-- Testing processes
        +-- Versioning

Home > Category > Section > Page

<nav aria-label="Breadcrumb" class="breadcrumb">
  <ol itemscope itemtype="https://schema.org/BreadcrumbList">
    <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
      <a itemprop="item" href="/docs/">
        <span itemprop="name">Docs</span>
      </a>
      <meta itemprop="position" content="1" />
    </li>
    <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
      <a itemprop="item" href="/docs/tutorials/">
        <span itemprop="name">Tutorials</span>
      </a>
      <meta itemprop="position" content="2" />
    </li>
    <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
      <a itemprop="item" href="/docs/tutorials/getting-started/">
        <span itemprop="name">Getting Started</span>
      </a>
      <meta itemprop="position" content="3" />
    </li>
    <li itemprop="itemListElement" itemscope itemtype="https://schema.org/ListItem">
      <span itemprop="name"><strong>Installation</strong></span>
      <meta itemprop="position" content="4" />
    </li>
  </ol>
</nav>

The [journal system](../explanation/architecture/journal-system.md) stores all events
as append-only records.

> **Learn More**
>
> To understand why Babysitter uses event sourcing, see
> [Event Sourcing Explained](../explanation/core-concepts/event-sourcing.md).

## Prerequisites

Before starting this tutorial, ensure you have:
- Completed [Installation](./installation.md)
- Read [Your First Run](./your-first-run.md)
- Basic understanding of [TDD concepts](../explanation/methodologies/tdd-philosophy.md)

## Next Steps

Now that you've completed your first run:
- **Continue learning:** [Understanding Results](./understanding-results.md)
- **Build something:** [TDD Calculator Tutorial](../building-features/tdd-calculator.md)
- **Go deeper:** [Event Sourcing Explained](../explanation/core-concepts/event-sourcing.md)

---

## See Also

- [Quality Convergence](../explanation/core-concepts/quality-convergence.md) - Understand how quality targets work
- [Set Quality Targets](../how-to/quality/set-quality-targets.md) - Configure targets for your projects
- [Debug Quality Issues](../how-to/troubleshooting/debug-quality-issues.md) - When quality doesn't converge

---
title: [Tutorial Title]
description: [One-sentence description]
category: tutorial
level: beginner | intermediate | advanced
estimated_time: [X minutes]
prerequisites:
  - [list of prerequisite pages]
personas:
  - [primary personas]
---

# [Tutorial Title]

**Time:** [X minutes] | **Level:** [Beginner/Intermediate/Advanced]

## What You'll Learn

By the end of this tutorial, you will be able to:
- [Learning objective 1]
- [Learning objective 2]
- [Learning objective 3]

## Prerequisites

Before starting, ensure you have:
- [ ] [Prerequisite 1 with link]
- [ ] [Prerequisite 2 with link]

## What We're Building

[Brief description of the project/outcome, with screenshot or diagram if applicable]

---

## Step 1: [Action Title]

[Explanation of what we're doing and why]

**What you should see:**

> **Note:** [Helpful tip or common mistake to avoid]

---

## Step 2: [Action Title]

[Continue pattern...]

---

## Step [N]: [Final Action]

[Final step...]

---

## Summary

You've successfully:
- [Accomplishment 1]
- [Accomplishment 2]
- [Accomplishment 3]

## Next Steps

- **Continue learning:** [Next tutorial link]
- **Apply this:** [Related how-to link]
- **Go deeper:** [Related explanation link]

## Troubleshooting

### [Common Issue 1]

**Symptom:** [What the user sees]

**Solution:** [How to fix it]

### [Common Issue 2]

[Continue pattern...]

---

## See Also

- [Related page 1]
- [Related page 2]

---
title: How to [Task]
description: [One-sentence description of what this achieves]
category: how-to
section: [workflows|quality|breakpoints|integration|methodologies|troubleshooting|customization]
personas:
  - [primary personas]
---

# How to [Task]

[One paragraph explaining what this guide helps you accomplish and when you'd need it]

## Prerequisites

- [Prerequisite 1]
- [Prerequisite 2]

## Steps

### 1. [First Action]

[Brief explanation]

### 2. [Second Action]

[Brief explanation]

### 3. [Continue as needed...]

---

## Variations

### [Variation 1: Different Scenario]

[Adjusted steps for this scenario]

### [Variation 2: Alternative Approach]

[Adjusted steps for this approach]

---

## Verification

To confirm success:

Expected result: [what indicates success]

---

## Common Issues

| Issue | Cause | Solution |
|-------|-------|----------|
| [Issue 1] | [Cause] | [Solution] |
| [Issue 2] | [Cause] | [Solution] |

---

## Related Guides

- [Related how-to 1]
- [Related how-to 2]

## Reference

- [CLI command reference]
- [Configuration reference]

---
title: [Reference Item Name]
description: [Brief technical description]
category: reference
section: [cli|api|configuration|file-structure]
---

# [Reference Item Name]

[One-paragraph technical description]

## Synopsis

## [Options/Parameters/Properties]

| Name | Type | Required | Default | Description |
|------|------|----------|---------|-------------|
| `[name]` | [type] | [Yes/No] | [default] | [Description] |
| `[name]` | [type] | [Yes/No] | [default] | [Description] |

## [Return Value/Output]

[Description of what is returned or output]

### [Format 1: JSON]

### [Format 2: Text]

## Examples

### Basic Usage

Output:

### [Specific Use Case]

## [Exit Codes / Error Handling]

| Code | Meaning |
|------|---------|
| [code] | [meaning] |

## [Related / See Also]

- [Related reference 1]
- [Related reference 2]
- [How-to guide using this]

---
title: [Concept Name]
description: [One-sentence description]
category: explanation
section: [core-concepts|architecture|methodologies|governance|best-practices]
personas:
  - [primary personas]
---

# [Concept Name]

[Opening paragraph that establishes context and importance]

## Overview

[High-level explanation accessible to all readers]

## [Core Concept Section 1]

[Detailed explanation with examples]

### [Subsection if needed]

[Further detail]

## [Core Concept Section 2]

[Continue pattern...]

## How It Works

[Technical explanation with diagrams if helpful]

## Why This Matters

[Explanation of importance and benefits]

### [Benefit 1]

[Explanation]

### [Benefit 2]

[Explanation]

## Trade-offs and Alternatives

[Discussion of trade-offs, when this approach isn't ideal, alternatives]

| Approach | Pros | Cons |
|----------|------|------|
| [Approach 1] | [Pros] | [Cons] |
| [Approach 2] | [Pros] | [Cons] |

## Practical Applications

[How to apply this understanding]

- **[Scenario 1]:** [Application]
- **[Scenario 2]:** [Application]

## Further Reading

- [Internal link to related explanation]
- [Internal link to how-to guide]
- [External resource if appropriate]

---

## Summary

[Key takeaways in 2-3 sentences]

### [Term]

**Definition:** [Clear, concise definition in one sentence]

**Context:** [Where/how this term is used in Babysitter]

**Example:** [Brief example of usage]

**Related Terms:** [Link to related glossary entries]

**Learn More:** [Link to explanation page if available]

### [Error Code/Message]

**Error Message:**

**Cause:** [What causes this error]

**Solution:**
1. [Step 1]
2. [Step 2]

**Prevention:** [How to avoid this error]

**Related:** [Link to relevant documentation]

---
title: [Page Title]                    # Required
description: [SEO description]          # Required, max 160 chars
category: [tutorial|how-to|reference|explanation]  # Required
level: [beginner|intermediate|advanced] # Required for tutorials
section: [section-name]                 # Required for how-to and reference
estimated_time: [X minutes]             # Required for tutorials
prerequisites:                          # Recommended
  - [prerequisite-slug]
personas:                               # Recommended
  - sarah-chen
  - james-park
last_updated: [YYYY-MM-DD]             # Required
---

> **Version Note:** This feature requires Babysitter v1.2.0 or later.