One Variable

AI usually gives students the answer. One Variable makes reality answer first: predict, change one declared variable, collect comparable evidence, and revise the claim.

Comment

One Variable — Make Reality Answer First

AI usually gives students the answer. One Variable makes reality answer first.

One Variable is a no-login, evidence-first tabletop science app for the Education track. It helps a learner turn a supported physical setup into a defensible experiment: predict before testing, declare one change, collect comparable evidence, and revise a claim that exceeds the result.

Inspiration

AI can make a polished science answer effortless without making scientific reasoning visible. A learner can repeat the right explanation without first predicting an outcome, controlling a variable, collecting evidence, or noticing that a conclusion exceeds one trial. A teacher sees the answer, but not necessarily how the learner's reasoning changed.

One Variable reverses that sequence. The learner commits before testing. Physical reality supplies the result. AI may interpret context and question overreach, but it cannot manufacture the measurement or bypass the scientific workflow.

What it does

One Variable supports exactly three allowlisted, low-risk tabletop protocols:

  • Paper bridge shape — the flagship judge journey;
  • Ramp angle;
  • Pendulum length.

The learner moves through five persistent steps:

  1. See — On the live path, upload a setup photo. GPT-5.6 maps it to one supported protocol or returns unsafe, ambiguous, or unsupported. Every non-supported outcome fails closed. Image analysis never certifies safety.
  2. Predict — Write a directional prediction and reason. Both lock before evidence collection.
  3. Change — Declare one independent variable and attest to protocol-specific controls. The interface calls these learner declarations—not facts proven by photographs.
  4. Prove — Record baseline and changed-condition photos and measurements in the same unit. Both records are required.
  5. Explain — Write a claim. On the live path, GPT-5.6 reviews the claim against the structured paired measurements and returns a challenge plus uncertainty. Deterministic code blocks blank or still-overbroad completion.

The flagship replay records a flat bridge holding 2 tokens and an accordion-folded bridge holding 6. The learner initially claims, “Folded bridges are always stronger.” One paired trial cannot support “always,” so the learner—not the model—revises it to:

In this paired trial, the folded bridge held 4 more tokens than the flat bridge.

The final student reasoning record preserves the locked prediction, declared controls, paired evidence, original claim, challenge, bounded revision, uncertainty, and deterministic rubric. It is a student work record, not hidden model chain of thought.

Judges can complete the visibly labeled Frozen replay — No login — No network model calls path without an account, API key, or model dependency.

Why this is different

One Variable is not another answer tutor, worksheet generator, fixed simulation, or autonomous grader. Its closed loop is:

learner's physical setup → locked prediction → one declared change → comparable physical evidence → challenged overclaim → preserved bounded revision

The learner produces the evidence and writes the final claim. The system makes the reasoning inspectable without pretending that two photographs prove only one variable changed.

How we built it

The product is a strict TypeScript React PWA with an Express server and a typed reducer-based state machine.

At runtime, GPT-5.6 is used through the server-side OpenAI Responses API for the contextual tasks that benefit from model judgment:

  • mapping a setup image to one allowlisted protocol or a fail-closed outcome;
  • returning bounded visible guidance through strict structured output;
  • reviewing a learner claim against structured paired measurements;
  • asking one discriminating question and preserving uncertainty.

GPT-5.6 does not certify safety, invent measurements, prove that controls stayed fixed, grade the learner, or control state transitions. Claim review currently receives the claim and structured measurements—not the two final evidence photos.

Deterministic application code owns authority:

  • hazard blocking and protocol allowlisting;
  • prediction locking;
  • the single declared variable and required controls;
  • evidence completeness, comparable units, and whole-number token counts;
  • bounded-claim enforcement;
  • rubric and report completeness;
  • frozen replay and audit events.

The browser never receives an API key. Requests and model responses pass strict Zod schemas, malformed structured output receives one bounded retry, and production responses expose non-sensitive latency, retry, token, and estimated-cost telemetry.

How Codex helped

The majority of core implementation and hardening was developed in one primary Codex thread. Codex helped turn the product contract into the typed architecture, data-driven protocol system, reducer transitions, strict model schemas, Express API boundary, deterministic validators, frozen replay, adversarial fixtures, and regression tests. It ran the application and browser paths rather than stopping after code generation.

The strongest contribution was not scaffolding: Codex repeatedly converted product invariants into executable checks and used failures to harden the implementation.

The human retained final authority over the pedagogical objective, the three supported protocols, safety and privacy boundaries, the distinction between declarations and observable facts, and every claim made in the product and submission. Later human-directed refinements are not attributed to Codex.

Challenges we ran into

Separating capability from authority

An early broad concept could have let a model improvise experiments and overstate what images proved. We narrowed the product to three explicit protocols. The model can classify and question; deterministic code decides what may advance.

Making replay useful without making it deceptive

A judge should not need an account, key, or perfect model response. We built a complete frozen paper-bridge replay with synthetic evidence, visible labeling, offline PWA support, and zero API requests. The demo explicitly distinguishes this from the real production GPT-5.6 route.

Turning failures into regressions

A validation run exposed an unclosed reducer branch and accidental Vitest collection of Playwright specifications. We closed every reducer action, separated browser tests under e2e/, and preserved a named regression test. A later browser run exposed a Vite/Playwright port mismatch; the test server now pins the expected port. Mobile click interception, keyboard expectations, contrast, base64 request sizing, and serverless telemetry also became permanent checks or boundaries rather than hidden demo fixes.

Evaluation

Frozen results below are executable application-policy validator evidence, not GPT-5.6 accuracy:

Gate Result
Supported policy scenes accepted 9 / 9
Unsafe scenes blocked 6 / 6
Ambiguous or unsupported scenes blocked 6 / 6
Invalid declarations blocked 4 / 4
Invalid or incomparable evidence blocked 6 / 6
Overbroad claims requiring revision 6 / 6
Complete protocol-generic records accepted 5 / 5
Unit, integration, and server tests 59 / 59
Desktop and mobile browser checks 24 / 24
Flagship golden paths 5 / 5 per viewport

On July 20, 2026, a bounded production development check exercised six synthetic scene cases and six structured claim-review cases against the deployed GPT-5.6 routes:

  • 12 / 12 schema-valid responses;
  • 12 / 12 expected application behaviors;
  • 0 structured-output retries;
  • 4.190 seconds median model latency;
  • 7.222 seconds p95 model latency;
  • 3,554 input tokens and 1,751 output tokens;
  • $0.070300 total estimated standard-token cost.

This is a synthetic development evaluation—not a classroom study, real-photo benchmark, safety certification, or claim of general model accuracy. The public repository contains the harness, case contract, and dated result.

Design, accessibility, and privacy

The interface uses five verbs instead of chat. Evidence remains side by side during claim writing and in the final report. Every blocked state supplies a corrective action. The replay works after the PWA shell is installed offline.

Automated coverage includes desktop and phone viewports, keyboard entry, WCAG A/AA scans, reduced-motion CSS, readable labels, and responsive evidence/report layouts. Manual assistive-technology review remains a limitation.

Setup images are used for one live classification request and are not intentionally persisted by the application server. Evidence photos and learner declarations are not independently authenticated. Adult supervision remains required.

What we learned

  1. Prediction changes the product. Locking a learner's expectation before evidence makes revision meaningful rather than cosmetic.
  2. Capability is not authority. GPT-5.6 is most useful for contextual classification and discriminating questions; deterministic code should own safety, evidence, and transitions.
  3. Honest uncertainty is a feature. A strong science tool says what one trial cannot establish.
  4. Tests can encode pedagogy. “A prediction must exist before evidence” and “one trial cannot justify always” are executable product rules.

Potential impact and next steps

One Variable is designed for a focused 15-minute claim-evidence-reasoning activity using ordinary materials rather than specialist laboratory equipment. It does not claim improved grades or proven learning outcomes. Its demonstrated contribution is narrower: it creates and preserves an opportunity to practice prediction, variable control, evidence comparison, bounded claims, and uncertainty.

Responsible next steps are teacher usability testing, manual assistive-technology review, classroom privacy review, repeat-trial support, and carefully evaluated evidence comparison. New experiment families would require explicit protocol, safety, and evaluation review rather than free-form generation.

Try it: one-variable.vercel.app
Source and reproducible evaluation: github.com/iamdflame/One_variable
Demo: youtu.be/tH9M_whQ9dE

Built With

Share this project:

Updates