Process Library

<!-- process-library:lead:start --> The Babysitter Process Library is the SDK-managed library under `library/`. The current generated snapshot counts **2,239 JavaScript process files**, including **149 methodology files**, **2,038 specialization files**, and **31 shared process files**, plus support assets such as **2,021 skills** and **1,342 agents** discovered in the live tree. <!-- process-library:lead:end -->

---

In Plain English

<!-- process-library:plain-english:start -->

<!-- process-library:plain-english:end -->

**Think of the Process Library like a cookbook with 2,239 recipes in the live repository tree.**

Just like how a cookbook has recipes for Italian, Mexican, Japanese, and French cuisine - the Process Library has "recipes" for building web apps, mobile apps, APIs, security audits, and much more.

**You don't need to read the whole cookbook.** Just tell Babysitter what you want to make:

- "Build me a REST API" → Babysitter picks the right recipe automatically

- "Use the TDD methodology" → You pick a specific recipe

Each recipe includes:

- **Ingredients** (inputs you provide)

- **Steps** (phases of work)

- **Quality checks** (tests to ensure it's done right)

- **Approval points** (places where you review before continuing)

---

Quick Start: Using the Library

**Most users never need to browse the library directly.** Just describe what you want:

/babysitter:call build a user authentication system with login, registration, and password reset

Babysitter automatically finds and combines the right processes. Want a specific methodology?

/babysitter:call with TDD methodology, create a REST API for managing tasks

That's it! See the sections below for details on what's available.

---

What is the Process Library?

The Process Library provides ready-to-use orchestration workflows for virtually any task you might encounter. Each process is:

• **Battle-tested**: Designed with best practices and quality gates built-in
• **Composable**: Can be combined with other processes to create complex workflows
• **Customizable**: Extend or modify any process to match your requirements
• **Self-documenting**: Includes clear inputs, outputs, and execution flow

Instead of writing orchestration logic from scratch, you can leverage these pre-built processes and focus on what matters: your actual work.

How Babysitter Uses the Process Library

When you describe a task to Babysitter, the agent **automatically selects the most relevant processes** from the library and adapts them to your specific needs. This happens in several ways:

Automatic Process Selection

Simply describe what you want to accomplish in natural language:

Use babysitter to build a Next.js app with authentication and PostgreSQL

Babysitter will: 1. Identify relevant processes (e.g., nextjs-fullstack-app, jwt-authentication, database-setup) 2. Combine and adapt them to your requirements 3. Execute the orchestrated workflow with quality gates

Explicit Process Selection

You can also request a specific process by name:

Use babysitter with the tdd-quality-convergence process to implement user authentication

Or:

Use babysitter with the devin methodology to build a REST API

Mix and Match

For complex tasks, Babysitter intelligently combines multiple processes:

Use babysitter to create a microservices architecture with:
- GraphQL gateway
- Kubernetes deployment
- Monitoring and alerting

This might pull from graphql-api-apollo, kubernetes-setup, monitoring-setup, and cicd-pipeline-setup processes, adapting each to work together coherently.

Customizing for Your Use Case

You can also modify existing processes or provide additional context:

Use babysitter with the security-audit process but focus specifically on
OWASP Top 10 vulnerabilities and include PCI-DSS compliance checks

The agent will take the base process and adapt it to your specific requirements.

Library Structure

The built-in library lives under `library/`. Harness plugins do **not** ship the whole process tree under skills/babysit/; instead, they expose the babysit skill and rely on the SDK-managed active process-library binding. Project-local copies under .a5c/ are an override layer that can be created by plugins or by you.

How The Layers Relate

1. **Built-in library**: `library/` is the canonical source tree for built-in processes, methodologies, shared components, references, and examples. 2. **Plugin package**: the harness plugin ships skills, hooks, and packaging files such as `plugins/babysitter-unified/skills/babysit/SKILL.md`, then asks the SDK which process-library binding is active. 3. **Project-local .a5c/ copies**: files like .a5c/processes/, .a5c/skills/, and .a5c/agents/ inside a workspace override the shared library when present.

Active Lookup Order

Babysitter process discovery should prefer:

1. Project-local .a5c/processes/ 2. The SDK-managed active process-library binding resolved by babysitter process-library:active --json 3. Other installed skill/plugin roots only as compatibility fallback

Main Library Areas

Click any link to view the current source location:

Specializations Sub-Structure

Browsing and Discovering Processes

Asking Claude

The easiest way to discover processes is to ask Claude:

What processes are available for web development?

Show me security-related processes in the babysitter library

Claude can browse the process library and recommend the best match for your needs.

Process Naming Convention

Process files follow a consistent naming pattern:

• feature-name.js - The process definition
• README.md - Category documentation
• examples/ - Example inputs and usage
• agents/ - Specialized agents for the category

Finding the Right Process

1. **Start with the category** that matches your domain 2. **Review the README.md** in that category for an overview 3. **Check the JSDoc** at the top of each .js file for inputs/outputs 4. **Look at examples/** for sample usage patterns

Generated Catalog Snapshot

The catalog data in this section is refreshed from the live library/ tree. The explanatory prose on this page remains hand-written.

<!-- process-library:catalog:start --> Snapshot refreshed from the live library/ tree on 2026-05-07.

• Current snapshot counts
• Methodology families
• Shared process groups
• Development and technical specializations
• Business domains
• Science domains
• Social sciences and humanities domains
• Largest specialization categories

Current Snapshot Counts

Methodology Families

Shared Process Groups

Development and Technical Specializations

Business Domains

Science Domains

Social Sciences and Humanities Domains

Largest Specialization Categories

<!-- process-library:catalog:end -->

Example Processes by Category

Web Development

Browse all web-development processes →

AI Agents and Conversational

Browse all ai-agents-conversational processes →

Security Research

Browse all security-research processes →

DevOps and SRE

Browse all devops-sre-platform processes →

Scientific Discovery

Browse all scientific-discovery processes →

Using a Pre-Built Process

**Recommended: Just use /babysitter:call <request>** - it selects the right process automatically:

/babysitter:call build a Next.js app with authentication, PostgreSQL database, and Vercel deployment

Babysitter will find the nextjs-fullstack-app process and configure it based on your request.

Customizing Processes

Extending an Existing Process

import { process as baseProcess } from '../../../library/specializations/web-development/nextjs-fullstack-app.js';

export async function process(inputs, ctx) {
  // Add pre-processing
  const enhancedInputs = {
    ...inputs,
    additionalChecks: true,
    customConfig: myConfig
  };

  // Run base process
  const result = await baseProcess(enhancedInputs, ctx);

  // Add post-processing
  await ctx.task(myCustomValidation, result);

  return {
    ...result,
    customData: myCustomData
  };
}

Composing Multiple Processes

import { process as planPhase } from '../../../library/methodologies/gsd/plan-phase.js';
import { process as executePhase } from '../../../library/methodologies/gsd/execute-phase.js';
import { process as tddConvergence } from '../../../library/tdd-quality-convergence.js';

export async function process(inputs, ctx) {
  // Planning with GSD
  const plan = await planPhase(inputs, ctx);

  // Execute with TDD quality gates
  const implementation = await tddConvergence({
    ...inputs,
    plan: plan.tasks,
    targetQuality: 90
  }, ctx);

  // Verify with GSD
  const verification = await executePhase({
    ...inputs,
    tasks: implementation.artifacts
  }, ctx);

  return { plan, implementation, verification };
}

Modifying Process Parameters

Most processes accept configuration through inputs:

{
  "feature": "User authentication",
  "targetQuality": 95,
  "maxIterations": 10,
  "requirements": [
    "Support OAuth2",
    "Include MFA"
  ],
  "constraints": [
    "Must use existing user table",
    "No breaking API changes"
  ]
}

Best Practices

Choosing the Right Process

1. **Match your domain**: Start with the specialization that matches your work 2. **Check the methodology**: Consider which methodology fits your project style 3. **Review inputs carefully**: Understand what configuration options are available 4. **Read the examples**: Look at example inputs in the examples/ directories under library/

Customization Tips

1. **Start simple**: Use processes as-is before customizing 2. **Layer changes**: Extend rather than modify base processes 3. **Preserve breakpoints**: Keep human approval gates in critical paths 4. **Test incrementally**: Validate customizations with small inputs first

Quality Considerations

1. **Use quality convergence**: Processes with quality scoring help ensure high standards 2. **Enable breakpoints**: Human review catches issues early 3. **Compose methodologies**: Combine TDD with your domain process for better results 4. **Track iterations**: Monitor how many iterations processes require

See Also

• Process Definitions - How to create your own processes
• Quality Convergence - Quality gates and scoring
• Breakpoints - Human-in-the-loop approval
• Parallel Execution - Running tasks concurrently