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

3. Save the plan to

   plans/{plan-name}.yaml

   in the project root.
4. Tell the user to execute it:

   bernstein run plans/{plan-name}.yaml

Or submit via API

5. Run

   scripts/plan.sh submit plans/{plan-name}.yaml

   to submit for approval.
6. The plan enters

   pending

   state — use

   /bernstein-approve

   to review and approve.
7. Once approved, planned tasks promote to

   open

   and agents start picking them up.

Reviewing plans

8. Run

   scripts/plan.sh list

   to see all plans and their status.
9. 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