Canon Fodder Architectural Case Study

Imagine products where content, interaction, and presentation are generated dynamically for each user, context, or use case: marketing experiences that assemble themselves around a customer’s needs, training simulations that adapt to a learner’s pace and gaps, support workflows that reshape around the issue at hand, or interfaces that change based on what the user is trying to accomplish.

Canon Fodder is an AI-native generative experience built as a testbed for that kind of product architecture. In this case, the testbed takes the form of a playful narrative simulation: users provide character input, and the system generates profiles, evolving events, narrated recaps, visual assets, and finale results.

Canon Fodder roster setup screen showing character cards, simulation controls, and a configured arena run. — The product starts with a real setup surface: users configure a cast before the system turns those inputs into governed simulation state.

The simulation is not random selection, a curated template library, or a fixed tabletop-style ruleset. Users 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.

The broader architecture question is how to unlock dynamic, personalized experiences without sacrificing the durability of product state, rules, and outcomes.

I built Canon Fodder end to end as a practical study in stateful AI product design, prompt contracts, LLM orchestration, production-aware user experience, and AI-assisted software delivery.

The Challenge

The opportunity in generative AI is not just better automation. It is the ability to add a flexible layer for variation the product team could not fully anticipate in advance: new content, new interactions, new presentations, and new user-specific paths through an experience.

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?

The Approach: 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.

A generative layer proposes and presents profiles, events, narrative, media, summaries, and variation, while a deterministic control plane accepts, rejects, records, and owns state, rules, validation, continuity, and user-visible outcomes. — The generative workflow contributes proposals and presentation; the control plane retains authority over state, validation, and outcomes.

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.

Freeform characters become generated profiles and traits, runtime constraints, an event proposal, an accept reject or revise decision, and a state plus recap outcome. — Open-ended character input is translated into bounded workflow stages that can be steered, checked, and presented.

Inside that 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.

Canon Fodder day recap screen showing generated arena events, character status changes, and narrative progression. — The day view presents generated events as product state, keeping narration, outcomes, and character changes readable inside the live interface.

From Architecture To Confidence

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.

Repeated simulation runs reveal edge cases and drift, which feed tightened contracts, targeted workflow runners, UI fixture checks, and release decisions based on behavior staying inside bounds. — Evaluation is a repeatable loop, not a one-time approval of a single generated result.

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.

Patterns The System Surfaces

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.

Closing

Canon Fodder is a small, playful surface for a larger product thesis: generative AI can make content, interaction, and presentation dynamic at the level of an individual user or use case, but only if the product architecture preserves authority over state, rules, and outcomes.

The project brings together LLM orchestration, structured outputs, stateful product design, prompt operations, evaluation loops, production-aware UX, and AI-assisted development into a coherent prototype without letting the model become the product’s source of truth.