Skip to content

Instantly share code, notes, and snippets.

@dmahlow

dmahlow/runbook.md

Created June 14, 2026 08:46
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save dmahlow/96cda079c2f80ada69c4c17c41486f31 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save dmahlow/96cda079c2f80ada69c4c17c41486f31 to your computer and use it in GitHub Desktop.
Download ZIP
GCEU Workshop Runbook - Beat by Beat
Raw
runbook.md

Workshop Runbook - Beat by Beat

Every 20-minute block of the day, what you do, what you say, what can go wrong.

Block 1: 9:00-9:20 - Intro + Setup

  1. Title + about me (2 min) - Managing Partner at Contiamo, GenAI from prototype to production since 2020. Builder, generalist. Keep it warm but brief - they're here to build, not to listen.

  2. What's a claw (2 min) - Always-on, autonomous, persistent memory, self-scheduling, acts on your behalf. "NOT a coding agent. Something different." Five bullet points, fragment reveal.

  3. The ecosystem (1 min) - OpenClaw 247K stars, NanoClaw (lightweight, $12M raise), GoClaw (Go reimplementation, multi-tenant). "The architecture is validated. Microsoft Scout ships on OpenClaw. The patterns are what matter - that's what we're building today." This is where you set the tone: we're past the hype, we're building for real.

  4. Why Go (1 min) - The terminal-window slide. Goroutines for parallel tool execution, channels for streaming, types for tool schemas, single binary deployment. "scp myclaw user@server:/usr/local/bin/ - Done. That's it. No runtime."

  5. What you'll learn + three acts + methodology (3 min) - "The claw is the vehicle. Go patterns are what you take home." Three acts: Agent Core -> Claw -> A2A + Game. Skills, checkpoints, review gates. The rhythm: skill -> implement -> review -> validate. Say this explicitly: "Checkpoints are a feature, not a safety net. If you're not at a checkpoint when I say, copy it. That's what they're for. No shame."

  6. LiteLLM proxy (2 min) - One endpoint, same model, no debugging. Show the 3 env vars on screen. "Your coding agent uses your own API key. The claws all point here."

  7. Maze heist teaser (30 sec) - The grid visual. "Your claws will collaborate to solve a maze together." Pause. "Leave that for later."

  8. Setup check (5 min) - The terminal slide with 3 commands. Walk the room. This is your first chance to spot trouble: wrong Go version, proxy unreachable, no coding agent. Fix as many as you can now. Every problem you catch here saves 10 minutes later.

  9. "Let's go." (transition)

What can go wrong: Proxy is unreachable (have the URL and health endpoint ready to paste in chat). Someone doesn't have Go installed (point to checkpoints - they can still follow along). Someone has no coding agent (pair them with a neighbor who does).

Block 2: 9:20-9:40 - Demo 1 Step 1: Agent Loop + Tools (first half)

  1. Demo 1 title slide + ReAct loop (3 min) - "Every agent does this. Claude Code, Codex, OpenClaw. All of them." Draw the cycle: Reason -> Act -> Observe -> Reason. "Same loop as a REPL."

  2. Architecture slide + Tool interface slide (3 min) - Show what they're about to build: agent loop, LLM API, tool system, streaming, 4 tools. Then the Tool interface code. "Same pattern as http.Handler - different context."

  3. Tell them to start (1 min) - "Open skills/demo_1/step_1_agent_loop.md. Feed your agent everything up to the first Stop Here - that's project setup and the first LLM call. Stop when it says stop."

  4. While agents work: show "The Planning Phase" interstitial (5 min) - Good prompt vs bad prompt. "Context first, instructions second." Walk the room. The most common problem right now: openai-go SDK types. The skill has the reference code but some agents will ignore it. If someone's stuck on message types, point them to the SDK reference section at the top of the skill.

  5. When ~80% are done (1 min) - "Everyone at the first stop? Good. Now continue to Step 2 - define the Tool interface and the first two tools. Same file, next section."

  6. While agents work: show "Why Interfaces" interstitial (5 min) - "The LLM doesn't know Go. It sees JSON schema and returns JSON. The interface bridges the gap." Walk the room again. Common issue: Schema() returning invalid JSON. Remind them the acceptance criteria say go build ./... must pass.

What can go wrong: The combined step 1 is the densest step. Some agents will produce code that doesn't compile because of the openai-go union types. The SDK reference at the top of the skill file is there for this reason. If someone is deeply stuck, point them to checkpoint_1_agent_loop (just the loop) or checkpoint_2_tools (loop + tools).

Block 3: 9:40-10:00 - Demo 1 Step 1 (second half) + Step 2 Start

  1. When tools are done, tell them to continue to Step 3 (1 min) - "Now wire the tools into the agent loop. This is where it becomes an agent - the LLM decides when to use tools."

  2. While agents work: show "Tool dispatch flow" slide (3 min) - Go struct -> JSON Schema -> LLM -> Tool Call JSON -> Execute -> Feed back. Walk through it. Mention the LiteLLM gotcha: "The proxy returns finish_reason 'stop' even with tool calls. Check by presence, not by finish reason. This is in your skill file."

  3. When wiring is done, first magic moment (2 min) - "Ask your agent: 'what files are in the current directory?' It should use list_directory. Then: 'read the go.mod file.' Then: 'what's 2+2?' That last one should NOT trigger a tool." Walk the room, watch faces. This is the first "it works" moment.

  4. Mandatory QA gate (5 min) - "Before we move to streaming, run these two prompts." Show them on screen: generate a mermaid diagram of the architecture, explain the tool dispatch flow. "Read the output. Does it match what you think the code does? This is not optional."

  5. Transition to Step 2: Streaming (1 min) - "Open step_2_streaming.md. Responses appear token by token instead of all at once." Show the streaming slide: without vs with. "This is where Go's concurrency model shines."

  6. While agents work: show "Why Goroutine + Channel" interstitial (5 min) - "Producer reads SSE, channel delivers to consumer. This pattern recurs everywhere - WebSocket in Demo 2, A2A in Demo 3." The streaming skill has the accumulator pattern code.

What can go wrong: The LiteLLM .ToParam() gotcha hits here during streaming with tool calls. The skill warns about it and shows the manual construction pattern. If someone's agent ignores the warning, they'll get garbled tool calls. Point them to the code block in the skill.

Block 4: 10:00-10:20 - Demo 1 Step 3 + Recap

  1. When streaming works, transition to Step 3: More Tools (1 min) - "Open step_3_more_tools.md. Add write_file with path traversal protection, run_command with a timeout. Your agent can now change things, not just observe."

  2. While agents work: show security moment slide (3 min) - "run_command is powerful and dangerous. In this workshop: trust. In production: sandbox everything." Show the NanoClaw comparison. "We'll go deep on security in Demo 2."

  3. "When to intervene" interstitial (3 min) - Let it run: making progress, asking questions, running tests. Step in: circular edits, growing complexity, ignoring errors. "Your agent is a junior engineer with perfect memory and no judgment."

  4. When tools are done, full test (3 min) - "Test all four together: list files, read main.go, create a file, run cat to verify." Walk the room.

  5. Demo 1 architecture recap (5 min) - Show the "What you built" slide: main.go -> agent/ -> tools/ -> 4 tools. Then "The code that matters" slide: the agentTurn inner loop. "This is the engine. Everything else is wiring."

  6. Harness connection moment (3 min) - "Same patterns everywhere" slide. Your Tool interface next to zot's, next to Claude Code's. "You just built the same core that powers every coding agent. Pro tip: sort tool specs alphabetically for prompt cache hit rates." Then: "who picked a 100KB size limit for read_file? Who did something different? Why?" Quick show of hands.

  7. Checkpoint catch-up slide (1 min) - "Not at checkpoint 4? Copy it now. We're moving to Demo 2."

What can go wrong: write_file path traversal - some agents won't implement the check unless explicitly told. The acceptance criteria require it. If time is tight, skip the "when to intervene" interstitial.

Block 5: 10:20-10:40 - Demo 1 Wrap + Coffee Transition

This block is buffer. If Demo 1 ran long (likely), this is where it finishes. If it ran on time, this is an extended coffee break.

  1. If Demo 1 is still running: finish the recap and harness connection moment from Block 4. Don't rush the "same patterns everywhere" slide - it's the conceptual payoff of the entire first act.

  2. If Demo 1 is done: early coffee. Tell people: "Coffee break. Be back at 11:00 sharp. If you want to run the validation skill or QA skill during the break, go for it."

Coffee break: 10:40-11:00 (20 min)

Block 6: 11:00-11:20 - Demo 2 Intro + Step 1: Memory

  1. Demo 2 title slide (1 min) - "From Agent to Claw."

  2. The triptych (3 min) - The three-column slide: Agent / Harness / Claw. "Same foundation, different direction." Agent = what you built in Demo 1. Harness = add intercept hooks, skill loading, extensions (Claude Code, zot, Cursor). Claw = add memory, scheduling, always-on (OpenClaw, NanoClaw, Microsoft Scout). "We're going right."

  3. Three features that cross the line (1 min) - Memory, Scheduling, Web UI. "These are what turn an agent into a claw."

  4. Tell them to start Step 1: Memory (1 min) - "Open skills/demo_2/step_1_memory.md. Feed your agent up to the first Stop Here."

  5. While agents work: "System prompt engineering" interstitial (5 min) - What goes in (identity, capabilities, instructions, recent memories) vs what doesn't (full history, all memories, implementation details, API keys). "Every token in the system prompt is sent with every request. Be surgical."

  6. "Why markdown on disk" interstitial (3 min) - Human-readable (cat it), git-friendly (diff it), LLM-native (no serialization). "OpenClaw uses the same pattern. Sometimes the simplest storage is the right one."

  7. When Step 1 substeps are done (3 min) - "Test: tell your agent 'My name is [your name], remember that.' Exit. Restart. Ask 'what's my name?' It should use recall without you telling it to."

What can go wrong: Memory directory permissions. Frontmatter parsing edge cases. The intentional omission (token budget - they choose the limit) means some agents will inject all memories and blow the context window. That's a learning moment, not a bug.

Block 7: 11:20-11:40 - Demo 2 Step 2: Scheduling + The Big Refactor

This is the most important 20 minutes of the workshop.

  1. Transition to Step 2: Scheduling (2 min) - "This is the moment the agent becomes proactive. It's no longer just reactive." Show the select pattern slide. "This is a natural Go pattern - the language was designed for exactly this kind of multiplexing."

  2. Tell them to start (1 min) - "Open step_2_scheduling.md. Feed everything up to the first Stop Here - that's the scheduler package."

  3. While agents work: "The Architecture Moment" interstitial (5 min) - Show the 4-source channel diagram: CLI, Scheduler, WebSocket, A2A all feeding one chan Message. "This is the slide." Show the before/after comparison. "ReplyTo decouples where the question came from from how you answer it."

  4. When scheduler package is done, continue to Step 2 (schedule tool) (1 min) - "Now add the schedule tool and wire the callback into the message channel."

  5. When tool is done, continue to Step 3 (the big refactor) (1 min) - "This is the most important step. Refactor from blocking stdin to channel-based multiplexing. Your agent tells the coding agent what to do."

  6. While the refactor runs: walk the room actively (8 min) - This is where coding agents fail most often. The refactor touches main.go and agent.go significantly. Watch for: agents that delete the tool dispatch logic during the refactor, agents that create a new channel but don't wire the scheduler into it, agents that break the streaming. If someone's agent is struggling, suggest: "Tell your agent to look at the Message struct definition, then refactor one source at a time - stdin first, then scheduler."

  7. "If you're stuck, checkpoint 6 is your friend" (1 min) - Say this proactively, don't wait for someone to ask. "The refactor is hard. If your agent can't get it, copy checkpoint_6_scheduling and move on. You'll understand it better after the QA gate."

What can go wrong: This is the highest-risk block. The refactor can break everything if the agent gets confused about the channel wiring. The most common failure: the agent creates the channel but still reads from stdin in the main loop, so scheduled tasks never fire. Checkpoint 6 is the safety net. Use it aggressively.

Block 8: 11:40-12:00 - Demo 2 Step 2 QA + Step 3: Web UI

  1. Mandatory QA gate (5 min) - "Before we continue, run these two prompts." The mermaid diagram of all goroutines and channels. The explanation of how a scheduler message reaches the agent. "If this diagram makes sense, everything else will too. If it doesn't, ask me."

  2. Transition to Step 3: Web UI (2 min) - Show the embed.FS slide. "Your entire claw ships as one binary. No Docker. Just scp." Show the single-binary deployment terminal.

  3. Tell them to start (1 min) - "Open step_3_web_ui.md. This adds HTTP server, WebSocket streaming, and a chat UI. Plus system prompt extraction, config, and slog at the end."

  4. While agents work: "embed.FS and single-binary deployment" (3 min) - "//go:embed bakes the HTML into the binary at compile time. One file to deploy." Show the code.

  5. Walk the room (5 min) - Web UI is usually smoother than the refactor because the channel architecture is already in place. The WebSocket is just another source feeding the same channel. Common issue: WebSocket library choice (gorilla vs nhooyr). Either works. If they have the channel refactor working, this step goes fast.

  6. When web UI + config are done (2 min) - "Open http://localhost:8080. Chat with your claw through the browser. Does it feel different than the terminal? Try opening two tabs."

What can go wrong: WebSocket library version conflicts. Port 8080 already in use. The config/slog sub-step at the end of step 3 is quick but some agents will skip the API key redaction. The validation checks catch this.

Block 9: 12:00-12:20 - Demo 2 Step 4 (Discussion) + Wrap

This block is the security + harness discussion, then lunch. No coding.

  1. Demo 2 architecture recap (3 min) - "The full claw" slide: main.go -> agent/ -> web/ -> tools (8) -> memory/ -> scheduler/. "Five goroutines, one binary." Show the goroutine map: main loop, scheduler tick, HTTP server, WebSocket clients, CLI reader.

  2. Step 4: Security + Harness Discussion (10 min) - No coding. Slides + talk.

    • The phantom token pattern (4 min) - "Your claw has run_command and write_file. In production, the agent should never see API keys. The phantom token pattern: agent gets a useless session token, a proxy swaps in the real key at the network boundary. nono does this with Go bindings."
    • OpenClaw crisis (2 min) - "48,000 exposed nodes. 230 malicious scripts on ClawHub in one week. 35% susceptibility to RCE. This is what happens without sandboxing." Let the numbers land.
    • The triptych callback (3 min) - "Remember the three columns? The harness adds intercept hooks: before-tool, before-turn, before-message. Where in YOUR codebase would you add a before-tool hook that blocks rm -rf?" Pause. Let them think. "Some maze doors will test you on exactly this."

  3. Checkpoint catch-up slide (1 min) - "Not at checkpoint 8? Copy it. We're going to lunch, and after lunch we add A2A."

  4. Lunch logistics (1 min) - "Be back at 13:15. If you ran the QA gate, read the output during lunch. If you haven't run the validation skill yet, do it now - it takes 30 seconds."

Lunch: 12:15-13:15 (60 min, or 55 if Demo 2 ran 10 min over)

What can go wrong: Nothing - this is discussion. The risk is going over time. Keep the security talk to 10 minutes. The triptych callback question is the hook for Demo 3.

Block 10: 13:15-13:35 - Demo 3 Step 1: A2A Server

Post-lunch energy is always low. Start with something concrete.

  1. Demo 3 title slide (1 min) - "A2A + The Maze Heist. Your claws talk to each other. Then they play a game."

  2. MCP vs A2A slide (2 min) - "MCP is agent-to-tool (vertical). A2A is agent-to-agent (horizontal). Complementary, not competing. Your claw uses both."

  3. Agent Cards slide (2 min) - "DNS + API docs in one JSON file." Show the JSON. "HTTP GET to a well-known path. That's discovery."

  4. "A2A is just HTTP" slide (1 min) - "JSON-RPC 2.0 over POST. Your claw is already an HTTP server. Adding A2A is adding two routes."

  5. Tell them to start (1 min) - "Open step_1_a2a_server.md. We're implementing A2A manually - no SDK. You'll see the raw JSON-RPC, the message format, the task lifecycle. It's just HTTP."

  6. While agents work: "Same channel, new source" slide (3 min) - "The Demo 2 refactor pays off. The A2A server is just another input source feeding the same Message channel. No changes to the agent loop."

  7. "Agent Cards as capability advertising" interstitial (3 min) - "What can you do? Answered by a JSON file. No central registry. No DNS. Just a well-known URL."

  8. Walk the room (5 min) - A2A server is usually straightforward. The types are simple (AgentCard, JSONRPCRequest/Response, Message, Part). The server handler is similar to what they've already built for the web UI.

What can go wrong: The A2A types and JSON-RPC format are new but not complex. Some agents will try to import the a2aproject/a2a-go SDK even though the skill says manual. If they do, it's fine - it works. The manual approach is more educational but not required.

Block 11: 13:35-13:55 - Demo 3 Step 2: A2A Client

  1. When server is done, transition to Step 2: A2A Client (1 min) - "Now your claw can receive messages. Let's make it send them."

  2. Tell them to start (1 min) - "Open step_2_a2a_client.md. Discover peers, ask them questions, broadcast to all."

  3. While agents work: show broadcast fan-out/fan-in slide (3 min) - "Goroutine per peer. Channel collects. Timeout protects. Textbook Go."

  4. Walk the room (5 min) - The client tools (discover_peer, ask_peer, broadcast, find_peer_with_skill) are each 30-50 lines. The peer registry uses sync.RWMutex. Mention: "RWMutex because lookups during broadcast are read-heavy."

  5. Network note about the relay (2 min) - Show the relay slide. "Conference WiFi is unpredictable. Your claw polls its inbox on the game server. Outbound-only HTTP. Works through any firewall." Explain: "When you join the game, peers come with a relay_url. Your ask_peer and broadcast tools work unchanged - they just target the relay URL instead of a direct peer URL."

  6. Live demo moment (5 min) - Start two claw instances on different ports. Have one discover the other. Ask it a question. "Two AI agents collaborating over HTTP." Show both web UIs side by side if possible. This is a powerful moment - let it breathe.

What can go wrong: If you're running the live demo on stage, make sure both claws use different memory dirs and task files (the skill covers this). Port conflicts: use 8181 and 8182, not 8080.

Block 12: 13:55-14:15 - Demo 3 Step 3: Connectivity Test

  1. Transition to connectivity test (1 min) - "Open step_3_connectivity.md. Three checks: local loopback, reach the game server, join and verify the inbox."

  2. Step 1: Local A2A loopback (5 min) - They already did this if they watched the live demo. "Start a second instance on a different port. Discover it. Ask it something. Verify the response flows through."

  3. Step 2: Reach the game server (3 min) - Give them the game server URL. "curl it. Discover it as a peer." Watch the big screen - the game server should show discovered agents. If curl fails, you have a network problem - flag it immediately.

  4. Step 3: Join and verify the inbox (5 min) - "Tell your claw to join the game. Watch the big screen for your dot." This is the first time the visualization is live with real participants. Energy goes up. "Broadcast a hello to all peers. See who replies."

  5. Debugging time (5 min) - Walk the room. The main issues: claw not running (copy checkpoint 10), game server unreachable (network problem - try the travel router), inbox poller not starting (rejoin). With the polling model, most issues are "I can't reach the game server" which is a single-point test.

What can go wrong: The game server itself is unreachable from the venue WiFi. Fallback: run it on the same network as the travel router. If all else fails, the game server runs on localhost and participants connect their claws to it via the same machine. The polling model makes this much simpler than peer-to-peer would have been.

Block 13: 14:15-14:40 - Connectivity Debugging + Buffer

This block is buffer for connectivity issues. If everything works, it's extra game time.

  1. If connectivity is working (people's dots are on screen): "Great. Let's take a coffee break and come back for the game." Move the break up.

  2. If connectivity is struggling: keep debugging. The most common issues:

    • Game server URL wrong (typo, http vs https)
    • Claw didn't build clean (CGO_ENABLED=0 go build)
    • Inbox poller didn't start (claw needs to successfully join first)
    • Pair struggling participants with working ones

  3. "Copy checkpoint 10" announcement (2 min) - "If your claw isn't running or isn't connected, grab checkpoint 10 right now. Build it. Set your env vars. Join the game. Everyone plays."

Coffee break: ~14:40-15:00 (15-20 min)

Block 14: 15:00-15:20 - Game Setup + First 10 Minutes

  1. Pre-game slides (5 min) - Show the visualization on the big screen. Explain the rules:

    • 5 roles (lockpick, hacker, demolitions, analyst, scout), ~10 per role
    • Locked doors need 3+ agents of the right role
    • Some doors need your help: Go coding challenges. "Solve them any way you like - by hand, Go Playground, or ask your coding agent."
    • Share maps via A2A. Coordinate. Find the jewel.
    • The game runs itself. You commentate.

  2. Game-ready catch-up slide (1 min) - "Claw not running? Checkpoint 10. Build. Run. The game doesn't care who built what."

  3. "Let's play." (transition)

  4. First 10 minutes of the game - Watch the big screen. The auto-camera follows interesting events. Call out what you see:

    • "c-3 just started exploring south!"
    • "Oh, c-7 found a lockpick door! Who else is a lockpick?"
    • "Look at the auto-broadcast: 'Door door-2 needs 1 more hacker!' Who's nearby?"
    • Build energy. This is raid leader mode.

What can go wrong: Fewer than 20 claws connected. If so: reduce maze size via GAME_MAZE_SIZE=20, or accept it and commentate harder. The auto-difficulty scaling will reduce door requirements after 10 minutes if progress is slow.

Block 15: 15:20-15:40 - Mid-Game

  1. Watch for door openings - The first door opening is a big moment. Call it out. "Door-2 just opened! Three lockpicks coordinated via A2A!"

  2. Watch for human challenges - When a claw hits a deep door, the participant sees the challenge in their web UI. Walk over. "You've got a coding challenge! Write the function, get the key, paste it back." The room should feel like a hackathon now.

  3. Watch the auto-broadcasts - The game server broadcasts coordination hints automatically. "Door-5 at (18,12) needs 1 more demolitions! 2/3 present." You can add color: "c-14, you're a demolitions expert and you're only 5 cells away!"

  4. If time and things are going well: harness challenge doors - Hit the "Trigger Harness Challenge" button on the GM panel. Broadcast: "c-8, c-12 - the door ahead needs a before-tool guard. Block any run_command containing 'rm'. Rebuild your claw and prove it." This is optional. Only if the game has momentum.

  5. Watch the convergence lock - If someone discovers the jewel, the big screen shows "CONVERGE! LOCK 3/8" with a pulsing ring. This is the crescendo building. Call it out: "THE JEWEL HAS BEEN FOUND! Everyone converge! We need 8 explorers within 3 cells!"

What can go wrong: Claws walking in circles (haiku model not following the strategy well). The auto-difficulty scaling helps. If claws are genuinely stuck, use the GM broadcast: "All explorers: head east. There's a cluster of doors around (20,15)." The 35-minute auto-converge is your safety net.

Block 16: 15:40-16:05 - Endgame + Wrap-up

  1. The convergence (whenever it happens) - Watch the charge meter fill. "5/8... 7/8... ONE MORE!" Call out who's arriving. If the auto-converge timer fires at 35 min, the jewel coordinates are revealed and the requirement drops, so it will happen.

  2. The reveal (2 min) - Full maze reveal. All paths traced. Every dot visible. "Look at that. 50 agents, one maze, and you built every single one of them today." Pause. Let it land. Screenshot this.

  3. Wrap-up slides (8 min) - Don't rush this.

    • "What you built today" - Three columns: Agent Patterns (tool interface, loop, streaming, context), Claw Features (memory, scheduling, web UI, channel multiplexing), Networking (A2A, peer discovery, fan-out/fan-in, collaborative game). "These patterns power Claude Code, zot, OpenClaw, and your claw."
    • "The real takeaway" - How to direct coding agents effectively. Go concurrency patterns for agent architectures. Patterns that transfer to any LLM integration.
    • "What's next" - Keep building your claw. Add messaging (Slack, Telegram). Deploy it. Extend with MCP. Build agents for your team.
    • Resources - OpenClaw, A2A spec, openai-go, nono, zot, workshop repo.

  4. "Thank you." - Daniel Mahlow, Contiamo, Berlin. GitHub. Let people come talk to you.

What can go wrong: The jewel isn't found and auto-reveal fires at 45 min. That's fine - the reveal still happens, the paths are still traced. It's slightly less dramatic but still a good ending. The worst case (game completely broken, nobody connected) shouldn't happen with the polling model and checkpoint 10 binaries, but if it does, the wrap-up slides stand on their own.

Emergency plays

Demo 1 runs 30 min over: Cut the "when to intervene" interstitial and the show-of-hands discussion. Go straight from architecture recap to checkpoint catch-up. Demo 2 starts at 11:20 instead of 11:00.

Demo 2 runs 20 min over: The QA gate becomes "run it during lunch." The security discussion shrinks to 5 min (phantom token pattern only, skip the OpenClaw numbers). Lunch is 50 min instead of 60.

Connectivity test eats all the buffer: Skip the coffee break. Start the game at 15:00 with whoever is connected. Announce checkpoint 10 loudly.

Fewer than 15 claws at game time: GAME_MAZE_SIZE=15, GAME_JEWEL_REQUIRED=3. Smaller maze, faster game. The auto-difficulty scaling compensates for the rest.

Proxy goes down: Participants' claws stop working. The build steps still work (code compiles without the proxy). Tell them to continue building and testing with go build ./... and go vet ./.... The proxy usually recovers in minutes.

Your laptop dies: The game server is on your laptop. If it dies mid-game, the game is over. Mitigation: run the game server on the VPS next to the LiteLLM proxy. Or have a second laptop ready.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment