Babysitter Process Selection Guide

A comprehensive guide to help you choose the right process/methodology for your project needs.

---

Quick Decision Tree

Use this text-based flowchart to quickly identify the best methodology for your needs:

                              START HERE
                                  |
                                  v
                    +-------------------------+
                    | Do you have existing    |
                    | codebase to work with?  |
                    +-------------------------+
                         |              |
                        YES            NO
                         |              |
                         v              v
         +---------------+        +----------------+
         | Brownfield    |        | Greenfield     |
         | Project       |        | (New Project)  |
         +---------------+        +----------------+
              |                         |
              v                         v
    +------------------+      +--------------------+
    | Need governance/ |      | What's your main   |
    | compliance?      |      | priority?          |
    +------------------+      +--------------------+
         |       |                     |
        YES     NO               +-----+-----+-----+
         |       |               |     |     |     |
         v       v               v     v     v     v
    +--------+ +--------+    Speed  Quality Gov  Team
    |Spec-Kit| |  GSD   |      |      |      |    |
    |Brown-  | |Codebase|      v      v      v    v
    |field   | |Mapping |   Ralph/  TDD   Spec- Scrum/
    +--------+ +--------+   Devin  QC     Kit   Agile
                                               Kanban

    Legend:
    - Spec-Kit Brownfield: Governance + existing code
    - GSD Codebase Mapping: Systematic brownfield analysis
    - Ralph/Devin: Quick iterations, autonomous coding
    - TDD QC: Test-driven development with quality gates
    - Spec-Kit: Full governance, enterprise requirements
    - Scrum/Agile/Kanban: Team coordination, sprints, flow

---

Quick Reference Table

---

Use Case Examples

"I want to build a new project from scratch"

**Recommended: GSD (Get Shit Done)**

GSD provides systematic project development with:

• Vision capture and research
• Phased milestone planning
• Parallel task execution
• UAT and verification loops

babysitter run:create \
  --process-id gsd/new-project \
  --entry library/methodologies/gsd/new-project.js#process \
  --inputs '{"projectName": "My New App"}'

**Also consider:** Spec-Kit if you need formal governance, or Devin for autonomous feature development.

---

"I want test-driven development with quality gates"

**Recommended: TDD Quality Convergence**

TDD Quality Convergence provides:

• Agent-based planning with TDD principles
• Red-Green-Refactor cycle
• Iterative quality scoring (0-100)
• Parallel quality checks (coverage, lint, types, security)
• Convergence until target quality reached

babysitter run:create \
  --process-id babysitter/tdd-quality-convergence \
  --entry library/tdd-quality-convergence.js#process \
  --inputs '{"feature": "User Authentication", "targetQuality": 90}'

**Also consider:** ATDD/TDD for simpler test-first workflows, or BDD for stakeholder collaboration.

---

"I have governance requirements and need formal specifications"

**Recommended: Spec-Kit**

Spec-Kit provides:

• Constitution with governance principles
• Executable specifications
• Quality checklists ("unit tests for English")
• Full audit trail

babysitter run:create \
  --process-id methodologies/spec-driven-development \
  --entry library/methodologies/spec-driven-development.js#process \
  --inputs '{"projectName": "Enterprise System", "developmentPhase": "greenfield"}'

**Variants:**

• spec-kit-constitution.js - Governance principles only
• spec-kit-quality-checklist.js - Quality validation
• spec-kit-brownfield.js - Adding to existing systems

---

"I want quick iterations with minimal ceremony"

**Recommended: Ralph or Devin**

**Ralph** - Simple persistent loop:

• Execute task until DONE signal
• Minimal overhead
• Good for autonomous completion

babysitter run:create \
  --process-id methodologies/ralph \
  --entry library/methodologies/ralph.js#process \
  --inputs '{"task": "Implement login feature", "maxIterations": 10}'

**Devin** - Plan-Code-Debug-Deploy:

• More structured than Ralph
• Includes quality scoring
• Deployment phase

babysitter run:create \
  --process-id methodologies/devin \
  --entry library/methodologies/devin.js#process \
  --inputs '{"feature": "Shopping Cart", "targetQuality": 85}'

---

"I need to coordinate a team with sprints"

**Recommended: Scrum or Agile**

Scrum/Agile provides:

• Product backlog management
• Sprint planning and execution
• Daily scrums, reviews, retrospectives
• Velocity tracking

babysitter run:create \
  --process-id methodologies/scrum \
  --entry library/methodologies/scrum/scrum.js#process \
  --inputs '{"projectName": "Team Project", "sprintDuration": 2, "sprintCount": 6}'

**Also consider:** Kanban for continuous flow without fixed sprints.

---

"I want continuous delivery without fixed iterations"

**Recommended: Kanban**

Kanban provides:

• Visual workflow management
• WIP limits and flow optimization
• Service classes for prioritization
• Continuous improvement

babysitter run:create \
  --process-id methodologies/kanban \
  --entry library/methodologies/kanban/kanban.js#process \
  --inputs '{"projectName": "DevOps Pipeline", "cycles": 10}'

---

"I want stakeholders involved in defining behavior"

**Recommended: BDD (Specification by Example)**

BDD provides:

• Discovery workshops with stakeholders
• Given-When-Then scenarios
• Living documentation
• Executable specifications

babysitter run:create \
  --process-id methodologies/bdd-specification-by-example \
  --entry library/methodologies/bdd-specification-by-example/bdd-process.js#process \
  --inputs '{"projectName": "E-commerce", "feature": "Checkout process"}'

---

"I'm building a complex domain with microservices"

**Recommended: Domain-Driven Design (DDD)**

DDD provides:

• Strategic design (subdomains, bounded contexts)
• Tactical design (entities, aggregates, services)
• Ubiquitous language
• Context mapping

babysitter run:create \
  --process-id methodologies/domain-driven-design \
  --entry library/methodologies/domain-driven-design/domain-driven-design.js#process \
  --inputs '{"projectName": "E-Commerce Platform", "complexity": "complex"}'

---

"I need to add features to an existing codebase"

**Recommended: Spec-Kit Brownfield or GSD Codebase Mapping**

**Spec-Kit Brownfield:**

• Analyzes existing patterns
• Infers or validates constitution
• Plans integration carefully

babysitter run:create \
  --process-id methodologies/spec-kit-brownfield \
  --entry library/methodologies/spec-kit-brownfield.js#process \
  --inputs '{"featureName": "2FA", "existingCodebase": "./src"}'

**GSD Codebase Mapping:**

• Architecture understanding
• Pattern identification
• Integration planning

babysitter run:create \
  --process-id gsd/map-codebase \
  --entry library/methodologies/gsd/map-codebase.js#process \
  --inputs '{"projectPath": "./src"}'

---

Methodology Descriptions

Core Methodologies

GSD (Get Shit Done)

Systematic project development preventing context degradation through:

• **Discuss Phase**: Capture implementation preferences
• **Plan Phase**: Research-informed task planning with verification
• **Execute Phase**: Parallel task execution with atomic commits
• **Verify Phase**: UAT and automated diagnosis

**Documentation:** gsd/README.md

---

Spec-Kit (Spec-Driven Development)

Executable specifications that drive implementation:

• **Constitution**: Governance principles and standards
• **Specification**: User stories with acceptance criteria
• **Plan**: Technical architecture and stack
• **Tasks**: Ordered, actionable implementation tasks
• **Quality Checklists**: "Unit tests for English"

**Documentation:** SPEC-KIT.md

---

TDD Quality Convergence

Test-driven development with iterative quality improvement:

• Agent-based planning with TDD principles
• Quality scoring across multiple dimensions
• Convergence loop until target quality reached
• Parallel quality checks

**Documentation:** tdd-quality-convergence.md

---

Devin Style

Autonomous software engineering workflow:

• **Plan**: Architecture and implementation strategy
• **Code**: Feature implementation
• **Debug**: Iterative test-fix cycles
• **Deploy**: Production deployment

---

Ralph Loop

Simple, persistent iteration loop:

• Execute task repeatedly until DONE signal
• Minimal ceremony and overhead
• Good for autonomous task completion

---

Agile Methodologies

Scrum

Iterative framework with defined roles and ceremonies:

• Sprint-based timeboxed iterations
• Product Owner, Scrum Master, Development Team
• Sprint Planning, Daily Scrum, Review, Retrospective
• Velocity tracking and burndown charts

---

Kanban

Continuous flow management:

• Visual workflow with WIP limits
• Pull-based system
• Service classes (Expedite, Standard, Fixed Date, Intangible)
• Cycle time and throughput metrics

---

Agile (General)

Sprint-based iterative development with:

• Product backlog management
• Sprint cycles with planning and review
• Continuous improvement through retrospectives

---

Specification & Design Methodologies

BDD (Specification by Example)

Collaborative approach capturing requirements as concrete examples:

• Discovery workshops with stakeholders
• Gherkin scenarios (Given-When-Then)
• Living documentation
• Executable specifications

**Documentation:** bdd-specification-by-example/README.md

---

Domain-Driven Design (DDD)

Strategic and tactical design for complex domains:

• Subdomain classification (Core, Supporting, Generic)
• Bounded contexts and context mapping
• Entities, Value Objects, Aggregates
• Domain events and services

**Documentation:** domain-driven-design/README.md

---

Example Mapping

Collaborative requirement discovery:

• Stories, Rules, Examples, Questions
• Workshop-based discovery
• Foundation for BDD scenarios

**Documentation:** example-mapping/README.md

---

Other Methodologies

---

Comparison Matrix

By Project Phase

By Team Size

By Certainty Level

By Quality Focus

---

Domain-Specific Process Selector

Choose based on your domain specialization:

Software Development

Data & AI

Operations & Infrastructure

Product & Design

Scientific & Engineering

---

Combining Methodologies

Many projects benefit from combining approaches:

Spec-Kit + TDD

// 1. Use Spec-Kit for requirements and planning
const spec = await runProcess('methodologies/spec-driven-development', { ... });

// 2. Use TDD QC for implementation
for (const task of spec.tasks) {
  await runProcess('babysitter/tdd-quality-convergence', {
    feature: task.title,
    targetQuality: 85
  });
}

DDD + BDD

// 1. Use DDD for strategic design
const design = await runProcess('methodologies/domain-driven-design', { ... });

// 2. Use BDD for each bounded context
for (const context of design.boundedContexts) {
  await runProcess('methodologies/bdd-specification-by-example', {
    feature: context.name
  });
}

GSD + Kanban

// 1. Use GSD for project initialization
const project = await runProcess('gsd/new-project', { ... });

// 2. Use Kanban for ongoing delivery
await runProcess('methodologies/kanban', {
  initialBacklog: project.roadmap.tasks
});

---

Documentation Links

Core Documentation

• Process Library README - Built-in library overview
• GSD README - Get Shit Done workflows
• GSD Quick Start - GSD quick reference
• Spec-Kit - Spec-driven development
• TDD Quality Convergence - Test-driven with quality gates

Methodology Documentation

• BDD/Specification by Example
• Domain-Driven Design
• Example Mapping
• Kanban
• Feature-Driven Development
• Hypothesis-Driven Development
• ATDD/TDD
• Jobs To Be Done

Domain Specializations

• Technical Documentation
• Data Science/ML
• DevOps/SRE
• Security/Compliance
• QA/Testing
• Software Architecture

---

Getting Started

1. **Identify your project type** using the decision tree above 2. **Review the quick reference table** to understand methodology trade-offs 3. **Read the detailed documentation** for your chosen methodology 4. **Start with examples** in the examples/ directories 5. **Iterate and combine** methodologies as your project evolves

---

**Version:** 1.0.0 **Last Updated:** 2026-02-03 **Plugin:** babysitter