bernstein-plan

Bernstein Plan Mode

Create structured execution plans that get human approval before agents start.

When to Use

• User describes a complex feature: "implement user authentication with OAuth"
• User wants to break down a large task into stages
• User says "plan this out" or "create a plan for..."
• User wants to review what agents will do before they start

Instructions

Creating a plan

1. Analyze the user's request and decompose it into stages and tasks.
2. Write a plan YAML file using this structure:

name: "{descriptive plan name}"
description: "{what this plan achieves}"
stages:
  - name: foundation
    steps:
      - goal: "Create database models for user and session"
        role: backend
        scope: small
        complexity: low
      - goal: "Add migration scripts"
        role: backend
        scope: tiny

  - name: implementation
    depends_on: [foundation]
    steps:
      - goal: "Implement OAuth2 flow with Google provider"
        role: backend
        scope: medium
        complexity: medium
      - goal: "Create login/signup UI components"
        role: frontend
        scope: medium

  - name: verification
    depends_on: [implementation]
    steps:
      - goal: "Write integration tests for auth flow"
        role: qa
        scope: medium
      - goal: "Security review of token handling"
        role: security
        scope: small

1. Save the plan to plans/{plan-name}.yaml in the project root.
2. Tell the user to execute it: bernstein run plans/{plan-name}.yaml

Or submit via API

1. Run scripts/plan.sh submit plans/{plan-name}.yaml to submit for approval.
2. The plan enters pending state - use /bernstein-approve to review and approve.
3. Once approved, planned tasks promote to open and agents start picking them up.

Reviewing plans

1. Run scripts/plan.sh list to see all plans and their status.
2. Show the plan with stages, dependencies, and estimated cost/time.

Tips

• Keep stages to 2-5 tasks each
• Use depends_on to enforce ordering (foundation before implementation)
• Assign appropriate roles: backend, frontend, qa, security, devops, docs
• Mark risky tasks with complexity: high - they'll get more capable models
• Foundation stages should be tiny or small scope