LAST SIP

Stack drinks. Slam streamers. A 90-second beach-bar brawl where streamers compete for tips while Twitch viewers help or sabotage, put messages on bomber planes, name customers and vote on disasters.

Comment

Stack drinks. Slam streamers.

LAST SIP is a 90-second beach-bar party game where streamers race for tips, and their Twitch chat decides whether to help them or ruin their run.

▶ Play free in your browser · Source code

Inspiration

Picture a school sports-day game: a pile of stuff in the middle of the field, everyone sprints for it at once, grabs as much as they can carry, and races back. It's chaotic and unfair, and when you drop everything it's always somebody else's fault. (We called it "Rob the Nest" in PE.)

I wanted that feeling as a game for streamers: short enough to play between longer sessions, and simple enough that any viewer understands it in seconds. The whole game comes down to one decision:

Leave now with the drinks you have, or risk stacking one more?

A taller tower earns bigger tips, but it's harder to carry. And on stream, the scariest thing isn't the other players. It's your own chat. When most streamers play a game, chat only watches. In LAST SIP, chat can step in and help you or sabotage you, live.

What it does

Streamers compete

  • Every round is 90 seconds. There's one bar in the middle of a small island, and every streamer races to it.
  • Stack drinks into a tower and carry them to customers waiting around the island. Whoever earns the most tips wins.
  • The tower leans more as it grows, so each extra drink changes how you move, not just your score.
  • Rivals can body-slam you, throw bombs, inflate you with a CO₂ gun until you pop, or ram you with a taxi. There's even a plane that runs out of fuel at the worst moment.
  • Play SOLO against three rival bots, or press CREATE ARENA and share an invite link to play together.
  • At the end, the leaderboard shows who won and who to blame, and you can share your result.

Viewers help or sabotage

Type your channel name and press CONNECT CHAT, and your viewers can use ordinary chat messages:

  • Messages become bomber planes. kaboom or !bomb get him sends a plane towing that viewer's actual message on a banner, then bombs whoever is winning.
  • Care packages help you. mayday drops a parachute crate of bombs next to you.
  • Sabotage ruins deliveries. seagull steals your top drink, swapsies swaps your tower with a rival's, and !chairs swaps positions.
  • Votes pick the next disaster. Every few seconds a ballot appears and viewers type 1, 2 or 3.
  • Chatters show up in the game. Their names appear on customers and rival bots.
  • Every event is credited. A small proof strip in the corner shows a LIVE badge and quotes the exact message that caused each event, so everyone knows who to blame.

No setup: no developer app, no copied token, no bot to install, no game account. Cooldowns and busy-chat ballots keep events readable even on big channels.

A shared daily house rule changes the conditions each day, and your best score and streak give you a reason to play one more round.

How I built it

  • Ideation with ChatGPT. I spent about 13–14 hours with ChatGPT before writing any code, testing ideas until "race for the drinks while your chat picks sides" stuck.
  • OpenAI Codex did the heavy lifting. It researched the concept and built:
    • the first playable prototypes
    • movement and the fixed-step physics simulation
    • the wobbling drink tower
    • the Twitch WebSocket chat client, message parsing, ballots and the customer raffle

Codex came back at the end for the final visual and audio pass, the README, playtest review and bug fixes, and it helped produce the submission video. The Codex session ID is included in the submission.

  • Claude Code stepped in when my Codex usage ran out:
    • the arena redesign, review and polish
    • a "film mode": an autopilot that plays a scripted round with cinematic cameras, so the trailer is rendered straight from the real game

Tech stack

  • JavaScript, Three.js and Vite: runs fully in the browser
  • Twitch chat over WebSocket: anonymous and read-only, no OAuth needed
  • Supabase Realtime: shared arenas
  • Web Audio: gameplay sound
  • Characters and effects drawn in code, plus free (CC0) Kenney environment and vehicle models
  • Deployed on Vercel

Challenges I ran into

  • No Twitch developer access. I made a Twitch account but couldn't get into the developer console (API keys, extensions). It needed phone verification, and my number wouldn't link, apparently a carrier issue on my end. Twitch support was kind but couldn't fix it in time. So I rebuilt the integration around anonymous chat, which turned out better for streamers: zero setup, just type your channel.
  • Timing. I had seven exams in three days and was sick for most of the hackathon. Everything overlapped.
  • AI usage limits. I kept running out of usage at the worst moments, so work moved between Codex and Claude Code to keep going.
  • Making chaos readable. With planes, bombs, seagulls and votes all happening at once, viewers need to see the message, see what it did, and know who sent it. Named banners, a credited event feed and compact standings link those together.
  • Making stacking matter. The tower had to wobble enough to feel risky without feeling random.
  • Testing the actual game. Recorded gameplay showed bots getting tips before reaching customers. Codex traced it to an out-of-date distance calculation, fixed the routing and added a test so it can't come back.

Accomplishments that I'm proud of

  • Real Twitch chat controls the game, live, with zero setup. In the demo, a real chat command turns into a banner-plane attack, and a real vote resolves into an event.
  • It holds up on a busy public channel: real messages and chatter names flow into the game.
  • Every chat event is credited to the person who caused it, so chaos becomes content instead of noise.
  • A complete round in any browser: stack, deliver, fight, results, share.
  • A trailer rendered from the real game by an autopilot.
  • Shipping it through exams, illness and no developer access.

What I learned

  • A great stream moment needs a visible cause and someone to blame. The tower makes greed visible; the viewer's message makes the interruption personal.
  • Constraints can improve a design. Losing API access pushed me to zero-setup chat, which is easier for every streamer.
  • Playing and recording prototypes beats polishing a description. Watching real gameplay found bugs and ideas that planning never would.
  • AI tools work best as a team: ChatGPT for thinking, Codex for building, Claude Code for extra hands. You still have to steer.

What's next for LAST SIP

  • Official Twitch integration once I have developer access: channel points, Bits and EventSub events for bigger moments.
  • Streamer vs. streamer showdowns: two channels in one arena, each chat backing its own streamer.
  • More chat powers, maps and daily challenges, plus stronger team roles.
  • Wider playtesting across small and huge channels.

The core stays simple: race for tips, risk one more drink, and see whether your chat helps you carry it home.

Built With

Share this project:

Updates

Submission history