Willie

A persistent social object Twitch communities shape, raid forward, and inherit without resetting.

Comment

Willie

Twitch moves audiences. Willie gives them something worth following.

A raid moves people to another channel. But the thing a community built together usually disappears at the boundary.

Willie changes that.

Willie is a persistent social object for Twitch: one living artifact that communities shape together, creators safely pass forward, and the next community inherits without resetting.

A raid shouldn't reset the story.

Judge Willie in 90 seconds

If you only have a minute and a half, look for four things:

  1. One object survives across communities. Willie keeps its identity, Relay progress, permanent marks, Passport Chapters and Receipts after a handoff.
  2. A raid is evidence, not authority. Twitch can prove a raid happened, but custody still cannot move until the destination creator explicitly accepts.
  3. The community influences without hijacking. Chat can shape Willie and influence rituals while creators retain custody authority.
  4. The system is built to survive failure. Replay protection, concurrency guards, durable PostgreSQL state, provider verification and exactly-once custody commits are part of the product—not demo-only scaffolding.

Live product: https://willie-phi.vercel.app Judge lifecycle: https://willie-phi.vercel.app/judge-v2 Stage Mode: https://willie-phi.vercel.app/stage Source: https://github.com/VictorCyberDev/willie

The idea in 20 seconds

A community shapes Willie. Chat participation changes its visible state, Relay progress and community rituals. The creator chooses where Willie can go next. Community influence never becomes custody authority. Twitch provides raid evidence. Willie listens for the matching channel.raid event. The destination creator must explicitly accept. A raid alone cannot transfer Willie. The authority engine commits custody exactly once. Progress, permanent marks, Passport Chapters and Receipts survive. The next community continues the same story.

The authority chain is intentionally strict:

COMMUNITY INFLUENCES → CREATOR AUTHORIZES → DESTINATION PREPARES → TWITCH VERIFIES → DESTINATION ACCEPTS → ENGINE COMMITS

Why this is more than another Twitch overlay

Most Twitch tools make one channel more interactive. Willie makes continuity itself the interaction.

Polls end. Overlays reset. Bots belong to one broadcaster. Raids move viewers, but the shared artifact normally stays behind.

Willie introduces a different primitive:

Follow the object, not only the creator.

That turns raids into chapters instead of endpoints.

A viewer can encounter the same Willie days later in another creator's stream and recognize the history left by previous communities. A creator can launch a relay that becomes bigger than any single channel. Every accepted handoff adds provenance to the same object.

That is Willie's moat: not a single mini-game, poll or chatbot feature, but a reusable cross-community social primitive that can power creator relays, charity journeys, launches, quests and events.

What streamers and viewers actually do

Viewers

  • Shape Willie's visible state through bounded chat participation.
  • Contribute toward a shared Relay mission.
  • Influence permanent community marks.
  • Participate in destination rituals.
  • Follow Willie's Passport as it moves across creators.
  • Re-encounter the same artifact later and see what other communities added.

Streamers

  • Authenticate through Twitch.
  • Start or join a Willie Relay.
  • Approve the next destination.
  • Prepare a safe handoff.
  • Raid normally on Twitch.
  • Accept an incoming Willie with Hold to Receive.
  • Use Watch Willie, Stage Mode and OBS-friendly surfaces on stream.

The important design rule is that social participation can influence Willie without gaining authority over custody.

The winner experience

Willie is not only backend infrastructure. It was designed to be watchable.

  • Living Willie V2 — a visual object whose state changes with the community.
  • Willie Relay — one shared mission spanning multiple Twitch communities.
  • Permanent Community Marks — durable marks with provenance from each community.
  • Community Decision Rituals — viewers influence the next chapter while creators retain control.
  • Passport Chapters — every accepted handoff becomes part of Willie's history.
  • Watch Willie — follow the current community, Relay and journey.
  • Stage Mode — a room-scale presentation surface for live viewing.
  • Community Legacy — a shareable artifact of what one community contributed.
  • Judge Mode V2 — a clearly labelled simulated replay that lets judges inspect the full lifecycle without confusing simulation with real provider evidence.

Built with Twitch

Willie connects to Twitch through:

  • Twitch OAuth for creator identity and authorization;
  • Twitch EventSub for provider events;
  • Twitch chat participation for bounded community influence;
  • channel.raid evidence for handoff verification;
  • OBS-friendly presentation surfaces for live streams.

Willie's Twitch transport has also been exercised against the official Twitch CLI EventSub simulator through the real transport/parser path. That evidence is labelled CLI_ACCEPTED, not live broadcaster acceptance.

Built with OpenAI Codex

OpenAI Codex was central to the engineering foundation, not just used for snippets.

Codex helped design and implement:

  • the deterministic custody state machine;
  • PostgreSQL authority and outbox persistence;
  • Twitch provider integration;
  • replay and duplicate protection;
  • concurrency and race-condition repairs;
  • property-based testing;
  • failure/restart acceptance;
  • security review;
  • SDK and adapter contracts.

We also used Codex as an adversarial engineering partner: it helped run 10,000 randomized authority sequences, investigate failure modes, surface race conditions and verify the resulting fixes.

Canonical Codex Session ID: 01a171fa-0ed6-750c-8ed5-4ac1c6eab04b

Safety and authority

A cross-community object is only interesting if it cannot be hijacked by normal social activity.

Willie's invariants include:

  • chat cannot transfer custody;
  • a raid cannot automatically transfer custody;
  • destination acceptance is mandatory;
  • duplicate or stale evidence cannot recommit custody;
  • exactly one authoritative owner exists per version;
  • provider gaps pause rather than guess;
  • permanent marks and Passport Chapters are replay-safe;
  • successful handoffs produce durable Receipts.

Engineering proof

The Winner Release is on the repository's default main branch and the acceptance workflow covers:

  • lint and TypeScript typecheck;
  • unit tests;
  • 10,000-sequence property tests;
  • PostgreSQL integration and concurrency tests;
  • Twitch/provider contract tests;
  • browser E2E;
  • failure and restart acceptance;
  • production build;
  • Docker build.

The production Willie runtime exposes health/readiness gates and is migrated through database version 9.

Evidence policy

Willie deliberately separates real, CLI/simulator, contract-tested and simulated evidence.

Judge Mode visibly says SIMULATED WINNER RELEASE · NOT LIVE TWITCH. Twitch CLI evidence is labelled CLI acceptance. Contract-tested provider behavior is not described as live. LIVE_ACCEPTED is reserved for genuine external Twitch behavior.

That boundary is part of the product philosophy: never invent authority and never invent proof.

What I'm proud of

The most important accomplishment is not the feature count. It is that Willie turns a simple emotional idea—what if the thing we built together could keep travelling?—into a system with real authority boundaries, persistence, replay safety, provenance and a visual experience people can actually follow.

The result is both playful and technically serious.

What's next

After the Twitch commissioning run, the same primitive can support creator relays, charity campaigns, game launches, branded journeys and larger multi-community events.

But the core stays simple:

One live thing. Many communities. One continuing story.

Built With

Share this project:

Updates

Submission history