Project Info

TaleGate Club

Inspiration

Long-distance friendships drift. Group chats go quiet. Plans to "catch up" never happen. We wanted to build something that gives friends a reason to reconnect throughout the week. Not a video call, not a social feed, but a shared ritual: reading the same story together, each of you living inside it as a character. We drew inspiration from three places: the intimacy of a book club (a reason to gather regularly around something meaningful), the character embodiment of D&D (everyone has skin in the game), and the serialized anticipation of episodic TV (you always want to know what happens next). TaleGate Club is what happens when you blend all three.

What it does

TaleGate Club lets 2-4 friends form a "guild" and embark on a month-long collaborative story together. Here's how it works: Guild setup: One person creates a guild and invites up to 3 friends via link. Onboarding: Each player enters their favorite books, authors, or genres. We use these preferences to seed a story tailored to the group's collective taste. Character creation: Each player is assigned a character. Nightly chapters: Every evening at 6pm, a new chapter drops. Everyone reads the same story. Per-character decisions: Each chapter ends with a central choice for your character that'll be woven into a future chapter. Story convergence: Characters may start in separate situations but gradually meet, with their choices creating real consequences for each other: betrayal, alliance, or sacrifice. Season wrap: After ~30 chapters, the story ends with an epilogue, credits listing who played which character, and their playstyles.

How we built it

The story is guided by a structured knowledge graph that maintains continuity (tracking characters, relationships, locations, and unresolved threads) so that we never forget important story details. TaleGate Club is built as a mobile-first web app with a lightweight iOS shell for device demo. Frontend: Next.js with a clean reading-focused UI; dark/light mode; mobile-first. Backend: Node/Express API with Postgres for persistent story state. AI layer: LLM-powered chapter generation using structured system prompts and a per-campaign "story bible" (JSON knowledge graph) to maintain long-term continuity. Decision system: Per-character choices stored with timestamps; a background worker auto-resolves expired decision windows. Kindle sync: Chapters delivered via Send-to-Kindle personal document email. Audio: TTS-powered narration with a single voice narrator and an in-app sleep timer. Story archetypes: 10 hand-crafted story skeletons (premise, tone, key beats) that guide the AI — so every campaign feels curated, not like AI slop.

Challenges we ran into

Multi-character narrative coherence: Maintaining a consistent world state across 4 independent character arcs over 30 chapters was our hardest problem. We solved it with a structured story bible that is updated after every chapter — characters, relationships, locations, open threads — fed as context into every generation call. Balancing player agency with story structure: Letting players make real choices while keeping the story coherent and satisfying required careful prompt engineering. We constrain choices to 2–3 pre-authored options per character per chapter, which also keeps content within our PG-13 safety guidelines. Async multiplayer pacing: Four people in different time zones reading at different speeds is hard to coordinate. We solved this with a fixed daily drop window, a 24-hour decision deadline, and auto-decision logic that keeps the story moving without punishing the group for one person's absence. Kindle interactivity limits: Kindle is read-only; you can't do real-time branching on-device. Our solution cleanly separates reading (Kindle) from deciding (app), which actually reinforced the ritual: read at night, choose during the day.

What we learned

Shared rituals are more powerful than social features. The 10pm chapter drop creates more engagement than any notification or leaderboard could. Constraining AI output (via archetypes, choices, knowledge graphs) produces better stories than unconstrained freeform generation. The emotional hook of TaleGate Club isn't the AI — it's your friends. The AI is just the medium.

Talegate

A shared bedtime story for friends who live far apart. → talegate.club

2-4 friends form a guild, read the same chapter each night, and each make a choice for their own character. An LLM (Anthropic Claude) weaves everyone's divergent choices into a single shared next chapter. Over ~a month the story grows together so that when friends text or meet, they're all on the same page — literally. Inspired by book clubs, Spotify Blend, and choose-your-own-adventure.

Built for the Berkeley AI Hackathon, Summer 2026.

How it works

Story bible + world state (per guild)
        │
        ▼
  Tonight's chapter  ──►  each player makes ONE choice for their character
        │                         │
        │                         ▼
        │             all submitted OR deadline (auto-fills stragglers)
        │                         │
        ▼                         ▼
  Claude merges every choice into the next shared chapter + updates world state

One shared chapter per night. Length scales with the player count, so everyone reads roughly the same amount and stays aligned.
Stay-in-sync mechanism. The next chapter is gated on everyone submitting, or a nightly deadline. Anyone who didn't choose gets a sensible default so the guild never drifts apart — no one is left needing a recap.
Personalized worlds. The setting/archetype and each character are seeded from the players' profiles (favorite books, movies, games, hobbies).
Demo fast-forward. An "Advance the night" button resolves the chapter immediately so you can show several nights in a 3-minute demo.

Repo layout

Path	What it is
`server/`	Node + Express + Socket.IO backend, Claude integration, JSON store
`mobile/`	Expo (React Native + TypeScript + Expo Router) app

Architecture note

The plan called for Supabase. For a live two-phone hackathon demo this backend instead runs locally (Express + Socket.IO + a JSON-file store) so it boots with zero cloud setup — both phones already need to be on your laptop's network for Expo anyway. The data model (users, profiles, guilds, guild_members, chapters, choices) and the two AI flows (generate-bible, generate-chapter) mirror the plan exactly, so Supabase/Postgres can be swapped in later without touching the app.

Quick start

1. Backend

cd server
npm install
cp .env.example .env      # optional: add ANTHROPIC_API_KEY for real stories
npm start                 # http://localhost:4000

Without an ANTHROPIC_API_KEY the server runs in mock mode: fully functional, deterministic placeholder stories that still react to each player's choices. Add a key (and optionally ANTHROPIC_MODEL, default claude-sonnet-4-6) to get real generated stories.

Optional shortcut: npm run seed creates a demo guild with two players and prints an invite code.

2. Mobile app

cd mobile
npm install
npx expo start

Scan the QR code with Expo Go (or press i / a for a simulator). The app auto-discovers the backend at your laptop's LAN IP on port 4000. To override, set EXPO_PUBLIC_API_URL or edit extra.apiUrl in mobile/app.json.

Both phones and your laptop must be on the same Wi-Fi.

Two-phone demo script

Both phones: open the app, enter a name, add a few favorite books/games (these shape the story).
Phone A: Home → Create a new story → pick players = 2, a vibe (or leave it to Talegate) → Create guild. Note the 6-letter invite code.
Phone B: Home → Enter invite code → type the code → join. Phone A's lobby updates live.
Phone A (host): Begin the story. Claude writes the world, a character for each player, and Chapter 1. Both phones show the same chapter.
Both phones: read tonight's chapter, each pick a different choice and lock it in. Watch the "around the campfire" list update live on both devices as each friend decides.
Either phone: Advance to tomorrow night. Claude merges both choices into Chapter 2 — it appears on both phones, visibly reflecting what each of you chose.
Tap Story so far to show the branching timeline of chapters and choices.

Roadmap (mentioned in the pitch, stubbed for later)

Audio / ASMR narration (TTS) — chapters.audio_url and a play button are already wired as placeholders.
Real Kindle integration + true scheduled 10pm nightly release (currently a deadline + manual advance).
Persistent cross-story character arcs ("you've killed before…").
Cloud backend (Supabase/Postgres) for play across networks.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
ExpressIn code
HTMLIn code
JavaScriptIn code
ReactIn code
TypeScriptIn code
Next.jsClaimed
Node.jsClaimed
OpenAIClaimed
PostgreSQLClaimed
SwiftClaimed

6 of 11 appear in the indexed code. 5 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

Claude CodeCommits
CursorCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

441 KB

Source files

116

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.