Debate Me

Inspiration I kept noticing the same thing in myself: I could recognize a concept on a slide and still fall apart the moment someone asked me to defend it. Recall felt like understanding, but it wasn't. The deepest learning I ever did was in classroom discussions, or setup debates, where someone pushed back until I either found the reasoning or admitted I didn't have it.

So I asked a simple question: what if every student had a sparring partner on demand, one that never gets tired, never lets a weak claim slide, and argues the opposite of whatever you believe? That's Debate Me.

What it does You state a claim you're studying, pick your side, and an opponent takes the other side and comes after your reasoning.

It opens with a strong counter-argument and one probing question, then presses through a real back-and-forth (minimum five exchanges). Every argument you make is scored live as strong / weak / off-topic / contains a factual error, shown as a confidence bar, and that verdict feeds back into the opponent so it targets exactly where you're weakest. It escalates as you go: basic counterpoints, then edge cases, then it steelmans your own position before dismantling it. When you finish, you get a structured debrief: a 0 to 100 Debate Score, what you argued well and why, the counterarguments you never addressed, and three things to read next. Don't know enough to debate yet? Paste your lecture notes or an article and it extracts the most debatable claims for you to pick from.

How I built it Frontend/back: Next.js 14 (App Router) with TypeScript and Tailwind. All logic lives in API routes, no separate server. Debate state is held client-side in Zustand and persisted to sessionStorage, so there's no database and no login. Two models in a feedback loop: a generative opponent (llama-3.3-70b-versatile) for the debate, debrief, and reading analysis, plus a separate low-temperature classifier call that grades each of your turns. The classifier's read is injected back into the opponent's system prompt each round. A generative model plus a classifier working together is what makes the intelligence core to the product rather than a chatbot wrapper. Inference: open-source models via Groq's fast free tier, with a Hugging Face Inference API fallback path baked in and selected automatically. Reliability: transient "model busy" errors retry with backoff and fall back across several models; hard failures surface as clean human-readable messages; malformed JSON from the models is repaired and retried before it can break a screen. Deploy: Vercel, one public URL, zero friction to try.

Challenges I ran into The opponent would argue against reality. My first version obeyed "never agree" too literally and started fabricating counter-evidence to defend indefensible claims. I rewrote the opponent around intellectual honesty: concede true facts, then fight on interpretation, significance, and trade-offs instead of denying them. It tried to debate settled facts at all. A student could type "water is $H_2O$" and start a debate. I added a debatability gate that classifies the resolution before the match begins and refuses settled facts and falsehoods, offering a genuinely debatable reframe instead. Formally, I only let the debate proceed when the claim is contestable: $\text{debatable} \in {\text{opinion, value, interpretation, policy, contested-empirical}}$. Stale knowledge. The model would "correct" recent studies it simply hadn't seen. I taught it to respect its own training cutoff and accept post-cutoff evidence provisionally rather than calling it fake. A harsh, context-blind scorer. The classifier judged each argument in isolation and punished brevity, tagging solid rebuttals as "weak" at 90% confidence. I gave it the opponent's prior turn as context and recalibrated it so a concise-but-reasoned argument scores as strong. Free-tier limits. I exhausted one provider's monthly credits mid-build, which forced me to design the provider-agnostic layer and fallbacks that ended up making the whole thing far more robust.

Accomplishments that I'm proud of The intelligence genuinely adapts. Watching the opponent press harder on evidence right after the classifier flags a weak turn is the moment the whole idea clicks. It's honest. It won't manufacture misinformation to win, and it won't let you practice against a fact. The debrief. Turning a messy argument into a score, named strengths, unaddressed counterarguments, and a reading list is the payoff that makes the practice stick. A deliberate, non-generic interface. I rebuilt the UI as a clean editorial diagnostic tool rather than another gradient-and-emoji chatbot, and stripped every tell down to the em-dashes.

What I learned For adversarial tooling, honesty is a feature, not a limitation. The constraints I added (concede facts, gate non-debatable claims, respect the knowledge cutoff) made it more useful, not less. Two small specialized models beat one big prompt. The classifier plus generator loop produces behavior neither could alone. Design a demo to survive reality. Retries, fallbacks, and graceful error copy mattered as much as the core idea once real rate limits and flaky JSON showed up.

What's next for Debate Me Voice mode for spoken debate practice, closer to a real viva or moot. Difficulty settings and named opponent styles (Socratic, cross-examiner, devil's advocate). Saved history and progress tracking so students can watch their Debate Score climb on a topic over time. Class mode: an instructor drops in a reading or a set of resolutions and students debate them as homework. Citations with real sources in the debrief, and shareable debate transcripts.