ONE MORE CONTROL

A scientific reasoning game where you win by choosing the experiment that proves you wrong.

Comment

Inspiration

In the AI era, preserving human judgment and learning how to troubleshoot feel like essential skills to me. AI can often provide a correct answer, but it may not explain why the other paths fail—or notice the human choices and possible sources of error that shape a process.

I wanted to make a game that trains logical elimination rather than answer collection. Players practice asking what evidence would rule an explanation out, looking at the same problem from another direction, and thinking about both the result and the path that produced it. Repeating that habit can gradually build stronger reasoning and judgment. This first case uses biochemistry, but I believe the same learning pattern applies across many fields.

What it does

ONE MORE CONTROL is a browser-based scientific reasoning game. The current submission includes one complete case, The Fading Signal. It begins with a synthetic enzyme-assay observation and three plausible mechanisms: catalytic inhibition, enzyme loss, or optical interference.

Players assign their initial beliefs, spend a limited experimental budget, and predict which hypotheses each test should separate before running it. Experimental outcomes come from a deterministic authored engine, never from a language model. A Bayesian evidence model tracks how much each result changes the hidden posterior while players update their own beliefs separately.

At the end, the player submits a mechanism, cites two results, falsifies an alternative, and receives a reasoning fingerprint showing falsification index, redundancy rate, evidence efficiency, and calibration gap. The featured route combines a temporal control with an orthogonal measurement because that pairing communicates the central lesson most clearly. An alternate 38-unit abundance-plus-titration chain is also scientifically decisive and can earn 100.

How we built it

I built ONE MORE CONTROL with Codex as an English-first responsive Next.js application using TypeScript, Tailwind CSS, and the official OpenAI JavaScript SDK.

GPT-5.6 serves two bounded roles through the Responses API. First, it interprets a locally generated synthetic observation image. A strict structured-output schema limits that response to visible evidence, controls, missing controls, ambiguity, and confidence. Second, after deterministic scoring, it reviews only the server-validated reasoning trail and returns constrained feedback. The model cannot rank the starting hypotheses, reveal the mechanism early, give wet-lab instructions, invent an experiment or outcome, or alter the result trail. If either route is unavailable or fails semantic validation, an authored fallback keeps the game fully playable.

The scientific truth lives in a separate server-only module. The experiment route validates the player's action, returns a pre-authored result, and recomputes the Bayesian posterior from run history rather than trusting the browser. Server code owns claim support, score, posterior, budget, cost, every experimental outcome, and the true mechanism. GPT-5.6 may review observed, server-validated outcomes after scoring, but it cannot create, change, or score a result. Small pure functions handle normalization, KL information gain, scoring, budget rules, and state transitions. Anonymous progress stays in local storage, so the demo needs no account or database.

Codex helped me turn the product blueprint into an implementation plan, establish the AI/truth boundary, build the interface and state machine, implement the deterministic case engine, generate invariant-focused tests, and refine the end-to-end player experience. I kept the product, scientific, engineering, and visual decisions explicit throughout the primary build thread.

Challenges we ran into

The hardest part for me was deciding what this project should be. In my first discussion with GPT-5.6, it suggested a social-themed concept. It was creative and could help people organize decisions, but it felt more entertaining than constructive—and I already make games most of the time. For this competition, I wanted to build something different: meaningful depth, an idea beyond simply rebuilding a familiar tool, a connection to my own background, and a starting point grounded in a human need. Those constraints eventually led me to ONE MORE CONTROL.

Once the direction was clear, the hardest design problem was deciding what AI should not do. Allowing a model to invent experiments would make the experience flexible but scientifically untrustworthy. The architecture separates interpretation and review from truth: GPT-5.6 can help a player inspect the opening observation and review a completed reasoning trail, while deterministic authored code controls every outcome, numeric update, score, and claim-support decision.

A second challenge was making Bayesian information gain understandable without turning the game into a statistics lecture. I connected the math to visible consequences: a limited budget, prediction splits, hypothesis survival states, and result roles that distinguish low-value repetition from a low-increment but independent confirmation.

I also needed to keep the hidden answer off the client while preserving a smooth anonymous game. Server-only truth, validated run history, and a separate verdict route let the debrief reveal the mechanism without shipping it in the browser bundle.

Accomplishments that we're proud of

  • A complete briefing-to-debrief game loop built around falsification rather than chat.
  • Two bounded GPT-5.6 features—observation interpretation and post-score reasoning review—with strict structured output and reliable authored fallbacks.
  • Deterministic experimental truth that the language model cannot rewrite.
  • A tested Bayesian engine that makes low-information repetition visibly different from decisive controls.
  • A reasoning fingerprint that turns scientific habits into player-facing feedback.
  • A responsive, anonymous experience that remains playable without an API key.

What we learned

Personally, I learned to let go of control. I usually want to intervene in every detail, but this collaboration worked best when I set the direction, protected the things that mattered to me, and trusted Codex to carry the implementation forward. Sometimes that honestly meant stepping away from the keyboard for a while, watching the project take shape, and returning with clearer product decisions.

From the game itself, I learned that this kind of reasoning practice is not limited by age or field. The most useful educational AI does not always collapse uncertainty; sometimes its best role is to preserve competing explanations and leave causal judgment to evidence. With more time, I would add much more art direction and visual polish so it feels even more like a beautiful, dramatic game. I love beautiful things, and I think beauty is part of what invites people to stay with a difficult idea long enough to understand it.

What's next

The next authored case is The Weak Mutant, which explores how to distinguish a catalytic defect from low protein abundance or incomplete cofactor loading. It is planned, not part of the current submission build.

After that, I would add restricted natural-language mapping to pre-authored experiment cards, bounded Socratic questions, an instructor-reviewed case editor, more scientific domains, and accessibility options for an optional uncertainty soundscape. The deterministic engine would continue to own every result.

AI and Codex disclosure

GPT-5.6 is used in two bounded server-side routes. First, it interprets the visible synthetic observation through strict structured output. Second, after deterministic scoring, it reviews only the server-validated reasoning trail. Server code owns every experimental outcome, posterior, cost, score, true mechanism, and claim-support decision; model output that invents an outcome, number, or experiment is rejected in favor of an authored fallback.

Codex was the primary development collaborator for architecture, implementation, tests, visual iteration, truth-boundary hardening, and responsive verification. The submitted /feedback Session ID points to the main thread where the majority of the core functionality was built.

Built With

Share this project:

Updates