An OPORD-grounded exercise needs a repeatable way to turn source documents into controller-ready runtime materials. Manual drafting was slow, but speed was not the main risk. The harder problem was coherence: every turn had to trace to the same source, carry consequences forward, and remain usable by trainers and controllers under execution pressure.
Supporting system Ongoing
CADE Controller Package Generator
Built the core production pipeline that turns an OPORD into the five-document Controller Package used to run CADE, with source traceability and trainer review preserved across every turn.
Where this fits
This is part of the supporting stack.
This project is part of the wider NextGen Wargame system. It strengthens the production chain around CADE by improving source-package completeness, controller usability, or multi-document workflow reliability.
Project Proof
The useful version first.
Every project is framed as a problem, design move, built system, supporting workflow, evidence set, and transferable skill.
I made the OPORD the governing source layer and generated the package in sequence, not as disconnected documents. That let AI accelerate drafting while human review checked source fidelity, phase continuity, and trainer fit before anything reached execution.
I built an OPORD-to-controller-package workflow that produces a master turn list plus phase-level turn cards. Each output includes situation context, decision prompts, option frames, adjudication triggers, and review-ready structure for trainer approval.
Master turn list generator
Converts the OPORD into a sequenced exercise map organized by phase and turn.
Phase document workflow
Builds four to five turns per phase while preserving consequence state from earlier decisions.
Source-traceability review
Checks generated prompts, triggers, and situation updates against the OPORD before controller use.
Trainer revision loop
Routes trainer feedback back into the model-assisted drafting workflow without rebuilding the package from scratch.
Reusable package format
The workflow produces five controller documents: one master turn list and up to four phase documents.
Supported live execution
The same production pattern supported all three CADE executions.
Source coherence preserved
Turns, prompts, and adjudication triggers stayed anchored to one OPORD-quality source instead of drifting independently.
Architecture improved from evidence
Execution feedback pushed CADE away from fragmented runbook logic and toward a unified Controller Package.
This project shows I can design an AI-assisted production pipeline that preserves source truth, coherence, review gates, and runtime usability across a multi-document product.
Deeper Detail
The Controller Package Generator is the production pipeline behind CADE. It takes an approved OPORD and produces the runtime documents controllers need: a master turn list and phase documents with situation updates, decision prompts, adjudication triggers, and consequence carry-forward. The workflow keeps drafting fast without allowing each document to drift from the source order or from the other phases.
Operating Constraints
- Every turn must trace back to the OPORD — no independent invention of scenario logic.
- Consequence state must carry forward across phases, not reset between turns.
- Controller documents must be usable under time pressure without designer support.
- All outputs require trainer review before execution.
Production Approach
I anchored the workflow to the OPORD as the sole source layer. AI generates draft turn content inside that constraint. I review each document for operational coherence and source fidelity before it goes to the trainer team. Trainer feedback comes back to me; I revise using the model and return updated documents. The workflow has produced Controller Package materials for all three CADE executions.
AI Operator Skill Demonstrated
- Used the OPORD as a hard constraint on AI generation — output that contradicted the source was rejected and regenerated.
- Structured the generation workflow to produce phase documents in sequence so consequence state carried forward correctly.
- Maintained human review as the gate between AI output and execution-ready documents.
- Revised based on trainer feedback using the model, keeping the iteration cycle fast without bypassing review.
Key Decisions
Generate the Controller Package from the OPORD, not from freestanding scenario notes
Reasoning:
Freestanding scenario notes drift. An OPORD-quality source layer forces internal consistency and gives reviewers a fixed reference for checking each turn against source intent. Downstream products that contradict the OPORD can be identified and corrected before execution.
Alternatives considered:
- Draft turn content from a loose scenario summary
- Let each phase document evolve independently
Keep trainers in the review loop before any document reaches execution
Reasoning:
AI generation produces operationally plausible content, but only trainers can confirm that the exercise logic is sound for this unit in this context. Review is not a formality — trainer changes fed directly into subsequent runs.
Alternatives considered:
- Deliver documents directly to controllers and collect feedback after execution
- Run a single design review at the end of production rather than per-document
Tech Stack
- Claude
- ChatGPT
- Markdown
- OPORD-grounded planning workflows
Result & Impact
- 5 (master turn list + up to 4 phase documents)Documents per package
- 4–5Turns per phase
- 3Executions supported
- Trainer-reviewed before every executionReview gate
The Controller Package Generator made CADE reproducible as a production system. The same pipeline can regenerate, revise, and improve the runtime package without restarting from a blank page.
Additional Evidence Signals
One source governs multiple runtime documents
The workflow kept the master turn list and phase documents aligned to one OPORD-quality source instead of allowing each phase to drift independently.
Trainer feedback loops stayed fast
Documents could be revised against trainer input without rebuilding the package structure from scratch, which made repeated executions practical.
Controller-facing runtime artifact emerged
The generator helped move CADE away from fragmented runbook logic and toward a usable Controller Package architecture.
Where This Fits
- An exercise already has an OPORD or source order that can govern downstream generation.
- Controllers need a runtime package that preserves state, sequencing, and consequence logic.
- The main challenge is multi-document coherence under time pressure.
Designed Against Failure Modes
Generation stays sequenced and source-governed so consequence state carries forward correctly.
Output that cannot be traced back to the OPORD is rejected and regenerated before review.
Trainer review remains a mandatory gate before any package reaches live facilitation.
Boundaries
- The workflow does not replace trainer review.
- The workflow is only as strong as the source order that governs it.
- The workflow supports controller execution; it does not automate adjudication authority.
Learnings
- The OPORD is not just reference material — it is the constraint that makes AI-generated exercise content coherent across a multi-document package.
- Trainer review is a production input, not a sign-off step. Changes from the first execution improved the workflow for the second.
- A five-document package generated in sequence preserves consequence logic better than generating all documents simultaneously.