Open Reading Club

An AI book club where three readers with committed viewpoints debate the book you read, challenge your interpretation, and create a downloadable recap.

Comment

Inspiration

The loneliest moment of reading is often the moment after finishing a great book: you have thoughts, questions, and emotions, but no one nearby has read it.

I participate in a real workplace book club in Korea, and the most valuable part is not hearing a correct interpretation. It is discovering that three people can read the same book and come away with completely different convictions. Those disagreements help me notice scenes I ignored, question assumptions I thought were obvious, and leave the meeting with a wider perspective.

I built Open Reading Club to make that experience available whenever a reader closes a book.

What it does

Open Reading Club turns almost any verified book into an interactive AI book-club meeting.

The user enters a book title and chooses whether to discuss one volume or an entire series. GPT-5.6 verifies the book through web search and displays the sources it used before the meeting begins.

Three AI readers then join the table with distinct emotional, analytical, and contextual perspectives. They introduce themselves, share independent first impressions, discuss memorable scenes, and eventually enter a structured debate.

This is deliberately different from chatting with a single agreeable assistant:

  • Readers maintain distinct interpretations instead of converging immediately.
  • Two readers with opposing positions clash before asking the user to join.
  • When the user states a position, another reader must challenge it.
  • The user can respond, continue listening, add another thought, or end the discussion.
  • A stance map visualizes the participants’ current positions during the discussion.
  • The moderator closes the meeting by connecting the major arguments.
  • The session produces a structured, downloadable meeting recap and preserves the full transcript.

Users can also replace one regular reader with an imagined historical or literary guest. This makes it possible to discuss science fiction with Isaac Newton, political philosophy with Machiavelli, or a modern novel with Jane Austen. Guests do not simply recite biographies; their known work and intellectual perspective shape one meaningful moment in the discussion.

How I built it

The frontend is built with React, TypeScript, and Vite and deployed through Firebase Hosting. A server-only Cloud Functions for Firebase endpoint calls the OpenAI Responses API, keeping the API key out of the browser.

The most important architectural decision was:

Code controls the meeting; GPT-5.6 supplies the language.

A deterministic TypeScript state machine controls the five meeting stages, speaking order, rebuttal targets, user checkpoints, topic limits, and session completion. GPT-5.6 generates the actual dialogue, book verification, private reading notes, stance extraction, and final recap.

Every model response uses strict structured output schemas validated with Zod. Incomplete, malformed, or overly long responses are rejected and regenerated, while persona data and prompt constraints keep each reader’s voice and position distinct.

The server records privacy-safe operational diagnostics such as duration, status, and request ID without logging prompts, transcripts, reading notes, or API keys.

Session state remains in the user’s browser through localStorage. The project has no account system, database, or server-side transcript storage.

How Codex accelerated the work

Codex was my implementation partner throughout the project, not only a code generator.

I repeatedly tested complete book-club sessions, shared transcripts and diagnostics with Codex, and described moments that felt mechanical or socially unnatural. Codex helped translate that qualitative feedback into deterministic product rules and tests.

Examples include:

  • separating personal introductions from book discussion;
  • making first impressions independent rather than reactions to the user;
  • guaranteeing a reader-to-reader disagreement;
  • ensuring the user receives a direct rebuttal;
  • returning to the same challenger after the user answers;
  • preventing the moderator from becoming a debate opponent;
  • detecting incomplete or abruptly truncated dialogue;
  • keeping invited historical guests involved in the main discussion;
  • making the user, rather than the AI cast, the center of the meeting.

Codex also helped build privacy-safe diagnostics, simulate full sessions without spending API credits, evaluate historical guest voices, detect book-specific overfitting, and maintain a fast test suite of more than 200 checks.

Challenges

The hardest problem was not generating intelligent sentences. It was generating a believable social experience.

Early versions behaved like a sequence of chatbot responses. Every reader reacted to the user, everyone spoke with equal frequency, disagreements ended too quickly, and the moderator sometimes moved on just when the discussion became interesting.

API latency created another challenge. A session requires multiple structured model calls, so the interface needed visible preparation states, prefetching, bounded retries, and clear error recovery instead of appearing frozen.

We also had to prevent the experience from overfitting to the books used during development. Prompts and tests were revised so that book knowledge comes from each newly verified title rather than from hard-coded examples.

Finally, historical guests needed recognizable perspectives without becoming impersonation gimmicks, biography recitals, or collections of famous quotations.

Accomplishments that I am proud of

I am proud that Open Reading Club now feels less like prompting a chatbot and more like entering a room where several readers already have opinions of their own.

The system supports both Korean and English discussions, single books and series, regular readers and imagined guests, complete session transcripts, and polished meeting recaps. It also gives the user meaningful control over when to speak, when to listen, and when the discussion should end.

Most importantly, disagreement is not merely requested in a prompt. It is enforced and tested by the orchestration engine.

What I learned

I learned that conversational quality depends as much on timing, turn-taking, memory boundaries, and social roles as it does on model intelligence.

Giving an LLM complete control of the conversation produced polished but structurally weak meetings. Separating deterministic orchestration from language generation made the experience more reliable, testable, and human.

I also learned that small interaction details matter enormously: who acknowledges a comment, whether the challenger responds again, whether a reader sounds spoken rather than written, and whether the user can remember the statement they are answering.

What’s next

Next, I want to improve latency and cost efficiency, expand the imagined guest roster, and let relationships between recurring readers evolve while preserving privacy and user control.

I also want to create richer shareable recap pages and help readers return to unresolved questions after the meeting. The long-term goal is simple: whenever someone finishes a book, a thoughtful and challenging reading table should already be waiting.

Built With

Share this project:

Updates