Prodigy — Summary

Prodigy is a Rust CLI tool that transforms ad-hoc Claude sessions into reproducible, parallel development pipelines defined in YAML workflow files. Written in Rust with a functional-core / imperative-shell architecture, it provides MapReduce-style parallel agent execution, automatic retry with exponential backoff, circuit breakers, and git-worktree isolation per workflow run. Each workflow step invokes a Claude slash command or a shell command, with conditional branching on failure or success. State is checkpointed to disk so interrupted workflows resume exactly where they stopped. Prodigy is the only framework in this batch that ships as a compiled native binary distributed through crates.io, positioning it as infrastructure-grade rather than a configuration overlay. Compared to seeds, it most resembles spec-driver's sequential skill-chain philosophy but adds parallel MapReduce execution, crash recovery, and per-run worktree isolation that spec-driver lacks; unlike claude-flow's 305-tool MCP server, Prodigy orchestrates at the process level using the Claude CLI binary directly.

Prodigy — Overview

Origin

Prodigy was authored by Glen Baker (iepathos) and published to crates.io as version 0.4.4. The first public commit dates from early 2026 and the repository has been actively pushed as recently as 2026-05-26. It has 9 GitHub stars and 2 contributors.

Philosophy

The project description reads: "Turn ad-hoc Claude sessions into reproducible development pipelines with parallel AI agents." The README opens with: "Transform ad-hoc Claude sessions into reproducible development pipelines with parallel execution, automatic retry, and full state management."

The core design opinion is that Claude interactions should be treated like CI/CD pipelines — deterministic, resumable, observable, and parallelizable. Prodigy rejects the idea of manually shepherding Claude through sequential prompts in a terminal and instead treats each Claude invocation as a pipeline step in a DAG.

Key Design Opinions

• YAML-first workflow definition: Complex orchestration is encoded in plain YAML, not code or prompts.
• Functional core / imperative shell: All business logic lives in pure Rust functions; I/O is isolated to an outer shell. This makes the orchestration engine itself testable without mocks.
• Worktree isolation by default: Every workflow execution creates a git worktree, so parallel branches don't collide.
• Failure is first-class: on_failure and on_success branches are first-class YAML constructs, not error-catching afterthoughts.
• Analytics over intuition: Cost tracking, performance metrics, and optimization recommendations are built in.

Prodigy — Architecture

Distribution & Install

• Distribution type: cli-tool (Rust binary via crates.io)
• Primary install: cargo install prodigy
• Source install: git clone && cargo build --release && cargo install --path .
• Binary name: prodigy
• Version analyzed: 0.4.4 (from Cargo.toml)
• License: MIT
• Required runtime: Rust toolchain for source build; precompiled binary otherwise. Claude CLI must be installed and authenticated separately.

Directory Tree (repo)

prodigy/
├── .claude/              # Claude Code context
├── .prodigy/             # Prodigy config dir
├── src/
│   ├── main.rs
│   ├── lib.rs
│   ├── cli/
│   │   ├── commands/     # changelog, checkpoints, clean, config, dlq, events, exec, logs, progress, resume, sessions, worktree
│   │   ├── args.rs
│   │   ├── router.rs
│   │   └── yaml_validator.rs
│   ├── core/             # Pure functional modules
│   │   ├── config/
│   │   ├── session/
│   │   ├── workflow/
│   │   ├── mapreduce/
│   │   └── validation/
│   ├── storage/          # Persistence layer
│   ├── worktree/         # Git worktree management
│   ├── subprocess/       # Claude CLI process spawning
│   └── unified_session/
├── workflows/            # Example YAML workflows
├── templates/            # Workflow templates
├── specs/                # Feature specs (YAML)
└── scripts/              # install-man-pages.sh, etc.

Target AI Tools

• Primary: Claude CLI (claude binary)
• Cross-tool: Any CLI that accepts slash commands (referenced via claude: "/command" in YAML steps)

Workflow Format

Workflows are YAML files with steps, mode: mapreduce, setup, map, reduce, and config blocks. Each step can be shell: or claude: with on_failure: / on_success: branches and capture_output: for chaining outputs.

Key Dependencies (Cargo.toml)

• clap 4.5 — CLI argument parsing
• tokio 1.49 — async runtime
• serde_yaml 0.9 — workflow parsing
• git2 0.20 — git worktree operations
• axum 0.8 — analytics/observability HTTP endpoints
• uuid 1.10 — session IDs
• indicatif 0.18 — progress bars

Prodigy — Components

CLI Subcommands

Workflow Primitives

Example Workflow Files (in workflows/)

• implement-with-tests.yml — TDD pipeline with test-fail recovery
• fix-files-mapreduce.yml — parallel fix across file list
• documentation-drift.yml — detect and repair doc/code drift
• analysis-workflow.yml — codebase analysis
• coverage.yml — test coverage improvement loop
• complex-build-pipeline.yml — multi-stage build with retry
• debtmap.yml — technical debt mapping
• debtmap-reduce.yml — MapReduce version of debt analysis

Scripts

• scripts/install-man-pages.sh — installs man pages for offline help
• install.sh — build-from-source helper

No Hooks, No Skills, No MCP

Prodigy does not use Claude Code hook events, skill files, or MCP servers. Orchestration is entirely at the process level.

Prodigy — Uniqueness & Positioning

Differs from Seeds

Prodigy is most similar to spec-driver in its sequential skill-chaining philosophy — both treat each agent step as a discrete unit with defined inputs and outputs. However, Prodigy diverges sharply in three dimensions: (1) it is a compiled Rust binary rather than a set of markdown skill files, making it infrastructure rather than a behavioral overlay; (2) it adds parallel MapReduce execution across git worktrees, which no seed framework supports; and (3) it has first-class crash recovery via checkpoints and a dead-letter queue, turning a best-effort agent loop into an engineering-grade pipeline. Compared to claude-flow's MCP-anchored approach, Prodigy invokes Claude at the process level rather than through a tool-server, giving it simpler deployment but lower cross-tool portability. Unlike superpowers' skills-only behavioral framework, Prodigy requires zero changes to Claude's system prompt; the orchestration lives entirely in the host process.

Positioning

Prodigy targets teams that want CI/CD-grade reproducibility for Claude workflows — not researchers running one-off prompts. The intended user has multiple files to process in parallel, needs to resume after failures, and wants cost analytics. It is the only framework in this catalog that ships as a native Rust binary via crates.io.

Observable Failure Modes

• Claude CLI dependency: The workflow fails if the Claude CLI is not installed, not authenticated, or its slash commands are not defined. Prodigy does not ship the slash commands — it assumes they exist.
• YAML coupling: Workflow files reference slash commands by name (/prodigy-implement-spec). If those commands are renamed or removed, all dependent workflows break silently.
• No agent memory: Each Claude invocation is cold-started. For complex multi-step tasks, the agent may lose context between steps despite output capture.
• Worktree accumulation: prodigy worktree clean must be run manually; stale worktrees accumulate on disk.
• No approval gate: Fully autonomous execution means a bad step can cascade before the human intervenes.

Explicit Antipatterns

None stated in README, but the design implies: avoid embedding complex logic in capture_output chaining instead of writing explicit reduce steps.