The problem
Long-form AI projects create a specific failure mode: generation is cheap, so the system can produce large amounts of polished material before the underlying architecture is stable.
That creates downstream problems that are expensive to repair:
- chapters duplicate or contradict one another
- later ideas leak backward into sections that are supposed to establish foundations
- tone and terminology drift across sessions
- interesting tangents gradually redefine scope
- AI reconstructs prior decisions imperfectly from memory
- supporting artifacts are generated before their conceptual purpose is clear
Treat the project as a production system with controlled state transitions. AI can expand, draft, revise, and render—but only after the relevant upstream specification has been approved.
Core operating principle
Do not use AI autonomy where unresolved human decisions still determine the shape of the work. Resolve architecture first; delegate production after the decision boundary is stable.
The six-phase production workflow
Canonical structure
Lock project identity, thesis, major sections, sequence, and overall logic before detailed generation begins.
Section / chapter skeletons
Define each unit's purpose, key questions, core claims, exclusions, required examples, and tone constraints.
Core-ideas expansion
Develop the skeleton into detailed internal architecture: arguments, definitions, contrasts, examples, transitions, research anchors, and drift controls.
Full drafting from canonical inputs
Draft one complete unit at a time using the approved skeleton and bullet architecture as structural source files.
Revision and alignment
Review the generated material against explicit failure categories rather than relying on a generic “make it better” revision prompt.
Supporting artifacts
Only after the conceptual structure is stable, generate appendices, diagrams, quick-reference tools, tables, case studies, and other derivative assets.
Control mechanisms
Canonical-input discipline
Common failure mode
A long-running conversation accumulates context. The model is then asked to continue “from what we already decided.” Small reconstruction errors compound over many generated sections.
Workflow response
The drafting stage required the actual structural files for each unit:
- chapter name
- approved skeleton
- approved bullet architecture
The rule was explicit: use those files as structural source material; do not invent replacement structure and do not draft from memory.
Quality review as evaluation
Revision was treated as a separate evaluation stage with named failure classes. This is important because an AI can improve sentence-level style while making the larger system worse.
Drift
Did the output move away from the approved purpose or thesis?
Redundancy
Did separate units begin doing the same conceptual work?
Tone inconsistency
Did the voice or level of explanation change across the project?
Overstatement
Did generated prose become more certain than the evidence or approved model allows?
Conceptual bleed
Did material cross boundaries and appear before or outside its intended location?
Integrity failures
Did simplification, synthesis, or stylistic fluency distort an important distinction?
Extending the same logic to artifact generation
The workflow was later applied to diagrams and supporting visuals. Instead of jumping directly from idea to image, generation was split into separate states:
Specification contains
- purpose and conceptual role
- layout / composition
- major zones and node contents
- relationships and flow direction
- visual hierarchy
- what must be obvious at first glance
- what must be avoided
Why separate specification from generation?
Image or artifact generation creates a high-cost branch in the workflow: once visual details are rendered, it becomes tempting to edit the artifact instead of questioning its structure. Reviewing the specification first keeps structural correction cheap.
Human–AI division of labor
Human responsibility
- define project purpose and success
- approve architecture and boundaries
- decide which distinctions are non-negotiable
- judge whether a stage is ready to advance
- evaluate whether outputs remain faithful to intent
- change the workflow when recurring failure patterns appear
AI contribution
- expand approved structures rapidly
- generate candidate arguments, examples, and transitions
- draft from canonical inputs
- perform structured revision passes
- translate core material into derivative formats
- maintain production throughput across many artifacts
The transferable method
The original project was long-form research and publishing, but the process generalizes to any AI-assisted workflow in which output quality depends on preserving state and preventing premature execution.
| Business / technical analogue | Equivalent workflow control |
|---|---|
| Product requirements → implementation | Do not generate/build before acceptance criteria and boundaries are stable. |
| Research brief → final report | Lock questions, evidence classes, and claim boundaries before synthesis. |
| Knowledge-base migration | Treat approved source documents as canonical inputs, not conversational recollection. |
| AI content pipeline | Separate architecture, generation, QA, and derivative-format stages. |
| Agentic workflow | Assign explicit approval points where downstream action depends on unresolved judgment. |
| AI QA | Use named failure categories and completion criteria instead of generic quality impressions. |
Result
The system converted an open-ended, multi-stage intellectual project into a sequence of bounded AI tasks with explicit inputs, outputs, review criteria, and human decision points. The key capability demonstrated is not “writing good prompts.” It is designing the process through which AI is allowed to contribute.