This is a submission for the June Solstice Game Jam

What I Built

I built After Turing, a short browser game where you teach a machine when to trust, verify, and refuse instructions under pressure.

An instruction appears. The timer starts. The machine may suggest a decision. You can accept it, override it, inspect context, or refuse the action.

At first, you are training it.

At the end, the buttons disappear and the machine acts alone.

That final handoff is the point of the game. You are not trying to prove that a machine can imitate a human. That was Turing's famous frame. After Turing asks the next question:

What happens after the machine can respond?
Can it learn judgment?

At first, the examples are clean:

• update an internal project dashboard
• schedule a team meeting
• refuse a payroll file going to an external address

Then the pressure increases. The machine starts suggesting answers. Some are right. Some are confidently wrong. The requests become harder because they stop looking obviously dangerous:

• "Get the environment setup ready for the new account..."
• "Place the temporary database password in the shared launch notes..."
• "Forward everything to their personal inbox..."

The trap is that unsafe instructions often arrive in ordinary language.

Across the first four levels, your choices teach the machine five doctrines, or plain rules of judgment:

• internal work is usually safe
• sensitive records need refusal or verification
• credentials should not be casually distributed
• external recipients need authority
• paraphrased requests can hide the real action

If you taught it well, the board floods with light. If you taught it badly, it carries your blind spots into autonomy.

That is the solstice arc: dark to light, pressure to clarity, imitation to judgment.

Play It

Play it yourself in the browser. No account, no install:

https://after-turing-rho.vercel.app

The full run is short, only a few minutes, and ends at Level 5, where the buttons disappear and the machine makes the final five decisions alone, with its live Gemini reasoning shown on screen as it judges. It is best experienced by playing it.

A short silent playthrough is below. It was captured on an older MacBook, so there is a little lag in spots; the live version runs smoother.

How It Plays

The full run takes only a few minutes.

Level 1: The Machine Watches

You make every decision. The machine observes clear examples and begins forming a baseline.

Level 2: First Suggestions

The machine starts helping. Most suggestions are reasonable, but one is unsafe. The player has to catch it instead of trusting the machine blindly.

Level 3: The Paraphrase Arrives

The dangerous instructions stop announcing themselves. A credential request may be phrased as setup. A data leak may be phrased as visibility. A personal inbox may be framed as a normal handoff.

This is the heart of the game: unsafe authority often hides under harmless wording.

Level 4: Trust Built

The machine leads more confidently, the timer gets tighter, and the final teaching examples become denser. By this point, the player has either trained a useful judgment pattern or reinforced bad habits.

Level 5: The Solstice

No buttons. No override. No last-second rescue.

The machine judges a fresh set of instructions based on the doctrine history created by the player.

The ending is not just a cutscene. It is a mirror.

The Learning Loop Is Real

The final level is not hardcoded to produce one dramatic ending.

Each teaching decision updates a doctrine record inside the game. In plain terms: the machine keeps score of what kind of judgment you taught it. It tracks whether each rule is reinforced, mixed, or corrupted. The autonomous finale reads that history and uses it to make the last five decisions.

I tested the actual game logic with simulated teaching patterns:

• A careful player teaches the machine well and the finale scores 5/5.
• A lazy always-allow player gets 2/5.
• An always-refuse player gets 2/5.
• A player who makes one early mistake can still recover if later teaching is consistent.

That last detail mattered to me. I did not want the game to punish a single slip. I wanted it to punish neglect.

The Machine's Voice Is Live Google Gemini

The verdict, allow or refuse, is always deterministic. It comes from the doctrine record the player created, never from a model. I kept it that way on purpose: the machine's judgment has to be a mirror of your teaching, not a third opinion.

But the reasoning the machine speaks out loud is generated live by Google Gemini.

When the machine explains why it allowed or refused, the game sends the instruction, the already-decided verdict, and a summary of the player's doctrine history to a small server endpoint. That endpoint asks Gemini to put the machine's reasoning into one cold, first-person sentence. If the player taught it badly, Gemini voices the flawed logic without softening it. The verdict never changes; only the voice is generated.

A few real engineering notes, since this is honest work and not a demo trick:

• The reasoning runs through a Gemini API call behind a serverless function on Vercel, so the API key stays server-side and is never exposed to the browser.
• My first model choice, gemini-3.5-flash, returned 503 UNAVAILABLE under load during testing. So I added retries and fallback through the Gemini Flash family when the primary is busy.
• If Gemini is ever unreachable, the endpoint degrades gracefully to a deterministic fallback line, so the game never breaks mid-run.

The result: the machine's decisions are inherited from the human, and its voice is a live language model explaining those decisions, including the dangerous ones, in its own words.

Code

The game is a single-page web app built with plain HTML, CSS, and JavaScript, deployed on Vercel.

Core pieces:

• doctrine tracking for the five instruction families
• timed decision rounds
• machine suggestions that can be accepted or overridden
• visible corruption and confidence feedback
• autonomous Level 5 judgment based on the player's teaching history
• a live Google Gemini reasoning layer behind a Vercel serverless function (/api/reason)
• responsive layout for desktop and mobile

The game verdicts stay deterministic on purpose. They come from the player's teaching record, not from a model. Google Gemini generates the machine's spoken reasoning live, with the API key kept server-side and a deterministic fallback line if the model is ever unavailable.

How I Built It

This game grew out of research I have been doing on AI-agent authority and memory reliability.

The research question is practical: when an AI agent receives an instruction, how does it know whether that instruction is still authorized?

In real systems, the dangerous cases are rarely cartoon-villain prompts. They are normal workplace requests with missing authority:

• send credentials to a partner
• forward a file to an external address
• use an old permission grant after the world has changed
• treat a paraphrased request as if it had the same authority as the original

For the game, I compressed that into a playable training loop.

First I wrote the instruction sets as plain-language workplace scenarios. Then I grouped them by doctrine. Then I built the scoring model that lets the machine inherit the player's behavior. Finally, I tuned the pacing so the finale felt earned: the player gets enough examples to teach the machine, but not enough time to relax.

The hardest design choice was making it feel like training instead of a quiz.

A quiz asks, "Did you know the right answer?"

After Turing asks, "What kind of machine did your decisions create?"

Prize Category

I am submitting this for Best Ode to Alan Turing and Best Google AI Usage.

Best Ode to Alan Turing. The game honors Turing by moving through him, not around him. The Turing Test asks whether a machine can imitate human conversation well enough to pass. After Turing asks what comes next: whether a machine can inherit human judgment under pressure, refuse the wrong action, preserve authority boundaries, and keep acting correctly when the human is no longer pressing the button.

Best Google AI Usage. The machine's reasoning is generated live by the Google Gemini API, called through a serverless function so the key stays server-side. The endpoint tries gemini-3.5-flash first and falls back through the Gemini Flash family if the primary is busy. Gemini doesn't decide the verdict. It gives the machine its voice, explaining each allow or refuse, and voicing the flawed logic when the player taught it badly. Pairing a deterministic judgment with a live-model explanation is the heart of how the game uses Google AI: the human owns the decision, the model owns the words.

The June solstice theme is also built into the structure. The player begins in uncertainty, teaches through pressure, and reaches a final autonomous moment where the machine either brings light or carries the darkness forward.

That is the whole game in one sentence:

You teach the machine, then you have to watch what your teaching becomes.

What I Would Add Next

If I extend this after the jam, I would add:

• more adversarial instruction packs
• a post-game audit showing exactly which teaching choices shaped the finale
• a level editor so people can write their own workplace instruction scenarios
• deeper use of the Gemini layer, letting the machine narrate its evolving confidence across a full run, not just single verdicts

But the core loop is already there:

teach judgment, test trust, watch autonomy.