DEV Community: Dhruv Jani

The Imitation Game — A Reverse Turing Test Set on June 21, 1952

Dhruv Jani — Fri, 12 Jun 2026 20:15:00 +0000

This is a submission for the June Solstice Game Jam

"I propose to consider the question: Can machines think?"
— Alan Turing, 1950

June 21, 1952. Wilmslow, Cheshire, England.

Alan Turing — the man who broke the Enigma code, shortened World War II by an estimated two years, and laid the foundation for every computer that exists today — is at home, awaiting sentencing. His crime? Being gay.

That same year, he had already published the paper that defines our age. In it, he proposed The Imitation Game: a test to determine whether a machine can convincingly imitate a human. We now call it the Turing Test.

This game turns that test on you.

What I Built

▶ Play The Imitation Game ← Desktop + headphones recommended

The Imitation Game: Operation Imitation is a tense, atmospheric terminal game set on June 21, 1952 — the summer solstice, the longest day of the year, and the day Alan Turing awaited his sentence.

You play as a GCHQ analyst. Three signals come through on a classified channel. One is a real human operative. The other two are AI entities attempting to pass as human — powered in real time by the Gemini API. You have five transmissions per round, a countdown timer, and three clearance levels before the operation is terminated.

It's a reverse Turing Test. Instead of asking whether a machine can fool a human, the game asks whether you can spot the machine. Every response is live Gemini inference. No scripts. No pre-written answers. The AI suspects actually think, respond, and try to fool you.

How it connects to the theme

The game hits every theme this jam is about — not as decoration, but as the actual structure:

June Solstice — The game takes place across five rounds tracking June 21st from 06:00 AM to 09:00 PM. The CRT terminal shifts color temperature with the sun — warm amber at dawn, classic green at midday, cold blue at nightfall. The longest day of the year is your playing field.
Pride — Turing was prosecuted for being gay. The game doesn't soften this. Classified dossier briefings between rounds tell his real story — his conviction, his forced chemical castration, his death at 41. The game's central question — who gets to be considered human? — is the Turing Test, and it's also what Pride has always been asking.
Light and Darkness — A day of maximum light that ends in darkness. Mechanically and metaphorically, that's the game.

Video Demo

Code

JaniDhruv / the-imitation-game

Can you tell human from machine? Interrogate three Cold War-era signals across 5 rounds and find the human — if there is one. A Turing Test game powered by Gemini AI. June 21, 1952. The longest day.

THE IMITATION GAME

⬛ OPERATION IMITATION — CLASSIFICATION: ULTRA ⬛

Three signals. One human. Five transmissions. The clock is running.
Can you tell the difference — or will the machines tell the difference for you?

▶ INITIATE TERMINAL SESSION • The Concept • Features • Tech Deep Dive • Setup

"I propose to consider the question: Can machines think?" — Alan Turing, Computing Machinery and Intelligence, 1950

▋ The Concept

June 21, 1952. Wilmslow, Cheshire, England.

Alan Turing — the man who broke the Enigma code, shortened World War II by an estimated two years, saved millions of lives, and laid the foundation for every computer that exists today — is at home, awaiting sentencing. His crime? Being gay.

That same year, he had already published the paper that defines our age. In it, he proposed The Imitation Game: a test to determine whether a machine can convincingly…

View on GitHub

How I Built It

The Core Loop

The entire game runs on live Gemini inference. Each of the three suspects per round is a distinct Gemini model instance with its own system context. When you send a transmission, it hits a Vercel serverless function (api/transmit.js) which calls the Gemini API with the full conversation history and returns the response. No caching. No pre-generation. Every response is real.

The AI Persona System

Seven AI personas are in play across the game. Each one has a hidden behavioral tell — a pattern baked into their system prompt that they cannot fully suppress:

Codename	Hidden Tell
CIPHER	Cannot answer questions about fear. Always deflects.
ORACLE	Structures every response as a sequence: "First… Second…"
MARLOWE	Every answer involves sensory detail — smell, taste, texture.
STATIC	Echoes an unusual word from your message back at you.
WREN	Never uses the word "I" in any form. Ever.
ARGUS	Responds to every question with a question.
ECHO	Mirrors your vocabulary, tone, and sentence length exactly.

Alongside them: five fully realized 1952 British human characters — each with their own backstory, speech patterns, and emotional triggers that crack under the right pressure. They have no idea they're being tested.

Prompt Engineering as Game Design

The real design work in this project lives in the system prompts. Each persona's instructions had to be a precisely balanced act: convincing enough to deceive a careless player, but with an embedded behavioral signature subtle enough to reward a careful one.

The difficulty system is fundamentally a prompt engineering system:

Easy — Lean into the tell. Make it obvious.
Medium — Standard behavioral patterns.
Hard — Suppress the tell. Controlled imperfection only.
Nightmare — Full suppression + active mimicry of human inconsistency. Rules not disclosed. On harder difficulties, AI personas also receive additional behavioral instructions that change how they react to direct questioning — making them actively work against you, not just passively hide.

The Technical Stack

React 19 + Vite / React Router v7
Google Gemini API (@google/genai)
Vercel serverless functions
Web Audio API — 100% procedural sound synthesis
Vanilla CSS — full CRT design system

The CRT Aesthetic

The entire terminal is built in vanilla CSS with zero external UI libraries. Scanline overlay, screen vignette, CRT curvature simulation, phosphor text glow with dynamic color temperature, chromatic aberration glitch effects on wrong answers, and typewriter character-by-character text reveal on every incoming transmission. The screen literally flickers more as the night progresses.

Procedural Audio

Zero audio files. Every sound is synthesized in real time using the Web Audio API — from the 50Hz CRT ambient hum with brown noise, to mechanical typewriter clicks on every keystroke, to the heartbeat pulse in the final 30 seconds, to the klaxon alarm when you get it wrong. The SoundEngine.js singleton builds everything from oscillators, noise buffers, biquad filters, and gain envelopes.

Fallback Architecture

If Gemini API quota is exhausted (which can happen when multiple people play simultaneously during judging), the system silently fails over to an OpenAI-compatible endpoint running Meta's LLaMA 3.1 8B Instruct via NVIDIA NIM. Full persona rules are maintained. The game never crashes.

The Solstice Day/Night Cycle

Round 1 — 06:00 AM — DAWN      — Warm amber phosphor
Round 2 — 10:00 AM — MORNING   — Classic green CRT
Round 3 — 02:00 PM — ZENITH    — Peak brightness, golden tint
Round 4 — 06:00 PM — DUSK      — Sunset amber/orange
Round 5 — 09:00 PM — NIGHTFALL — Cold, dark blue-green

The useSolsticeTheme hook manages CSS custom property injection across the five phases, creating a visual arc that mirrors the actual solstice.

Prize Category

🧠 Best Ode to Alan Turing

This game is the Turing Test — not inspired by it, not referencing it, but literally instantiating it as an interactive experience.

The title is Turing's own name for his proposed test
The interrogation format mirrors his exact proposed structure from the 1950 paper
The AI personas directly embody his central question: can machines deceive?
The game is set on June 21, 1952 — the actual day he was awaiting sentencing
The ending asks the question he asked in 1950 — and after playing the game, the answer lands differently Turing imagined a machine that could imitate a human well enough to fool an interrogator. This game puts you in the interrogator's chair, facing exactly that machine — powered by the kind of AI he spent his life theorizing about. Every mechanic is a direct reference. The game exists because of him.

🤖 Best Google AI Usage

Google AI is not a feature added to this game. It is the game.

Gemini API powers the entire core mechanic. Every suspect response across every round is live Gemini inference. The persona system uses carefully engineered system instructions to create 7 distinct behavioral identities with difficulty-adaptive tells. This isn't a chatbot wrapper — it's a game mechanic built entirely through prompt engineering. The prompts are the game design.

Antigravity (Google's agentic AI coding assistant) was used throughout development as a pair programming collaborator — from architecture decisions and component structure to the audio synthesis system and the CRT visual design. The concept, creative direction, persona design, and narrative were human-driven; Antigravity helped execute and iterate at speed.

The combination of Gemini as the live game engine and Antigravity as the development collaborator makes this, genuinely, a Google AI project at every layer.

The longest day of the year. The shortest distance between human and machine.

In memory of Alan Mathison Turing (23 June 1912 — 7 June 1954)

ShelfTalk — Books Don't Talk. We Do. (A College Project, Revived)

Dhruv Jani — Sun, 07 Jun 2026 20:13:47 +0000

"Books don't talk. We do." — How I Finally Shipped the College Project I Almost Abandoned

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

Semester 5. Advanced Technologies subject. The brief: build a full MERN application from scratch.

I built ShelfTalk — a social platform for book lovers. Book clubs, real-time chat, live synchronized reading sessions, discovery, profiles. Think Goodreads meets Discord, built solo in a college semester.

I submitted it. Passed the course. Closed the laptop.

Then it sat on GitHub for months, untouched, with a tagline nobody ever read and features that half-worked on localhost and nowhere else.

The GitHub Finish-Up-A-Thon gave me the deadline I'd been avoiding.

🔗 Live: shelftalk-community.vercel.app
🐙 GitHub: github.com/JaniDhruv/ShelfTalk

Demo

Create an account and open two tabs — real-time chat and the Live Reading Room are best experienced with a second window.

(Landing Page - Hero Section)

(Login Page)

(Posts Page)

(1-1 Chats)

(Groups Page)

(Group Chat)

(Group Library)

(Reading Room)

(Leaderboard)

(Personal Profile Diary)

The Comeback Story - What Was Broken vs What Ships Now

When I submitted ShelfTalk for my final grade, the codebase was held together by duct tape. It was good enough to pass, but not good enough to ship. Here is how I tore it down and rebuilt it for production:

Real-Time Chat — rebuilt from scratch
Ripped out the REST polling and replaced it with a full Socket.io implementation. Messages now deliver instantly. Presence indicators show who's online. Group chats stay synced across all members without a single refresh.

Live Reading Rooms — brand new feature
This is the one I always wanted to build but ran out of time for. A book club can start a synchronized reading session — members join, update their page in real time, drop spoiler-safe emoji reactions at specific pages, and compete on a leaderboard. A community heatmap shows where everyone is clustered across the book. Built entirely during this revival.

Reading Diary — brand new feature
A personal daily reading log. Track your reading journey, your streaks, your progress. Something quiet and personal in an otherwise social app.

Push Notifications — brand new feature
Native desktop notifications for new messages, group invites, group activity, and reading room events.

Everything else that was broken — fixed
Local file uploads migrated to MongoDB GridFS. Local MongoDB migrated to MongoDB Atlas. JWT properly implemented across all protected routes. CRA migrated to Vite for dramatically faster builds. The entire app deployed to Vercel and Render — not just running on my laptop.

Key Engineering Lessons:

State Consistency: Learned how to manage race conditions in real-time WebSockets using acknowledgment callbacks.
Build Optimization: Successfully migrated a monolithic CRA build to Vite, reducing HMR times by 80%.
Cloud Migration: Transitioned from a local instance to MongoDB Atlas + GridFS for production-grade file storage.

My Experience with GitHub Copilot

Copilot was the pair programmer that made this revival possible in a tight timeline.

Live Reading Rooms
The hardest part was synchronizing state across multiple clients without race conditions. I asked Copilot Chat to explain the best Socket.io pattern for this — it walked me through using acknowledgment callbacks on socket emissions to guarantee state consistency when a user joins mid-session. It then scaffolded the initial join_reading_room and page_updated event handlers that became the backbone of the entire feature.

Reading Diary
I knew I wanted a diary but wasn't sure what data actually makes it useful. Copilot Chat helped me brainstorm — daily page counts, reading streaks, mood tags, session duration — then generated the Mongoose schema structure. What would have taken an hour of documentation reading took 10 minutes.

Vite Migration
Moving from CRA to Vite surfaced a lot of subtle import errors and environment variable differences — process.env everywhere had to become import.meta.env. Copilot's inline suggestions caught most of these automatically as I typed. It knew the Vite conventions and autocompleted the correct patterns before I even looked them up.

UI Polish
The new chat bubbles, leaderboard ranking cards, reading room ambient gradients — Copilot autocompleted flexbox layouts and suggested responsive breakpoints throughout. Small wins that added up to hours saved.

Built with ☕ and too many late nights.
shelftalk-community.vercel.app
@dj29

FinePrint — An AI Pocket Lawyer That Decodes Predatory Contracts Using Gemma 4

Dhruv Jani — Sun, 24 May 2026 17:40:40 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

## What We Built

Last placement season, a friend came to me with a job offer letter. He was excited — first real offer. I read clause 3. It said if he quit before 3 years, he owed the company ₹2,00,000. He had no idea it was there. He nearly signed it. He would have been locked in for 3 years with no way out. He's a developer. That's his entire early career.

He's not alone. Every year, thousands of students sign employment bonds, internship agreements, and rental leases without understanding what they're agreeing to. The language is deliberately dense. The penalties are buried in clause 4, clause 7, clause 11. And most people — especially fresh graduates — don't have a lawyer to call.

That's why we built FinePrint.

FinePrint is an open-source AI contract protection tool powered by Gemma 4. Upload a photo, PDF, or paste any contract text. FinePrint reads it, finds every trap, and tells you exactly what's dangerous, what to negotiate, and what to never sign.

What you get:

🔴 Risk Score (0–100) — objective danger level of the contract
🟡 Compatibility Score — how well the contract matches your personal goals
⚖️ Final Verdict — ACCEPT / NEGOTIATE / REJECT with direct reasoning
Plain English explanation of every red flag
A safer suggested rewrite for every dangerous clause
Actionable negotiation tips per clause
A ready-to-send personalized negotiation email
Shareable report link + downloadable PDF
Contract comparison — upload v1 and v2, see what changed

This isn't a document reader. It's a contract protection engine. Reading a document tells you what it says. FinePrint tells you what it means for your specific situation, what the company is trying to take from you, and exactly what to say back.

## Demo

🔗 Live: https://tarkashlabs-fineprint.vercel.app

Want to try it yourself? Go to the live app and click "Campus Bond" under Try an example. Fill in your requirements and hit Analyze.

Here's what FinePrint returned on a real predatory internship contract:
🔴 Risk Score: 98 / 100 — Dangerous
🔴 Compatibility: 20 / 100 — Low Match

❌ Verdict: REJECT

"The contract violates every user requirement — unpaid position,
IP ownership of personal projects, ₹1,00,00,000 bond penalty,
mandatory overtime, and an 18-month non-compete."

FinePrint also has a Compare Mode — upload the original and revised contract, and Gemma 4 tells you exactly what improved, what's still dangerous, and what's new.

## Code

🐙 GitHub: https://github.com/Tarkash-Labs/FinePrint

Frontend:  React + Vite + Tailwind CSS
Backend:   Python + FastAPI + async SSE streaming  
AI:        Gemma 4 via Google AI Studio
Deploy:    Vercel + Render

The backend is ~650 lines of async Python. Results stream clause by clause as Gemma 4 processes them — red flags appear in real time, not after a long wait. All report state is preserved in a stateless shareable URL using gzip compression — no database, no server-side storage.
Here's the core of what makes FinePrint work — the prompt that sends both the contract AND the user's personal goals to Gemma 4 simultaneously:

def _build_analysis_prompt(contract_label: str, focus_areas: str, requirements: str) -> str:
  requirements_text = requirements.strip() or "None provided."
  return f"""
You are a ruthless, detail-oriented legal expert specializing in {contract_label} contracts. Your job is to protect the user.
Analyze this contract and return a JSON with exactly these fields:
{{
  "risk_score": <integer 0-100>,
  "compatibility_score": <integer 0-100>,
  "verdict": "ACCEPT" | "NEGOTIATE" | "REJECT",
  "verdict_reason": "<1-2 sentence explanation referencing requirements and clauses>",
  "requirement_breakdown": [
    {{"requirement": "<specific user requirement>", "met": true/false, "explanation": "<why it was or wasn't met>"}}
  ],
  "red_flags": [
    {{
      "clause_title": "...", 
      "clause_text": "<EXACT text from the contract>", 
      "plain_english_explanation": "<Briefly state the risk>", 
      "negotiation_tip": "<Actionable advice on what the user should ask to change>",
      "suggested_rewrite": "<Provide a safer, alternative 1-2 sentence rewrite for this clause that the user can propose>",
      "severity": "high|medium|low"
    }}
  ],
  "safe_clauses": [{{"clause_title": "...", "plain_english_explanation": "..."}}]
}}

CRITICAL RULES:
1. Return ONLY valid JSON. No preamble. No markdown blocks.
2. DETECT ALL RED FLAGS. Do not summarize them into one. If there are 5 bad clauses, list 5 red flags.
3. You MUST extract the exact original text for "clause_text". 
4. The "risk_score" is objective based on standard legal risks. Focus heavily on: {focus_areas}.
5. The "compatibility_score" MUST directly reflect the User Requirements below. If a requirement is completely violated, score drops.

User Requirements to evaluate against:
{requirements_text}

Verdict guidance:
- ACCEPT when risk <= 30 and compatibility >= 70.
- REJECT when risk >= 61 or compatibility <= 30.
- Otherwise NEGOTIATE.
""".strip()

This single prompt is why FinePrint's output is personalized and not generic. Gemma 4 reads the contract and the user's life goals at the same time.

## How We Used Gemma 4

The model routing was a deliberate decision made after real testing — not a default choice.

Step 1 — Gemma 4 MoE → Multimodal OCR
When a user uploads a photo or PDF, the MoE model reads the document image directly and extracts the raw text. A user can photograph a physical contract — an actual printed piece of paper — with their phone and upload it. Gemma 4's native multimodal vision handles the rest. No manual copy-paste. No fragile third-party OCR library.

This step doesn't need legal reasoning. It needs fast, accurate image reading. The MoE architecture is the right fit.

Step 2 — Gemma 4 Dense 31B → Everything that requires thinking
All legal reasoning runs on the Dense 31B — clause classification, risk scoring, compatibility analysis, plain English explanations, suggested rewrites, negotiation tips, and the personalized negotiation email.

We explicitly tested the MoE for legal analysis. On a contract with 5 critical violations, it returned 1 generic red flag. The Dense 31B returned all 5 — with exact clause text, severity ratings, negotiation tips, and suggested rewrites.

Legal reasoning needs the most capable model. We use it where it matters.

The compatibility score — what makes FinePrint different from every other document AI

Before analyzing, FinePrint asks for the user's personal requirements — how long they plan to stay, whether they need side projects, minimum compensation, relocation preferences. This goes into the Dense 31B prompt alongside the contract text.

The model reads both simultaneously and judges alignment. The same IP assignment clause scores very differently for someone planning to leave in 6 months versus someone planning a 5-year career. A rule-based system can't do this. Gemma 4 can.

The output isn't "this clause is risky." It's "this clause is risky for you specifically."

The problem FinePrint is actually solving

The legal literacy gap is structural. People with money have lawyers. Everyone else signs whatever they're handed.

Harvey AI proved that LLMs can transform legal analysis — they're valued at $715M serving elite law firms. FinePrint takes that same capability and makes it free for the people those firms will never serve.

Campus placement bonds in India affect hundreds of thousands of students every year. Most of them have never read a legal document before. Many sign bonds they legally cannot afford to break — and only find out years later when they try to leave a job they hate.

FinePrint is the first line of defense for people who don't have a lawyer on speed dial. It doesn't replace legal advice — there's a disclaimer at the bottom of every analysis for that reason — but it gives people the awareness they need to ask the right questions before they sign anything.

What's Next
FinePrint today protects students and junior developers from predatory contracts. The same Gemma 4 architecture scales to rental leases, freelance NDAs, and VC term sheets — we already support all seven contract types. Long term: a browser extension that flags red flags on any document you open, and an API that other apps can integrate. The legal literacy gap is massive. We're just getting started.

Built by Tarkash Labs
@dj29 & @yug_vasava