pipelines

A collection of Dippin pipelines for use with tracker — the agentic pipeline engine that executes multi-step AI workflows.

Quick Start

Requires tracker ≥ v0.44.0 (which vendors dippin-lang ≥ v0.48.0; joint release, tracker tagged first). Prefer the latest release — install with @latest (CI pins the newest lockstep pair, currently tracker v0.73.1 / dippin v0.72.0). The v0.44.0 floor is where the prompt_suffix_file: shared-prompt-fragment directive (used by the iterative/ STATUS-contract cascade) is understood — older releases reject it at parse time. Pipelines use the marker_grep typed-routing field on tool nodes, the tool_access: none structural bound on agent Start/Exit nodes, and writable_paths fs-jail bounds on agents that need scoped write access. The v0.39.0 floor matters: tracker's adapter only propagates the top-level tool_access spelling from v0.39.0 (2389-research/tracker#366) — on older releases the Start/Exit bounds parse but are silently ignored at runtime (prose-only). writable_paths enforcement is Linux-only (Landlock + openat2) — on macOS/Windows tracker refuses to start when the field is set; the field itself needs tracker ≥ v0.35.0, and older releases reject it as unknown.

# Install tracker
go install github.com/2389-research/tracker/cmd/tracker@latest

# Configure API keys
tracker setup

# Run a pipeline
tracker build-and-ship/speedrun.dip

You will need API keys for the LLM providers used in each pipeline (Anthropic, OpenAI, Gemini). See the tracker docs for details.

Projects

Kata

Pipeline	Description
complete.dip	Claims one ready, unowned kata item, plans only as needed, implements it, and requires two-model fresh-eyes review before evidence-backed closure. At most one repair pass.
board.dip	Reuses the complete pipeline for the whole board with separate child runs. Each approved child lands on the checked-out local trunk; failed work goes to the morning review. The pipeline never touches a remote.

Build & Ship

Single-pass build pipelines — fastest path from spec or bug report to shipped code.

Pipeline	Description
speedrun.dip	Ultra-minimal build pipeline — read spec, plan, implement, test, ship. Fully headless.
build_from_superpowers.dip	Builds from a superpowers spec — finds the spec, executes every task, commits with passing tests.
bug-hunter.dip	Autonomous bug fix — reproduces, diagnoses, fixes via TDD, and ships a PR.
refactor-express.dip	Incremental refactoring — tests stay green at every step, rollback on failure.
doc-writer.dip	Documentation generator — README, API reference, architecture guide, and tutorials.

Sprint

Sprint decomposition and execution with budget and YAML variants.

Pipeline	Description
spec_to_sprints.dip	Decomposes a spec into SPRINT-*.md files via multi-model tournament with human approval.
sprint_exec.dip	Executes the next incomplete sprint through implementation, validation, and review.
sprint_runner.dip	Runs all sprints in sequence until every sprint is completed.
sprint_exec-cheap.dip	Budget variant using smaller models with escalation.
sprint_runner-cheap.dip	Budget variant of the sprint runner.
megaplan.dip	Multi-model orientation, drafting, critique, and merge for sprint planning.

YAML variants: spec_to_sprints_yaml, spec_to_sprints_yaml_v2, sprint_exec_yaml, sprint_exec_yaml_v2, sprint_runner_yaml, sprint_runner_yaml_v2, spec_to_ship_yaml

Local Code Gen

Sprint pipeline that uses Opus/Sonnet for architecture and a local qwen3.6:35b-a3b (via Ollama) for code generation, with cloud (gpt-5.4) escalation only when local fix attempts are exhausted. Architect emits enriched SPRINT-*.md files via the dispatch_sprints tool; runner uses 4-strategy SR-block matching with rollback. Happy path costs $0.00 for codegen.

Pipeline	Description
architect_only.dip	Just the architect step — produces contract, sprint plan JSONL, and SPRINT-*.md files. Skips upstream decomposition tournament.
spec_to_sprints.dip	Full upstream tournament + the architect step end-to-end.
sprint_runner_qwen.dip	Per-sprint loop: qwen Generate → SR-block LocalFix → CloudFix escalation → Audit → Commit.

See local_code_gen/README.md for setup, model config, and the design principles in local_code_gen/principles/.

Pipeline Generation

Meta-pipelines that generate .dip files from specs via multi-model tournament.

Pipeline	Description
spec_to_dip.dip	Generates a validated .dip pipeline with domain-specific review panels.
pipeline_from_spec.dip	Generates a pipeline scoring against objective pattern and coverage metrics.
pipeline_from_spec_v2.dip	Revised with updated quality gates.
pipeline_from_superpowers.dip	Generates a pipeline from a superpowers-format spec.

Greenfield

New project validation — discovery, synthesis, review, and validation stages.

Pipeline	Description
greenfield.dip	Orchestrator — runs the full greenfield validation flow.
greenfield_discovery.dip	Explores the problem space, identifies constraints and opportunities.
greenfield_synthesis.dip	Generates candidate architectures and approaches.
greenfield_review.dip	Multi-model evaluation of synthesized candidates.
greenfield_validation.dip	Final feasibility and risk assessment.

Iterative

Incremental development with PAR (Parallel Adversarial Review) gates.

Pipeline	Description
iter_dev.dip	Orchestrator — coordinates scope → extract → run → audit cycle.
iter_scope.dip	Scopes work from a behavior corpus with structural/risk PAR review.
iter_extract.dip	Extracts actionable tasks with coverage/intent PAR review.
iter_run.dip	Implements a task with spec/quality PAR reviews and failure loops.
iter_audit.dip	Three-tier audit — traceability, execution verification, drift detection.

Interactive

Human-in-the-loop games and debates.

Pipeline	Description
20q.dip	20 Questions — AI asks yes/no questions to guess what you're thinking of.
story-engine.dip	Choose-your-own-adventure with branching narrative.
model-debate.dip	Multi-model debate arena — Claude, GPT, and Gemini argue, you judge.

tracker-claw

Pipeline	Description
agent.dip	Conversation with session memory: propose a bounded task, get human approval, execute, and review before the next request.

How It Works

Each .dip file defines a workflow in the Dippin language — a DSL for describing agentic pipelines. Workflows declare nodes (agents, tools, human gates, parallel branches, conditionals) and edges with optional conditions.

Tracker reads the .dip file, builds the execution graph, and orchestrates LLM agents through it — dispatching tasks to Claude, GPT, or Gemini in isolated git worktrees with parallel execution support and a TUI dashboard.

Node Types

• agent — LLM call with tool access
• human — Human input gate (choice, freeform, or interview)
• tool — Shell command execution
• parallel / fan_in — Parallel fan-out and synchronization
• conditional — Branching based on context

Releases & Changelog

CHANGELOG.md carries the per-version summary in Keep a Changelog format; long-form release notes live on the GitHub releases page.

Semantic Versioning applies from v0.2.0 forward, scoped to the operator surface: the set of *.dip workflows plus the operator-facing dev_loop/ configuration shape (dev_loop/scripts/lib/ helper internals are explicitly excluded).

PRs that touch the SemVer surface must add an entry under CHANGELOG.md#unreleased — enforced by the changelog check workflow, with a skip-changelog label as the escape hatch. Maintainers: see RELEASING.md for the release-cut convention.

Related Projects

• tracker — The runtime engine that executes these pipelines
• dippin-lang — The Dippin language compiler, LSP, and toolchain

---

Built by 2389.ai