Symposium: Argue It Out With the Greats

Ancient Greek philosophers argue your modern dilemma in character, then vote with a real decision method. You get a verdict computed in code, with clear conditions to meet.

Comment

Inspiration

Big decisions usually get made alone, late at night, with no one to argue with. When you ask a chatbot, you get one careful, polite answer that rarely helps you decide.

In 1985, Steve Jobs imagined a day when a student could ask Aristotle a question and get an answer. Plato's Symposium is a dinner party where each guest makes their case. I wanted both: a table of great minds who actually disagree, and a method that ends in a decision.

What it does

Symposium seats you at a table of ancient Greek philosophers and lets them argue your very modern question.

  • Choose your table. Pick three to five of nine thinkers on a character-select screen: Aristotle, Plato, Diogenes, Epicurus, Heraclitus, Pythagoras, Epictetus, Hypatia and Thucydides. Socrates can join as a guest with exactly one question.
  • Ask anything. Type your own question, pick an example, or start from today's news.
  • Let them argue. A moderator sets a sharp focus each turn; two philosophers answer and one rebuts, in character, written out by quill on papyrus. Tag one with @ to ask them directly, or talk to one privately. The table remembers the facts you give it, and "Sum up" shows where they agree, where they disagree and what's still unknown.
  • Call the vote. Choose a real decision method: Should I? (a go/no-go gate), Which one? (a weighted decision matrix) or What could go wrong? (a pre-mortem). Each philosopher scores the question, they debate the scores, and they poll out loud.
  • Get a verdict you can trust. The verdict is computed in code from their scores, never made up by the model. It's written on a papyrus scroll in plain words (Yes, Yes if…, Not yet) with the Greek beneath, every philosopher's vote, the conditions to meet, and a plain explanation of how it was decided.
  • Ask "What if…?" Change one fact and the table votes again, showing exactly what changed.

There's also a plain-words guide to each philosopher, optional music, fire and sound effects, a herald who can read the verdict aloud, and a demo mode that runs without an API key.

How I built it

I planned before writing any code, using the Devpost Learn Skill Pack: a scope, a product requirements doc, a technical spec and a build checklist (all in the repo's devpost/ folder). Then I built it slice by slice with Claude Code, testing each slice before moving on.

  • App: Next.js 15, React 19, TypeScript and Tailwind CSS.
  • AI: OpenAI. A fast model (gpt-5.4-mini) runs the moderator, the scores and the polls as structured JSON, validated with Zod. A stronger model (gpt-5.5) writes the in-character speeches, streamed to the browser. Anthropic's Claude works as an alternative provider.
  • Real disagreement: every philosopher has a fixed "lean" (Pythagoras wants the numbers to balance, Heraclitus bets on change, Diogenes votes against anything done for status), so the table genuinely splits.
  • Verdict math: pure TypeScript, separate from the model, covered by 40 unit tests.
  • Art and sound: portraits, scenery and logo painted with OpenAI's image model; music, fire, sound effects and the narrator voice generated with ElevenLabs.

Challenges I ran into

  • The table agreed too politely. Every philosopher runs on the same model, so they drifted to the same cautious answer. Giving each one a fixed lean, and a fairer rule for how a single vote is tallied, turned a lopsided result into real splits.
  • Talk was short and generic. I added a moderator focus for each turn, rebuttals between philosophers, banned filler phrases, and made the table remember the user's own numbers.
  • The first UI didn't work. On a laptop the debate area was barely 127 pixels tall. I rebuilt it around one layout: the table on the left, the full conversation on the right.
  • A verdict that never appeared. A stale-state bug reset the screen right after a vote finished, and later the papyrus writing effect waited forever on an empty line. Both were found by testing the full flow in a headless browser.
  • Making the demo video. Recording one smooth take of a live web app, then laying in voice, music and sound effects at the right frames, took more iterations than building some features.

Accomplishments that I'm proud of

  • The verdict is computed and explained in code. The model argues; the math decides.
  • The philosophers genuinely disagree, then settle it with a real decision method.
  • It feels like a place, not a chat window: painted portraits, a candlelit hall, writing on papyrus and a sealed verdict scroll.
  • Three complete decision methods, a demo mode, tests and full planning docs, built in a day.

What I learned

  • Planning first pays off. Having a scope, requirements and a spec meant every change had somewhere to land, even when I pivoted the whole cast to Greek philosophers halfway through.
  • Giving an AI agent rich, specific context and honest feedback ("this is unusable", "too generic") works far better than one-line prompts.
  • The most convincing AI features keep the model on the side it's good at (language and character) and keep decisions in plain, testable code.
  • Design matters as much as features: the same app felt "vibe coded" until it had a real visual identity.

What's next for Symposium

  • A public deployment with rate limiting, so anyone can try it without running it locally.
  • Shareable verdict links and images.
  • A voice for every philosopher, and a quick "Which philosopher are you?" quiz as an entry point.
  • More reliability: retrying failed vote steps and measuring the cost per vote.

Built With

Share this project:

Updates

Submission history