Managing Background Jobs with gob

Overview

gob (Background Job Manager) runs tasks asynchronously while keeping context free. Essential for builds, tests, dev servers, and any long-running commands.

When to use:

• •User explicitly asks for "parallel" or "simultaneous" commands → use gob add for each
• •Long-running command that would block context → use gob add
• •Multiple independent commands to run at once → use gob add for each

Why gob over parallel Bash tool calls: gob provides job IDs, output capture, status monitoring, and proper process control. Parallel Bash calls just fire and forget.

CRITICAL: Parallel Command Requests

When user says "run X and Y in parallel" or "run two parallel builds":

# ✅ CORRECT: Use gob add for each command
gob add pnpm build
gob add pnpm build

# Then await results
gob await-any
gob await-any

# ❌ WRONG: Do NOT use parallel Bash tool calls
# Bash(pnpm build) + Bash(pnpm build) in same message

Why this matters: Parallel Bash tool calls work but provide no job management. gob gives you job IDs, status checks, output streaming, and the ability to stop/restart jobs.

Core Concepts

The Problem Without gob

# ❌ BLOCKS: Claude Code waits for this to finish
npm run build
npm test
npm run lint

# Total time: Sequential, slow, context locked

The Solution With gob

# ✅ DISPATCHES: Returns immediately with job IDs
gob add npm run build    # Job #1
gob add npm test         # Job #2
gob add npm run lint     # Job #3

# Continue working while jobs run...
# Then collect results when ready

Key insight: gob add starts a job and returns immediately. You never wait. You work. You collect results later.

Sequential Execution

Use sequential execution when:

• •A command must complete before the next one starts
• •Result of one command needed for the next
• •Order matters
• •Examples: build → test, compile → verify, database migrations → seed data

Pattern: Sequential with Await

# Dispatch first command
JOB_ID=$(gob add make build)

# Wait for it (blocks here, but only here)
gob await $JOB_ID

# If it passed, dispatch next
JOB_ID_2=$(gob add npm test)
gob await $JOB_ID_2

# Result known, proceed

Process

1. •Dispatch: gob add <command> → returns job ID immediately
2. •Await: gob await <job_id> → streams output, returns exit code
3. •Check result: If exit code is 0, continue. If non-zero, handle error
4. •Next command: Only run next command if previous succeeded

Key Points

• •One await per command: Always explicitly wait for sequential commands
• •Check exit codes: Know if a command succeeded or failed
• •Error handling: Stop on first failure or continue gracefully
• •Clear naming: Use descriptive job names in comments

Parallel Execution

Use parallel execution when:

• •Commands are independent (don't depend on each other's output)
• •Running them together is faster than sequential
• •Examples: lint + typecheck, test suite 1 + test suite 2, API build + UI build

Pattern 1: Start All, Await All

Good when you have a few known parallel tasks:

# Dispatch all jobs
gob add npm run lint
gob add npm run typecheck
gob add npm test

# Collect results (order doesn't matter)
gob await-any
gob await-any
gob await-any

How it works:

1. •gob add three times → all three start in parallel
2. •gob await-any → waits for whichever finishes first, returns result
3. •Call await-any three times total to wait for all three jobs

Pattern 2: Specific Job Await

Good when you need specific jobs' results:

# Dispatch parallel jobs
LINT_JOB=$(gob add npm run lint)
TYPE_JOB=$(gob add npm run typecheck)
TEST_JOB=$(gob add npm test)

# Wait for specific jobs
gob await $LINT_JOB
gob await $TYPE_JOB
gob await $TEST_JOB

# Check all passed before proceeding

Pattern 3: Parallel Build Steps

# Dispatch parallel compilation tasks
gob add npm run build:frontend
gob add npm run build:backend
gob add npm run build:types

# Wait for all to complete
gob await-any
gob await-any
gob await-any

# All complete, package everything
gob add npm run package

Key Points

• •Independence: Jobs truly don't depend on each other
• •Dispatch first: Start all jobs before awaiting any
• •await-any: Call once per job when using this pattern
• •gob list: Check job status anytime with gob list
• •Latency: Parallel jobs reduce total time significantly

Common Patterns

Pattern: Long Test Run

# Start expensive test suite
TEST_JOB=$(gob add npm run test:integration)

# Implement feature or write docs
# (Tests run in background)

# Check if done:
gob list   # See status

# Wait for completion:
gob await $TEST_JOB

Job Management

View Job Status

gob list

Get Job Output

# Wait for job and stream output
gob await <job_id>

# Returns exit code (0 = success, non-zero = failure)

Stop a Job

# Graceful stop (allows cleanup)
gob stop <job_id>

# Force kill (immediate termination)
gob stop --force <job_id>

Restart a Job

# Stop and restart a specific job
gob restart <job_id>

Remove a Job

# Remove a stopped job from list
gob remove <job_id>

Real-Time Monitoring

# Watch jobs as they run
watch gob list

# Or check once
gob list

Best Practices

✅ DO

• •Use gob add for all long-running commands (builds, tests, servers)
• •Dispatch all parallel jobs before awaiting any (maximizes concurrency)
• •Check exit codes after sequential operations
• •Use descriptive comments to explain job purpose
• •Clean up stopped jobs periodically with gob remove
• •Monitor with gob list if uncertain about job status
• •Use --prompt-only with CLI tools (smaller output)

❌ DON'T

• •Don't use npm run build & - Use gob add npm run build instead
• •Don't use command & - gob handles backgrounding
• •Don't forget to await sequential commands - Result matters
• •Don't mix bash backgrounding with gob - Creates confusion
• •Don't await the same job twice - Job completes once
• •Don't ignore exit codes - Errors need handling
• •Don't let job list grow unbounded - Remove completed jobs

Conditional Parallel Execution

# Phase 1: Build must complete first
gob add npm run build
gob await-any

# Phase 2: Run quality checks in parallel (only if build succeeded)
gob add npm run lint
gob add npm run typecheck
gob add npm test

# Phase 3: Wait for all quality checks
gob await-any
gob await-any
gob await-any

# Phase 4: Package only if all checks pass
gob add npm run package