Slow Down to Ship

Front-loading judgment before AI writes code

Deliberate Development · Amplifier bundle

Make AI think before it types

Deliberate Development is an Amplifier bundle that makes AI-assisted coding slow down and reason before it writes — so you don't lose the better solution to the rush.

And this isn't a manifesto — it's already codified and shipped.

Proof

The discipline is real, not aspirational

Version 1.2.0 shipped in a single commit by Sam Schillace on 2026-01-31 — 35 files, 6,163 insertions.

So why does a discipline like this need to exist at all?

4

agents

9

recipes

4

behaviors

6,163

insertions in 1 commit

The Trap

AI makes it trivial to skip straight to code

The bundle names the failure modes outright as anti-patterns to avoid — the traps deliberate development is fighting.

Behind every trap is one lost thing: the space where insight shows up.

The Marathon Session

Working one session for hours or days until context becomes polluted.

The Immediate Implementation

Feature request → start coding, with no analysis of alternatives.

The Deferred Validation

“I'll test it when I'm done” — batching validation at the end.

The Insight, Verbatim

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

— DELIBERATE_PHILOSOPHY.md, line 16

So the method is built to buy that space on purpose.

The Method

Invert the turn budget

Spend 4-5 turns decomposing the problem — analysis and design — then commit to a single implementation turn.

But that one turn does more than write code.

4–5

Decompose the problem
Turns of analysis and design

1

“Go do it”
One implementation turn

The Payoff of Slowing Down

“Go do it” means implement and validate

Validation is implicit in that one turn — not batched at the end. The front-loaded thinking pays off as a single validated pass.

And because it's a discipline, it can be captured and reused.

Codified

Discipline turned into shippable tooling

Slowing down to think becomes a reusable, repeatable workflow — 4 agents and 9 recipes carry the method.

And it doesn't stay locked to one project.

4

Agents

planner, implementer, reviewer, debugger

9

Recipes

deliberate-design, feature-development, issue-resolution & more

The Takeaway

Leave room for insight

The bundle composes into any Amplifier bundle that already has foundation — so any project can adopt the discipline of thinking before it types.

Slow down between the turns; that's where the better solution lives.

Sources

Research Methodology

Present & complete · v1.2.0

Data as of: commit 18e5346, dated 2026-01-31 (only commit in this checkout).

Repository: ~/dev/ANext/amplifier-bundle-deliberate-development (composable Amplifier bundle).

Primary contributor: Sam Schillace <ramparte@gmail.com> — sole commit author.

Commands run:

git log --oneline — one commit: 18e5346
git show --stat 18e5346 | tail — 35 files changed, 6,163 insertions(+)
ls agents/*.md | wc -l → 4; ls recipes/*.yaml | wc -l → 9; ls behaviors/*.yaml | wc -l → 4
grep -n '4-5' context/DELIBERATE_PHILOSOPHY.md — “4-5 planning turns, then one ‘go do it’ turn” (line 14)
sed -n '93,121p' context/DELIBERATE_PHILOSOPHY.md — anti-patterns (Marathon Session, Immediate Implementation, Deferred Validation)
sed -n '41,49p' context/DELIBERATE_PHILOSOPHY.md — “‘Go do it’ means ‘implement AND validate’” (line 45)

Gaps: This checkout holds a single commit, so prior 1.0/1.1 iterations implied by version 1.2.0 could not be verified from git history; no gh PR/issue history was inspected.