Clause — Grammar Mission

Inspiration

It started with a Google Form, honestly. Teachers have been making "grammar escape rooms" for years now, TPT bundles, Genially templates, Boom Cards, all the same basic idea: a story, a few puzzles, a lock code at the end. Kids genuinely love it. But every version of it we looked at was completely static. The teacher has to sit down and write every single sentence, every wrong answer, every hint, the whole answer key, by hand, before class even starts. And even after all that work, it can only grade exact matches or multiple choice, because a spreadsheet has no idea that "the kingdom will have fallen" and "the kingdom would fall" are both perfectly fine fixes to the same tense mistake.

That's really where this came from. The game itself already works, kids like it, teachers already use it, but the content and the grading underneath it were doing basically none of the teaching. Grammar's one of those subjects where there's often more than one right way to fix a sentence, and yet almost every tool out there just teaches kids to match one accepted phrasing. It felt like an obvious fit for GPT-5.6, not to replace the escape room format, but to finally fix the part that was always the bottleneck: writing the content, grading what a kid actually typed, and giving a hint that's actually about their mistake instead of a generic one.

What it does

You pick a grade level, a topic, and a theme, and GPT-5.6 builds you a fresh escape room right then, intro story, a few puzzle stages, a final lock code. Students play it in the browser: sorting words, fixing a broken sentence, correcting a tense error, that kind of thing. Instead of picking an answer from a list, they type their correction, and it actually gets read and graded, the model says what rule it's checking, gives a verdict, and if it's wrong, gives a hint based on that specific mistake instead of "try again." If a student thinks the grade is wrong, they can push back on it, and the model either admits it was a fair call or explains exactly which rule they broke. At the end the teacher gets a plain-English summary of what the class actually struggled with, so it's not just a fun Friday activity, it's something that tells you what to teach next.

How we built it

• React frontend, single page. Each puzzle type is its own component so we could add or swap them without touching everything else.
• Backend is pretty thin on purpose, a handful of endpoints (generate-room, grade-answer, appeal, session-summary), each hitting GPT-5.6 with its own JSON schema instead of one big prompt trying to do everything.
• The grading always follows the same order: say what rule it's checking, give the verdict, hint if wrong, let them retry, and always leave the door open to challenge the result. Keeping that order fixed is basically the whole trick, it's what makes it feel like tutoring instead of a red X.
• Design-wise we ended up splitting things into two layers: a calm teal "brand" layer for the dashboard and sign-in stuff that a teacher sees, and then three swappable themes (Detective Office, Cursed Castle, Sci-Fi Lab) that only show up once you're actually inside a room.
• We built it with Codex doing most of the scaffolding and endpoint work, which freed us up to actually spend our time on the parts that mattered, is this grading too harsh, does this hint give too much away, would a teacher actually trust this dashboard.

Challenges we ran into

The scariest part of the whole build is the grader, honestly. If it wrongly marks a correct answer live in front of judges, the entire pitch falls apart in that one moment. So we ended up spending real time throwing deliberately annoying test cases at it, tense choices that are both arguably right, collective nouns, stuff like that, before we trusted it enough to demo.

We also had to actively stop ourselves from building too much. Four puzzle types, three full themes, a whole dashboard, appeals, adaptive difficulty, ranks, all of it sounded reasonable on its own, but trying to build everything would've meant nothing was actually finished. Cutting down to one polished theme and two AI-graded puzzle types was harder to accept than it sounds, but it was the right call.

Tone was a weirder problem than we expected. An 11-year-old wants a hint that's fun. A teacher deciding whether to trust an AI grading their students wants something calm and boring, honestly. We kept accidentally letting one bleed into the other, a teacher dashboard dressed up like a detective board, or a grading message that sounded like a corporate error code, until we just made it a hard rule: teacher-facing stuff stays plain, gameplay stuff gets to be fun.

And then there was just plain accessibility stuff we didn't think about until we hit it, gold text on a light background looks great until you run a contrast checker, and our dark sci-fi theme needed its own pass instead of just reusing the light theme's colors.

Accomplishments that we're proud of

Getting the grader to be appropriately unsure of itself is probably the thing we're most proud of, it doesn't just guess on ambiguous answers, it flags them and lets the student explain. The appeal feature ended up being the best part of the whole demo, actually, watching the model get challenged and reason its way through a rule instead of just repeating "incorrect" is more convincing than any explanation we could give about how it works. We're also just proud we ended up with something that a teacher would actually trust and a kid would actually enjoy, because those two things fight each other more than you'd think. And we shipped a real, working loop, generation, grading, hints, appeal, summary, in a week, with five separate GPT-5.6 calls each doing one specific job instead of one prompt trying to do it all.

What we learned

Structured outputs turned out to matter way more than we expected, once every step (generation, grading, hints, appeals, summary) had its own schema instead of sharing one prompt, the whole thing got a lot more trustworthy. We also learned grading grammar is genuinely harder than it sounds, a grader that isn't told to be cautious will confidently mark a correct answer wrong, which is exactly why we ended up building in the "when unsure, ask the student" behavior. The kid-friendly vs. teacher-trusted tension turned out to be two separate design problems, not one, and splitting the product into a plain layer and a themed layer solved most of our back-and-forth arguments on its own. And Codex genuinely changed how the week went, not doing the boring scaffolding ourselves meant we had more time left for the decisions that actually needed a human, like whether a hint gives too much away.

What's next for Clause — Grammar Mission

• Finish the other two themes and puzzle types so every topic actually has a fully AI-graded path, not just the one theme we polished for the demo.
• Make the difficulty actually adapt to what a group is getting wrong, instead of just a generic "harder/easier" toggle.
• Add a second AI pass that checks its own generated puzzles before a teacher ever sees them, so obviously ambiguous or broken items get caught early.
• Get it in front of a few real classrooms and see if the grading holds up against actual kid handwriting-to-text weirdness, not just our own test cases.
• Eventually explore regional language support and a lighter-weight delivery option (WhatsApp-native, maybe) for schools that don't have a device per student, that's a market almost nobody in this space is actually building for.

Built With

• chatgpt
• codex
• groq
• nextjs
• supabase
• turnstile
• typescript
• upstash