The 85% Wall

How BookFoundry writes the last 15%

The Frame

Prompting gets a book 85% there. BookFoundry writes the brutal last 15%.

Anyone can prompt an LLM to draft a book — and book2's design work found "just prompting" gets ~85% of the way there. The last 15% — voice, rhythm, no AI tells — is what BookFoundry, a solo-built book-writing engine, is the machine to finish.

And this is no prompt trick — here is what actually shipped.

The Proof

This isn't a prompt — it's a substantial, shipped engine.

BookFoundry (ramparte/bookfoundry) is real machinery, and it produced real output: a 27-letter book manuscript sits in the repo.

So the leverage is real. But the obvious way to earn that last 15% breaks down.

19,828

Lines of Python across 71 files

47

Test files

27

Letters in the produced manuscript

The Tension

Stack cleanup filters naively and they fight each other.

The last 15% needs cleanup filters. But the naive approach thrashes: later filters undo earlier fixes. This was one of the 5 critical failure modes book2 diagnosed.

So how do you order machinery that keeps sabotaging itself? BookFoundry's answer comes from a lineage.

Filters fighting each other Later filters undo earlier filters' fixes.

Revision loops degrading quality Repeated passes make prose worse, not better.

Mechanical metrics ≠ voice quality Hitting the numbers isn't hitting the voice.

Models write like models Tricolons, em-dashes, uniform sentence length.

The Lineage

BookFoundry is generation three of a book machine.

Its design distills three generations: book2 diagnosed the failure modes, book3 solved them, and bookfoundry generalizes them into an 8-layer pipeline — from Preparation through Verification.

The eight layers are real. What makes them work is the order they run in.

1

book2Diagnosed 5 critical failure modes.

2

book3Solved the diagnosed failures.

3

bookfoundryGeneralizes them into an 8-layer pipeline.

The Mechanism

Order is the discipline: voice first, gradient last.

Voice acquisition runs before any content generation. And the document-level gradient pass runs strictly last — because it is the most likely to reintroduce AI tells.

But ordering alone can't stop later filters from undoing earlier fixes. That takes a supervisor.

A

Voice capture — first"Voice acquisition runs before any content generation."

B

Generation, then ordered filters12 enabled filters in 3 ordered steps (6 programmatic, 5 LLM-guided, 1 gradient).

Z

Gradient pass — lastsentence_length_gradient "runs LAST because it is the most likely to reintroduce AI tells."

The Payoff

A ReAct supervisor re-applies any fix a later filter undid.

Layer 7's mechanical pipeline (pipeline.py, 748 lines) runs the ReAct pattern across three ordered steps: after Steps 2 and 3 the supervisor detects damage and re-applies fixes that were undone — eliminating the filter-thrashing problem for good.

"Mechanical has the last word — nothing runs after this layer." So who built all this?

Observe

detect_allDetect every AI-tell still present after a step.

Act

repair_damageRe-fix Step-1 work that Step 2 undid.

Supervise

run_supervised_pipelineRuns damage_check after Step 2 and Step 3, re-applying undone fixes.

The Turn

One developer built the core engine in an 11-day burst.

This discipline isn't a moonshot. Sam Schillace — the sole author across all 104 commits — built the core engine in an 11-day build burst, from the first commit on 2026-04-12 to 2026-04-23.

If a solo dev can build it in 11 days, the pattern is reachable. Here's the lesson to keep.

1

Developer — Sam Schillace, sole author

11

Days in the core build burst

104

Commits, all by one author

The Takeaway

For the last 15%, don't stack filters — supervise them.

The lesson generalizes beyond BookFoundry: to earn the last 15%, order your cleanup deliberately, give the riskiest pass the last word, and put a supervisor over the filters so no fix gets silently undone.

Feature status: Implemented — damage-supervised pipeline

Sources

Sources & Research Methodology

Primary source: ramparte/bookfoundry (checked out at ~/dev/ANext/bookfoundry). Every material claim was independently re-derived from command output in a fresh session.

Feature status: 8-layer pipeline, supervised damage detection, 12 enabled filters, and voice acquisition all IMPLEMENTED; provable editing DOCUMENTED / in-progress.

Commands run:

Layer count & names: grep -n -i 'layer' MACHINE-DESIGN.md ; ls recipes/ (8 layers, recipes layer-1…layer-8)
Mechanical-last / ReAct supervisor: sed -n '162,176p' MACHINE-DESIGN.md ; grep -ni 'ReAct|damage|repair_damage' bookfoundry/filters/pipeline.py ; wc -l bookfoundry/filters/pipeline.py (748 lines)
Enabled filters: grep -B1 'enabled: true' bookfoundry/filters/filter-pipeline.yaml | grep 'name:' ; grep -c ' - name:' … (12 enabled)
Filter modules on disk: ls bookfoundry/filters/*.py | grep -v __ | wc -l (18 modules)
Voice-before-generation: sed -n '90,100p' MACHINE-DESIGN.md ; ls modes/
Line / test counts: find bookfoundry -name '*.py' | xargs wc -l | tail -1 ; find tests -name 'test_*.py' | wc -l (19,828 LOC / 71 files / 47 tests)
Manuscript output: ls docs/letters/ | wc -l (27 letters)
Authorship & timeline: git log --format='%an' | sort -u ; git shortlog -sne --all ; git log --format='%ci' --reverse | head -1 (1 author, 104 commits, 2026-04-12 → 2026-04-23)

Gaps & caveats: The 85%/15% figures are book2's retrospective design premise (MACHINE-DESIGN.md line 11), not an independent benchmark. book2/book3 source repos were not located under ~/dev/ANext; the three-generations claim is grounded in bookfoundry's own MACHINE-DESIGN.md. "11 days" is the build-burst span; refinement commits continue to 2026-07-06. The pipeline has 12 enabled filters (not "14").

Primary contributor: Sam Schillace — sole author, 104 of 104 commits.