The pipeline

Cascade is built around one pipeline. The input mode varies, but every approved story flows through the same stages.

Stages

+-------------------------------------------------------------------+
|                       TEAM MEMORY LAYER                            |
| (conventions, decisions, glossary, prior work, constraints)        |
+-------------------------------------------------------------------+
            ^    ^    ^    ^    ^    ^    ^    ^
            |    |    |    |    |    |    |    |  every stage reads
            |    |    |    |    |    |    |    |  team memory as context
            |    |    |    |    |    |    |    |
+---------+ +--+ +--+ +-+-----+ +--+ +--+ +--+ +-------+
|  input  |->|IN|->|TX|->|stories|->|RV|->|PL|->|CD|->|PR open|
+---------+ +--+ +--+ +-------+ +--+ +--+ +--+ +-------+
            ingest transcribe extract review plan code   PR
                                          |
                            HUMAN APPROVES EACH GATE

What each stage does

Ingest

Audio or video file to text via Whisper. Three backends: faster-whisper (recommended), openai-whisper, or the OpenAI Whisper API. Picks the best available automatically.

Transcribe (with optional diarization)

The same module that ingests can also identify who said what, via pyannote.audio. If pyannote isn’t installed, all turns are labeled “Speaker” and Cascade still works fine.

Extract

Reads the transcript plus team memory and produces a StoryBatch: a list of user stories with Given/When/Then acceptance criteria, a size estimate, and a confidence score for each. Low-confidence stories are flagged for human attention.

Review

You walk through each story interactively. Options for each one: accept, edit (opens in $EDITOR), reject, or skip. Decisions are saved as you go, so you can quit and resume later.

Plan

For each approved story, an LLM produces a file-level implementation plan. The plan lists which files to create, modify, or delete, with the intent for each change in plain English. The plan also captures risks and explicit out-of-scope notes to prevent scope creep.

Code

Reads the plan and generates the full file contents for every change. For modified files, the current contents are included so the LLM can preserve unrelated code. Cascade validates that the generated changes match the plan (no hallucinated files, no action swaps).

Test

Runs the language’s test command (pytest, go test, cargo test, etc.) in a subprocess. Captures pass/fail, exit code, output, and duration.

PR

Creates a new branch, applies the changes, commits them, pushes the branch, and opens a PR on your configured VCS. The PR description includes the story, the changes, the test result, and a Cascade attribution.

Where humans approve

Two gates:

1. Story review before any code is generated. You see what Cascade plans to build and can edit or reject before it touches your repo.
2. PR review before any code is merged. Cascade never has merge permissions. A human always approves the final change.

Where team memory enters

Every LLM call across every stage receives the relevant team memory as grounding context. So when extracting stories, the extractor knows about your team’s glossary. When planning, the planner knows your architectural decisions. When coding, the coder respects your conventions.

Without team memory, Cascade is just another AI tool that produces generic output. With it, Cascade produces output that fits your team’s actual norms.

Learn how to populate team memory