# OpenProse Examples

These examples demonstrate workflows using OpenProse's full feature set.

## Available Examples

### Basics (01-08)

| File                              | Description                                  |
| --------------------------------- | -------------------------------------------- |
| `01-hello-world.prose`            | Simplest possible program - a single session |
| `02-research-and-summarize.prose` | Research a topic, then summarize findings    |
| `03-code-review.prose`            | Multi-perspective code review pipeline       |
| `04-write-and-refine.prose`       | Draft content and iteratively improve it     |
| `05-debug-issue.prose`            | Step-by-step debugging workflow              |
| `06-explain-codebase.prose`       | Progressive exploration of a codebase        |
| `07-refactor.prose`               | Systematic refactoring workflow              |
| `08-blog-post.prose`              | End-to-end content creation                  |

### Agents & Skills (09-12)

| File                                | Description                          |
| ----------------------------------- | ------------------------------------ |
| `09-research-with-agents.prose`     | Custom agents with model selection   |
| `10-code-review-agents.prose`       | Specialized reviewer agents          |
| `11-skills-and-imports.prose`       | External skill imports               |
| `12-secure-agent-permissions.prose` | Agent permissions and access control |

### Variables & Composition (13-15)

| File                             | Description                         |
| -------------------------------- | ----------------------------------- |
| `13-variables-and-context.prose` | let/const bindings, context passing |
| `14-composition-blocks.prose`    | Named blocks, do blocks             |
| `15-inline-sequences.prose`      | Arrow operator chains               |

### Parallel Execution (16-19)

| File                                 | Description                               |
| ------------------------------------ | ----------------------------------------- |
| `16-parallel-reviews.prose`          | Basic parallel execution                  |
| `17-parallel-research.prose`         | Named parallel results                    |
| `18-mixed-parallel-sequential.prose` | Combined parallel and sequential patterns |
| `19-advanced-parallel.prose`         | Join strategies, failure policies         |

### Loops (20)

| File                   | Description                             |
| ---------------------- | --------------------------------------- |
| `20-fixed-loops.prose` | repeat, for-each, parallel for patterns |

### Pipelines (21)

| File                           | Description                               |
| ------------------------------ | ----------------------------------------- |
| `21-pipeline-operations.prose` | map, filter, reduce, pmap transformations |

### Error Handling (22-23)

| File                          | Description                            |
| ----------------------------- | -------------------------------------- |
| `22-error-handling.prose`     | try/catch/finally patterns             |
| `23-retry-with-backoff.prose` | Resilient API calls with retry/backoff |

### Advanced Features (24-27)

| File                            | Description                       |
| ------------------------------- | --------------------------------- |
| `24-choice-blocks.prose`        | AI-selected branching             |
| `25-conditionals.prose`         | if/elif/else patterns             |
| `26-parameterized-blocks.prose` | Reusable blocks with arguments    |
| `27-string-interpolation.prose` | Dynamic prompts with {var} syntax |

### Orchestration Systems (28-31)

| File                                  | Description                                                                                                                                                 |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `28-gas-town.prose`                   | Multi-agent orchestration ("Kubernetes for agents") with 7 worker roles, patrols, convoys, and GUPP propulsion                                              |
| `29-captains-chair.prose`             | Full captain's chair pattern: coordinating agent dispatches subagents for all work, with parallel research, critic review cycles, and checkpoint validation |
| `30-captains-chair-simple.prose`      | Minimal captain's chair: core pattern without complexity                                                                                                    |
| `31-captains-chair-with-memory.prose` | Captain's chair with retrospective analysis and session-to-session learning                                                                                 |

### Production Workflows (33-38)

| File                         | Description                              |
| ---------------------------- | ---------------------------------------- |
| `33-pr-review-autofix.prose` | Automated PR review with fix suggestions |
| `34-content-pipeline.prose`  | End-to-end content creation pipeline     |
| `35-feature-factory.prose`   | Feature implementation automation        |
| `36-bug-hunter.prose`        | Systematic bug detection and analysis    |
| `37-the-forge.prose`         | Build a browser from scratch             |
| `38-skill-scan.prose`        | Skill discovery and analysis             |

### Architecture Patterns (39)

| File                               | Description                                                                                          |
| ---------------------------------- | ---------------------------------------------------------------------------------------------------- |
| `39-architect-by-simulation.prose` | Design systems through simulated implementation phases with serial handoffs and persistent architect |

### Recursive Language Models (40-43)

| File                          | Description                                                         |
| ----------------------------- | ------------------------------------------------------------------- |
| `40-rlm-self-refine.prose`    | Recursive refinement until quality threshold - the core RLM pattern |
| `41-rlm-divide-conquer.prose` | Hierarchical chunking for inputs beyond context limits              |
| `42-rlm-filter-recurse.prose` | Filter-then-process for needle-in-haystack tasks                    |
| `43-rlm-pairwise.prose`       | O(n^2) pairwise aggregation for relationship mapping                |

### Meta / Self-Hosting (44-48)

| File                              | Description                                            |
| --------------------------------- | ------------------------------------------------------ |
| `44-run-endpoint-ux-test.prose`   | Concurrent agents testing the /run API endpoint        |
| `45-plugin-release.prose`         | OpenProse plugin release workflow (this repo)          |
| `46-workflow-crystallizer.prose`  | Reflective: observes thread, extracts workflow, writes .prose |
| `47-language-self-improvement.prose` | Meta-level 2: analyzes .prose corpus to evolve the language itself |
| `48-habit-miner.prose`            | Mines AI session logs for patterns, generates .prose automations |

## The Architect By Simulation Pattern

The architect-by-simulation pattern is for designing systems by "implementing" them through reasoning. Instead of writing code, each phase produces specification documents that the next phase builds upon.

**Key principles:**

1. **Thinking/deduction framework**: "Implement" means reasoning through design decisions
2. **Serial pipeline with handoffs**: Each phase reads previous phase's output
3. **Persistent architect**: Maintains master plan and synthesizes learnings
4. **User checkpoint**: Get plan approval BEFORE executing the pipeline
5. **Simulation as implementation**: The spec IS the deliverable

```prose
# The core pattern
agent architect:
  model: opus
  persist: true
  prompt: "Design by simulating implementation"

# Create master plan with phases
let plan = session: architect
  prompt: "Break feature into design phases"

# User reviews the plan BEFORE the pipeline runs
input user_approval: "User reviews plan and approves"

# Execute phases serially with handoffs
for phase_name, index in phases:
  let handoff = session: phase-executor
    prompt: "Execute phase {index}"
    context: previous_handoffs

  # Architect synthesizes after each phase
  resume: architect
    prompt: "Synthesize learnings from phase {index}"
    context: handoff

# Synthesize all handoffs into final spec
output spec = session: architect
  prompt: "Synthesize all handoffs into final spec"
```

See example 39 for the full implementation.

## The Captain's Chair Pattern

The captain's chair is an orchestration paradigm where a coordinating agent (the "captain") dispatches specialized subagents for all execution. The captain never writes code directly—only plans, coordinates, and validates.

**Key principles:**

1. **Context isolation**: Subagents receive targeted context, not everything
2. **Parallel execution**: Multiple subagents work concurrently where possible
3. **Continuous criticism**: Critic agents review plans and outputs mid-stream
4. **80/20 planning**: 80% effort on planning, 20% on execution oversight
5. **Checkpoint validation**: User approval at key decision points

```prose
# The core pattern
agent captain:
  model: opus
  prompt: "Coordinate but never execute directly"

agent executor:
  model: sonnet
  prompt: "Execute assigned tasks precisely"

agent critic:
  model: sonnet
  prompt: "Review work and find issues"

# Captain plans
let plan = session: captain
  prompt: "Break down this task"

# Parallel execution with criticism
parallel:
  work = session: executor
    context: plan
  review = session: critic
    context: plan

# Captain validates
output result = session: captain
  prompt: "Validate and integrate"
  context: { work, review }
```

See examples 29-31 for full implementations.

## The Recursive Language Model Pattern

Recursive Language Models (RLMs) are a paradigm for handling inputs far beyond context limits. The key insight: treat the prompt as an external environment that the LLM can symbolically interact with, chunk, and recursively process.

**Why RLMs matter:**

- Base LLMs degrade rapidly on long contexts ("context rot")
- RLMs maintain performance on inputs 2 orders of magnitude beyond context limits
- On quadratic-complexity tasks, base models get <0.1% while RLMs achieve 58%

**Key patterns:**

1. **Self-refinement**: Recursive improvement until quality threshold
2. **Divide-and-conquer**: Chunk, process, aggregate recursively
3. **Filter-then-recurse**: Cheap filtering before expensive deep dives
4. **Pairwise aggregation**: Handle O(n²) tasks through batch decomposition

```prose
# The core RLM pattern: recursive block with scope isolation
block process(data, depth):
  # Base case
  if **data is small** or depth <= 0:
    output session "Process directly"
      context: data

  # Recursive case: chunk and fan out
  let chunks = session "Split into logical chunks"
    context: data

  parallel for chunk in chunks:
    do process(chunk, depth - 1)  # Recursive call

  # Aggregate results (fan in)
  output session "Synthesize partial results"
```

**OpenProse advantages for RLMs:**

- **Scope isolation**: Each recursive call gets its own `execution_id`, preventing variable collisions
- **Parallel fan-out**: `parallel for` enables concurrent processing at each recursion level
- **State persistence**: SQLite/PostgreSQL backends track the full call tree
- **Natural aggregation**: Pipelines (`| reduce`) and explicit context passing

See examples 40-43 for full implementations.

## Running Examples

Ask Claude to run any example:

```
Run the code review example from the OpenProse examples
```

Or reference the file directly:

```
Execute examples/03-code-review.prose
```

## Feature Reference

### Core Syntax

```prose
# Comments
session "prompt"                    # Simple session
let x = session "..."               # Variable binding
const y = session "..."             # Immutable binding
```

### Agents

```prose
agent name:
  model: sonnet                     # haiku, sonnet, opus
  prompt: "System prompt"
  skills: ["skill1", "skill2"]
  permissions:
    read: ["*.md"]
    bash: deny
```

### Parallel

```prose
parallel:                           # Basic parallel
  a = session "A"
  b = session "B"

parallel ("first"):                 # Race - first wins
parallel ("any", count: 2):         # Wait for N successes
parallel (on-fail: "continue"):     # Don't fail on errors
```

### Loops

```prose
repeat 3:                           # Fixed iterations
  session "..."

for item in items:                  # For-each
  session "..."

parallel for item in items:         # Parallel for-each
  session "..."

loop until **condition** (max: 10): # Unbounded with AI condition
  session "..."
```

### Pipelines

```prose
items | map:                        # Transform each
  session "..."
items | filter:                     # Keep matching
  session "..."
items | reduce(acc, x):             # Accumulate
  session "..."
items | pmap:                       # Parallel transform
  session "..."
```

### Error Handling

```prose
try:
  session "..."
catch as err:
  session "..."
finally:
  session "..."

session "..."
  retry: 3
  backoff: "exponential"            # none, linear, exponential

throw "message"                     # Raise error
```

### Conditionals

```prose
if **condition**:
  session "..."
elif **other condition**:
  session "..."
else:
  session "..."
```

### Choice

```prose
choice **criteria**:
  option "Label A":
    session "..."
  option "Label B":
    session "..."
```

### Blocks

```prose
block name(param):                  # Define with parameters
  session "... {param} ..."

do name("value")                    # Invoke with arguments
```

### String Interpolation

```prose
let x = session "Get value"
session "Use {x} in prompt"         # Single-line

session """                         # Multi-line
Multi-line prompt with {x}
"""
```

## Learn More

See `compiler.md` in the skill directory for the complete language specification.
