Development Philosophy

Deliberate Development

A decomposition-first approach to building software with AI assistance

Archived · Agents Still Available

January 20–31, 2026 · ramparte/amplifier-bundle-deliberate-development

The Problem

AI coding assistants encourage bad habits

Jump to Code

User asks for feature → immediately start coding. No analysis, no alternatives, no thinking.

Marathon Sessions

Hours in one session. Context becomes polluted. Decisions compound on stale assumptions.

Test It Later

“I’ll validate when I’m done.” Batching testing at the end. Hoping it works.

            The result: fast-looking progress that often requires rework, misses better solutions, and accumulates technical debt.
        

The Philosophy

Decompose before you build

4–5 planning turns, then one “go do it” turn

“The best solutions often come from the ‘oooh, you know what else would be smart’ moments that only happen when you’re not rushing.”

Core Principles

Six tenets of deliberate development

1

Decompose First

Break down the problem. Leave room for insight. Look for generalization.

2

Ephemeral Workspaces

Fresh workspace per task. Destroy when done. Never return to old sessions.

3

Validation is Implicit

“Done” means “verified working.” Not a separate step.

4

Scope Ruthlessly

One feature, one workspace. If you’re thinking “I’ll come back to this” — too big.

5

Generalize When Patterns Appear

“What else could benefit from this?” Look for the broader opportunity.

6

Systematic Research

Brainstorm first with multiple agents, research second. Iterate deeply.

The Workflow

The deliberate development cycle

1

Create Workspace

Fresh directory, local git, repos as submodules

Setup

2

Decompose

Break down the problem, identify components, map dependencies

1–2 turns

3

Explore

Consider 2–3 alternative approaches with trade-offs

1–2 turns

4

Generalize

Look for pattern opportunities — the key insight step

1 turn

5

Implement

One “go do it” turn with validation implicit

1 turn

6

Cleanup

Push to real repos, destroy workspace, start fresh for next task

Cleanup

The Tools

4 agents and 9 recipes for deliberate workflows

deliberate-planner

Decomposes problems, explores alternatives, looks for generalization. Does NOT implement.

"Use deliberate-planner to analyze this feature"

deliberate-implementer

Builds from specifications exactly. Validates as it goes. Does NOT plan.

"Use deliberate-implementer to build this spec"

deliberate-reviewer

Structural prevention, root cause analysis, anti-pattern detection.

"Use deliberate-reviewer to assess this code"

deliberate-debugger

Hypothesis-driven debugging, systematic issue resolution.

"Use deliberate-debugger for this timeout"

            The bundle also includes 9 recipes: deliberate-design, quick-design, feature-development, code-review-prep, issue-resolution, deliberate-review, learning-exploration, spike-investigation, and refactor-workflow.
        

In Practice

The deliberate-design recipe in action

# Step 1: Decompose — understand what's really being asked
decompose: "What are the components? What does success look like?"

# Step 2: Explore — 2–3 approaches with trade-offs
explore: "Option A (direct), Option B (alternative), Option C (general)"

# Step 3: Generalize — the key insight step
generalize: "What else could benefit? Is there a pattern here?"

# Step 4: Specify — complete contract for implementation
specify: "Components, interfaces, test strategy, success criteria"

# Step 5: Implement — one turn, validation implicit
implement: "Build it, verify it works, report completion"

            The generalize step is what makes this “deliberate” — it’s where the “what else would be smart” insights emerge.
        

Anti-Patterns

What deliberate development prevents

Anti-Pattern	Deliberate Alternative
Jump to implementation	Decompose first (4–5 turns)
One mega-session	Ephemeral workspaces, fresh each task
“Test it later”	Validation is implicit in “done”
Single approach	Explore 2–3 alternatives
One-off solutions	Look for generalization opportunities
Returning to old sessions	New task = new session, always

Architecture

Three-tier discovery design

Tier 1: Discovery

Awareness Pointer (Default)

Thin context file composed into default bundles. Users know the methodology exists and when to use it. Minimal token overhead per session.

Tier 2: Delegation

Context Sink Agents (On Demand)

Full philosophy docs load only when agents are delegated to. “Use deliberate-planner” triggers context loading in the agent’s session, not the parent.

Tier 3: Orchestration

Explicit Recipes (User Requested)

Complete multi-agent workflow orchestration when user explicitly requests a recipe. Full lifecycle from decomposition through implementation.

            Design intent: users discover the methodology with minimal overhead. Heavy docs load only when needed via delegation.
        

Ecosystem Integration

Works alongside foundation agents

Deliberate Agents Provide

Workflow discipline

• When to plan vs implement
• How to decompose problems
• When to look for generalization
• Workspace lifecycle management

Foundation Agents Provide

Domain expertise

• zen-architect for complex architecture
• modular-builder for implementation
• bug-hunter when issues arise
• explorer for codebase reconnaissance

            Deliberate development is a layer on top of Amplifier’s existing capabilities — adding process discipline without replacing domain expertise.
        

Development Velocity

Built in 11 days by a single author

4

Commits

1

Repository

1

Contributor

5,732

Lines (md + yaml)

            Primary author: Sam Schillace (4/4 commits, 100%)

            Timeline: January 20 → January 31, 2026 (11 calendar days)

            Current status: Repository moved to Inactive/. Agents remain available in current Amplifier sessions via the amplifier-toolkit integration.

Sources

Research Methodology

Data as of: February 20, 2026

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

Repository: ramparte/amplifier-bundle-deliberate-development (GitHub, public)

Research performed:

Git log: git log --oneline → 4 commits found
Commit dates: git log --format="%ai %s" → Jan 20–31 2026
Contributors: git log --format="%an" | sort | uniq -c → 1 author (Sam Schillace)
Agent count: find . -name "*.md" -path "*/agents/*" | wc -l → 4 agents
Recipe count: find . -name "*.yaml" -path "*/recipes/*" | wc -l → 9 recipes
Line count: find . \( -name "*.md" -o -name "*.yaml" \) | xargs wc -l → 5,732 total
Remote: git remote -v → ramparte/ org confirmed
Availability: HTTP 200 on github.com/ramparte/amplifier-bundle-deliberate-development

Gaps: Token cost estimates from a prior version of this deck were unverifiable and have been removed. Bundle validation claims were self-referential and have been removed.

Get Started

Try deliberate development

# The agents are available in current Amplifier sessions
# loaded via the amplifier-toolkit integration

# Start deliberate planning
"Use deliberate-planner to analyze this feature"

# Or run the full design workflow
"Run deliberate-design for: [your feature]"

# Original bundle repo (archived but still accessible)
git+https://github.com/ramparte/amplifier-bundle-deliberate-development@main

Stop rushing. Start deliberating.