Amplifier Bundle

LongBuilder

Phase-based orchestration for long-term projects

Archived

Concept & design: Sam Schillace · ramparte/amplifier-bundle-longbuilder

The Problem

Large AI Projects Fail

Analysis of two real projects revealed why.

Failure: Word Project

~20

sessions over 4 days

20–30%

estimated completion despite effort
Session bloat: 1,500+ turns
No clear progression gates
Undefined scope sprawl

Success: Lifeline Project

4

sessions over 3 days

100%

production-ready, feature-complete
Session discipline: <850 turns
Clear phase boundaries
Incremental validation

            Note: These figures come from analysis that motivated LongBuilder's design. They describe the projects studied, not LongBuilder's own results.
        

Key Insight

Same tools.
Different outcomes.

“Both projects used Amplifier with the same agents and capabilities. The difference was structure: phases, gates, and discipline.”

What made Lifeline succeed where Word failed?
Not better tools—better process.

The Design

Phase-Based Orchestration

The intended workflow: clear gates, incremental validation, human oversight at every boundary.

1

Plan Project

Decompose into 3–7 phases with explicit completion criteria

2

Design Phase

Architecture and specification for the current phase

✋

Human Approval Gate

Antagonistic validation reviews the design; human approves before implementation

3

Implement

Build with session discipline (design goal: max 800 turns per session)

✋

Human Approval Gate

Antagonistic validation reviews the output; human confirms phase completion

4

Complete

Mark phase done, checkpoint state, proceed to next phase or finish

Core Concepts

Design Principles

🎯

Phase Gates

Explicit completion criteria prevent undefined sprawl. Each phase has deliverables and validation before progression.

🔍

Antagonistic Validation

Fresh-context reviewers examine artifacts directly. No inherited assumptions—catch real problems early.

✋

Human Approval

Two approval points per phase: after design, after implementation. AI executes, humans decide.

📊

Session Discipline

Focused scope per session. Design goal: 500–800 turn limits with automatic checkpointing to prevent bloat.

🔄

Resumable Workflows

Pause and resume across sessions. State preserved through Amplifier recipe checkpointing at phase boundaries.

🛠

Thin Bundle Design

Compose existing Amplifier capabilities rather than reinvent. Recipes, agents, and approval gates from the ecosystem.

Motivating Analysis

What Works vs What Fails

Patterns identified from studying the Lifeline and Word projects.

✓ Success Patterns (Lifeline)

Clear phases with completion criteria
Focused sessions (never exceeded 850 turns)
Simple requirements from user perspective
Incremental validation at phase boundaries
Proactive documentation before building
Human approval at critical gates

✗ Failure Patterns (Word)

Task database without clear progression
Session bloat (sessions hit 1,500+ turns)
Complex design specs upfront, all at once
Terminal validation (too late to fix)
Reactive debugging documentation
No clear approval or phase gates

            These patterns became LongBuilder's design inputs. The bundle was conceived to encode Lifeline's successful patterns into a repeatable, recipe-driven workflow.
        

Intended Architecture

The Thin Bundle Approach

LongBuilder was designed to compose existing Amplifier capabilities, not reinvent them.

Orchestration Layer

LongBuilder Recipes

Staged YAML recipes with human approval gates. Intended recipes: execute-phase, antagonist-design-validator, antagonist-test-validator.

↓

Agent Layer

Specialized + Foundation Agents

Phase-planner and phase-validator agents composing Foundation capabilities: zen-architect, modular-builder, deliberate-reviewer.

↓

Platform Layer

Amplifier Core

Session management, recipe engine with checkpointing, approval gates, agent delegation—all pre-existing capabilities.

            Honest note: The repository at ramparte/amplifier-bundle-longbuilder is empty. This architecture represents the intended design, not a verifiable shipped implementation.
        

Current Status

Archived, but Influential

Concept Developed

Sam Schillace designed the phase-based orchestration concept based on real project analysis. The Word vs Lifeline comparison drove the core principles.

Repository Archived

The bundle directory exists at ~/dev/ANext/Inactive/amplifier-bundle-longbuilder but is empty—no files, no README, no git history. A separate longbuilder-investigation folder also exists in the Inactive directory.

Concepts Carried Forward

The word2 and word3 projects both contain .longbuilder directories, suggesting the ideas were applied to later work even after the standalone bundle was shelved.

            The honest summary: LongBuilder was a good idea that didn't ship as a standalone bundle. The repository is empty and the bundle cannot be installed. But the underlying principles—phase gates, antagonistic validation, session discipline—influenced subsequent projects and remain embedded in how Amplifier approaches large-scale work.
        

Sources

Research Methodology

Data as of: February 20, 2026

Feature status: Archived (repository in ~/dev/ANext/Inactive/)

Repository: ramparte/amplifier-bundle-longbuilder (GitHub)

Contributor: Sam Schillace (concept and design author)

Research performed:

ls ~/dev/ANext/Inactive/amplifier-bundle-longbuilder → directory exists but is empty
ls ~/dev/ANext/Inactive/ → confirmed longbuilder-investigation also present
find ~/dev/ANext/word2 -name ".longbuilder" -type d → .longbuilder directory found
find ~/dev/ANext/word3 -name ".longbuilder" -type d → .longbuilder directory found
Previous deck (longbuilder-deck.html) reviewed for claims requiring verification

Gaps and limitations:

Repository is empty—no code, no commits, no README to verify against
Design document not available in the repository
Specific recipe files, agent definitions, and implementation details from the prior version of this deck could not be verified
Word/Lifeline statistics (session counts, turn counts) originate from design analysis, not from LongBuilder outputs
No install commands provided as current—the bundle cannot be installed

Evidence of concept application: .longbuilder directories in word2 and word3 projects suggest the phase-based approach was used in later work.

The Ideas Endure

Good ideas survive
their first form

“The bundle didn't ship, but the principles did. Phase gates, antagonistic validation, and session discipline are now part of how Amplifier works.”

github.com/ramparte/amplifier-bundle-longbuilder
(Repository is archived and empty)

The patterns live on in Amplifier's recipe system, approval gates, and deliberate development workflow.