We built one scenario before we built a second. That was a discipline, not a limitation. The canonical scenario — a Baltic submarine-cable cut at winter peak — exists because it touches every theme a hybrid-warfare curriculum cares about at once: energy security, alliance cohesion, attribution under uncertainty, sanctions design, information warfare, and civilian impact.
Why one scenario
The fastest way to ship a shallow product is to ship ten scenarios. The fastest way to ship a credible one is to ship a single scenario rendered deeply enough that it survives contact with experts. We chose depth. Every entity in the scenario — each cable segment, vessel, substation, and bidding zone — resolves to real data already in the platform, so when a player asks "what was the grid doing at that hour," there is an answer with a citation, not a hand-wave.
A scenario authored on a slide is a story. A scenario grounded in live data is a world you can interrogate.
What was hardest
Two things. The first was information asymmetry: each cell must see only its own slice of the world, and that boundary has to hold under pressure from clever players. We enforce it at the database, not by trust — more on that in a separate note.
The second was plausible consequence. When a cell acts, the world must react in a way an expert won't laugh at. We do not pre-script a branching tree; modern hybrid scenarios can't be pre-written. Instead the Adjudicator drafts consequences anchored in real precedent and real data, and faculty approves, edits, or overrides every one. The hard work was the grounding library behind the Adjudicator, not the prose it writes.
The phased shape
The scenario runs as a briefing, then phased turns of escalating complexity, then a structured debrief. Early phases ask each cell for a couple of actions; later phases open back-channels and force attribution decisions with incomplete intelligence. Scheduled injects — real-world events surfaced at the right moment — keep the world moving even when the cells stall.
What we would reuse
Almost all of it. The grounding library, the inject mechanism, the role-scoped views, and the after-action pipeline are scenario-agnostic. Authoring a second scenario reuses the entire machine; only the world-state seed and the learning objectives change. That is the payoff of building one thing properly before building the second — the second is mostly configuration.
The thing we would not reuse is the temptation to add a scenario before the first one had been run end to end in front of real participants. Watching it run taught us more than another month of authoring would have.