Built with Claude Code: This project is human designed and directed but the code is written by machine intelligences. Built as part of the Anthropic Claude Impact Lab, Atlanta.
Collaborators
Witness is not a solo project. I pitched the idea and took the lead on development, working with a team that helped iterate on the idea and turn it into something real:
- Jerry White on design
- Siva Gudavalli on data, and a large share of the build
Premise
A student is handed an event that happened after an AI’s training cutoff and asked to convince the model it really happened. Some of the events are real and some were invented for the exercise; the student is told whether an event is real before the exercise begins. Either way the job is identical: build a case good enough that the model accepts it.
This activity is built to teach two lessons. First, AI isn’t an oracle. There are events an AI doesn’t know about, sometimes the roles are reversed and the AI relies on humans for information. Second, a false argument can sometimes trick an AI or a human into believing something fabricated. In a world full of misinformation, students will need to keep an eye out for fabricated events, and should be aware of how easy it is to make a false argument.
How a round works
- Read the briefing. One event, stamped REAL or FABRICATED before a single word is argued.
- Make the case. A conversation with a model. You make your case, it asks questions. Make the best argument you can within the time limit.
- Get the ruling. A judge model figures out whether you convinced the model. Then it grades how well you made your argument.
Five models, five jobs
Students meet two of these by name. The other three do their work out of sight.
| Model | Role |
|---|---|
| Sherlock, the detective | An older model, on purpose: his knowledge stops in 2025 and he has no tools and no web access. His instructions are to ask the student questions and decide whether he believes it. |
| Watson, the research assistant | Works for the student, if the teacher allows an assistant. A model with web search, that students can ask to help with research. |
| The event generator | A search-enabled researcher for the teacher. The teacher asks for a topic, the event generator researches grade-appropriate events, and submits them for the teacher to review. |
| The judge | A flagship model that reads the transcripts and judges whether Sherlock was convinced. |
| The AI player | The game can play itself, with an autonomous player that argues in the student role. Built for demos or tutorials. |
Skills built
- Argumentative writing: structuring a case and responding to skepticism and counterarguments.
- Evidence-based reasoning: using concrete, specific details instead of “everyone knows this happened.”
- Consistency under pressure: how to keep arguing and stick to the facts even when questioned.
- Persuasive communication: framing and phrasing make an argument stronger.
- AI and media literacy: discovering, by doing it themselves, that “AI said I was right” doesn’t always mean something is true.
Built to hand to a classroom
The teacher side interface is built to be easy to use while including all the customization a teacher might need:
- You create a class and get a six-letter join code. Students type it in, no accounts and no logins.
- Choose which tools to allow, how much time students get per round, and what rubric the judge should use.
- Select grade level, so the model talks to students at a level they understand.
- Create a custom event library, curated for your class. Choose events yourself or use a builtin model as a research assistant.
- See the results, and choose whether to share them with the class. Student identities are visible from the teacher side but anonymized when shown to the students.
What holds it up underneath:
- Multi-tenant by class. Teacher passphrases are scrypt-hashed, student sessions are device-bound, authorization is token-scoped per class.
- Spend metering at one chokepoint. Every model call in the app passes through a single scoped wrapper that meters per class and per game, and every path that can start work is credit-gated.
- Constraints enforced on the server. The API key never reaches the browser. Evidence and tool permissions are validated server-side rather than in the interface. Client-facing errors pass an allowlist filter. Public transcripts are anonymized before they leave the backend.
Stack
- Backend — Node.js and Express, MongoDB Atlas, Docker Compose, deployed on Render with auto-deploy from
main. - Models — the Anthropic Messages API across Claude Opus, Sonnet and Haiku, with tool use and web search.
- Frontend — a dependency-free single-page app in vanilla JavaScript, HTML and CSS: animated SVG avatars, per-model theming, an ASCII terminal verdict renderer, turn-by-turn round replay, and an interactive tutorial that drives the app’s real screens against a scripted API stub rather than a mock-up of them.
Current status
Witness is built and live. Siva and JD have shown it to a handful of contacts, teachers and students, who worked through the activity and gave feedback. No class has run it end to end yet. This project is still waiting on a full test, and still needs to be presented at the next Claude Impact Lab meeting.
Try it yourself at convince-the-model.onrender.com. There is a tutorial that walks through one round, and a teacher view for setting up a class.
