Canon Fodder: Designing a Stateful AI Product
A product and architecture case study in creating dynamic, user-shaped experiences while keeping the system responsible for state, rules, and outcomes.
Canon Fodder began with a product question: how much of an experience can adapt to the user without making that experience unpredictable or untrustworthy?
The product lets people bring their own character choices into a generative narrative simulation. From those inputs, it creates structured profiles, evolving events, narrated recaps, visual assets, and final outcomes. The experience is playful, but the underlying problem is relevant to a much broader class of products: using generative AI to create meaningful variation while preserving product authority.
This case study follows the work from user experience and product behavior through state ownership, generative workflows, evaluation, and delivery. GeekerJoy is Canon Fodder’s creative and publishing home; this Mutomedia case study examines the product and systems work behind it.
Business Context
Many digital products have an opportunity to become more responsive to the person using them: marketing experiences can adapt to a customer’s needs, training simulations can respond to a learner’s pace and gaps, support workflows can reshape around the issue at hand, and interfaces can change based on what the user is trying to accomplish.
That flexibility introduces a product and business constraint. The experience can vary, but it still needs to remain coherent, trustworthy, and operable. Canon Fodder uses a narrative simulation as a practical testbed for that broader product problem.
User Need
The experience needed to accept open-ended character choices without giving up coherence, continuity, or a sense of intentional design.
Canon Fodder is not random selection, a curated template library, or a fixed tabletop-style ruleset. People can bring freeform character choices into the system; generative AI turns those characters into structured profiles with strengths, weaknesses, and behavioral tendencies, and those generated traits become runtime constraints for the simulation. In effect, the system can create new situation-specific rules the engine did not hardcode and could not fully anticipate in advance.
A character’s generated profile can influence an event proposal, and the control plane can decide whether that proposal changes the authoritative state. That level of open-ended variation would be expensive to author by hand and hard to scale with fixed branches; generative AI makes it possible.
Canon Fodder was designed and built through Mutomedia as a practical study in stateful AI product design, prompt contracts, LLM orchestration, production-aware user experience, and AI-assisted software delivery.
Product Opportunity
The product opportunity was to make open-ended variation a designed capability rather than an uncontrolled side effect of using a model.
That flexibility only works if it sits on top of something more deterministic. Canon Fodder was built around that tension: the system needed to generate emergent narrative behavior while preserving state across sessions, maintaining continuity across generated events, keeping structured outcomes separate from prose, and preventing model output from silently becoming the source of truth.
The core question:
How do you let generative behavior create dynamic experiences while keeping the product architecture responsible for state, constraints, and outcomes?
Architecture: A Deterministic Control Plane
The architecture is organized around a deterministic control plane rather than treating the LLM as the application.
The control plane owns state, validation, session flow, and final interpretation of outcomes. Around it, a bounded generative layer interprets character input, proposes events, renders narrative, prepares media, and summarizes results.
The distinction matters. Generative components can suggest, interpret, describe, and enrich the experience, but they do not own the facts. The control plane maintains the authoritative record: what happened, what changed, and what can be shown to the user.
In practice, that means prompt contracts, structured outputs, schema validation, state ownership, runtime checks, and production-safe defaults are treated as product architecture, not as afterthoughts. The simplest way to describe the system is as a state authority boundary: generative components contribute proposals and presentation; the control plane decides whether and how those outputs become product state.
Experience Design
From the user’s point of view, the experience moves from cast setup to generated profiles, evolving events, changing character states, narrated recaps, and a final outcome. The product needs to make that variation feel open-ended without asking the user to understand the machinery behind it.
Inside the system boundary, the workflow is staged around bounded responsibilities. Each generative step receives context selected by the control plane to steer the task at hand, produces structured output, and can be checked before its results affect the product.
Delivery & Evaluation
A bounded architecture is only useful if it can be exercised repeatedly. Because the output is generative, quality cannot be proven by a single golden-path test or one good demo run.
Console-driven workflow runners made it possible to exercise model-facing components directly, without depending on the frontend or waiting for a full end-to-end simulation run every time. That made it easier to catch cases where generated prose, structured output, or state transitions drifted out of alignment.
That discipline matters because AI product quality is not a single test result. It requires repeated iteration: observe enough runs to find edge cases and behavioral trends, tighten contracts where the model needs steering, run targeted checks, inspect the user-facing experience, and build confidence that emergent output stays inside the intended product boundaries.
AI-Assisted Delivery
The project also tested how AI coding tools and chat sessions can participate in software delivery. They functioned as trusted advisors and development collaborators across implementation, security review, prompt editing, test generation, product critique, debugging, and visual design. The workflow moved from task-level prompting toward broader goal delegation with explicit acceptance criteria and verification, while human judgment remained responsible for architecture, product direction, polish, and final acceptance.
UI fixtures were a key part of that delivery workflow. They let the tooling inspect and iterate on loading states, final presentation, browser breakpoints, positioning, readability, and other user-facing states directly, without spending time or model tokens driving the entire product through a full simulation just to reach a specific screen.
What the Work Demonstrates
Canon Fodder surfaces several reusable patterns for products that need dynamic generative behavior without giving up product authority:
- Authority boundary: let models generate variation, interpretation, and presentation while the product retains control of state, rules, and outcomes.
- Structured contracts: treat prompts, schemas, and validation as part of the product architecture, not as disposable prompt text.
- Bounded workflow stages: break generative work into responsibilities that can be steered, checked, and iterated independently.
- Confidence loops: use targeted runners, prompt-guidance checks, and repeated behavioral review to find edge cases and steer trends over time.
- Fixture-driven UI iteration: give AI tools fast ways to inspect specific user-facing states across breakpoints without replaying the entire product flow.
- Human-owned delivery: use AI systems as advisors and development collaborators while keeping architecture, product judgment, and acceptance with the human builder.