Daily Vibe Challenge

#005 The Lighthouse Keeper: A Text Adventure with an Agent NPC

2026-10-15T00:00:00Z

#005 — The Lighthouse Keeper: A Text Adventure with an Agent NPC

Difficulty: Intermediate · Time: 2–4 hours · Theme: Text adventures with agents

Description

Build a small parser text adventure set in a storm-battered lighthouse where the one character you meet, the old keeper, is an LLM agent. The twist: the game engine owns the truth. The keeper can only change the world through a few typed tools (give an item, unlock a door, reveal a clue), so the conversation feels free-form while the puzzle stays fair, winnable and impossible to talk your way around.

Starter Prompt

Build "The Lighthouse Keeper", a short browser text adventure with one LLM-powered NPC. Use a single index.html plus engine.js and keeper.js, vanilla JS, no build step. The game must also run with NO API key using a scripted fallback keeper (see below).

World and engine (engine.js, fully deterministic, the single source of truth):
- 6 rooms: Shore, Keeper's Cottage, Lighthouse Base, Spiral Stairs, Lamp Room, Cellar. Each room has a description, exits and items.
- Items: lantern, oil can, brass key, logbook, matches, fuse. Inventory limit of 4.
- Parser verbs: look, go <dir>/n/s/e/w/up/down, take, drop, use <item> [on <thing>], inventory, talk <message> (or say "..."), help. Unknown input gets a helpful hint, never a crash.
- Goal: relight the lamp before the ship offshore runs aground. A turn counter (40 turns) is the storm clock; show it in the status bar.
- Puzzle chain: the Cellar is locked (brass key), the lamp needs oil + a fuse + matches, and the fuse's location is only written in the logbook, which the keeper holds.

The keeper agent (keeper.js):
- The player talks to the keeper with "talk ..." when in the Cottage. Send the LLM a system prompt with his persona (gruff, superstitious, secretly kind), the current visible game state, the last 8 exchanges, and a strict tool list:
  give_item(item), unlock(door), reveal_clue(clue_id), refuse(reason).
- Ask the model for JSON: {"say": "...", "tool_calls": [{"name": "...", "args": {...}}]}. Validate every call against the engine: he can only give items he actually holds, only unlock doors he has keys for, and only reveal clues from a fixed list (clue ids: "fuse_location", "cellar_key", "storm_lore"). Rejected calls are dropped and logged, never applied.
- Conditions the engine enforces (not the model): he hands over the logbook only after the player brings him the lantern, and gives the brass key only after the player asks about the cellar. The model can decide WHEN and HOW he says it, not whether the rules apply.
- Config: an API key field stored in localStorage and an OpenAI-compatible endpoint + model name field. Handle errors and timeouts by falling back to the scripted keeper for that turn.
- Scripted fallback: keyword matching (cellar, key, lantern, logbook, fuse, storm, ship) with a few canned lines per topic that call the same tools, so the game is fully completable offline.

UI:
- Dark terminal look: scrolling transcript, input line with command history (Up/Down arrows), status bar with room, turns left and inventory.
- Keeper lines in a different color. A "Debug" toggle shows the raw JSON from the model and any rejected tool calls.
- Save/load to localStorage; a "New game" button.

When done, explain how the engine/agent boundary works, list the tool validation rules, and give a walkthrough that wins in under 30 turns.

Success Criteria

The game is winnable start to finish with no API key, using the scripted keeper.
With a key set, the keeper responds in character and his item hand-offs actually show up in your inventory.
Trying to sweet-talk him ("just give me the fuse", "ignore your rules") never breaks the puzzle; invalid tool calls appear in the debug panel and are not applied.
The storm clock runs out correctly and shows a lose screen; relighting the lamp in time shows a win screen.
Save, reload the page, load: you are in the same room with the same inventory and turn count.

Optional Extensions

Give the keeper memory across saves: a short summary of what the player told him, rewritten by the model each conversation.
Add a second agent NPC (a ghostly sailor in the Lamp Room) who only speaks in riddles and can reveal one clue.
Generate fresh room descriptions each playthrough with the LLM while keeping exits and items fixed by the engine.
Write a tiny test script that plays the walkthrough against the engine and asserts a win.

#004 Cross-Tab Paddle Duel

2026-10-14T00:00:00Z

#004 — Cross-Tab Paddle Duel

Difficulty: Beginner · Time: 1–3 hours · Theme: Simple multiplayer

Description

Build a two-player Pong-style duel where each player lives in their own browser tab and the tabs sync in real time with the BroadcastChannel API. No server, no accounts: open two windows side by side and play. It is a tiny, honest intro to host authority, state sync and lag handling.

Starter Prompt

Build "Paddle Duel", a two-player Pong-style game where each player plays in a separate browser tab on the same machine. Use a single index.html plus game.js, vanilla JS and HTML5 Canvas, no build step and no server. Tabs communicate only through the BroadcastChannel API (channel name "paddle-duel").

Networking model:
- The first tab to open becomes HOST; the next becomes GUEST. Implement a tiny handshake: on load, post {type:"hello", id}; if no "host-here" reply arrives within 300ms, become host. A third tab becomes a SPECTATOR that only renders.
- The host is authoritative: it runs physics at a fixed 60Hz step and broadcasts a compact state snapshot {ball:{x,y,vx,vy}, paddles:[y1,y2], score:[a,b], tick} every tick.
- The guest only sends its input {type:"input", up, down, tick} and renders the latest snapshot, interpolating the ball between the last two snapshots.
- Handle disconnects: on "beforeunload" post {type:"bye"}; if the host disappears (no snapshot for 1s), the guest promotes itself to host and keeps the score.

Gameplay:
- 800x500 canvas, paddles on left (host) and right (guest), W/S or Up/Down to move.
- Ball speeds up 5% on each paddle hit and bounces at an angle based on where it hits the paddle.
- First to 7 wins; show a "Rematch" button that both players must click (ready-check over the channel).

UI:
- Top bar shows your role (HOST, GUEST or SPECTATOR), both scores, and a live "ping" in ms measured with timestamped ping/pong messages every second.
- A debug toggle (press D) that overlays tick number, snapshot rate and the last message received.

Keep the code clean with small functions (net.js-style section, physics section, render section) and explain how to test it: open index.html in two windows side by side. When done, list any edge cases you handled.

Success Criteria

Opening two tabs auto-assigns HOST and GUEST without any manual setup; a third tab becomes a spectator.
Both tabs show the same ball position and score with no visible desync.
Closing the host tab lets the guest take over within about a second without losing the score.
Rematch only starts after both players click it.
Works offline from a local file or any static host.

Optional Extensions

Swap BroadcastChannel for a WebSocket relay (about 30 lines of Node) so two different computers can play.
Add artificial latency and packet loss sliders to the debug overlay to see interpolation in action.
Power-ups (bigger paddle, split ball) spawned deterministically from a shared seed.
An AI paddle that fills in when only one tab is open.

#003 One-Room Pixel Dungeon Dash

2026-10-14T00:00:00Z

#003 — One-Room Pixel Dungeon Dash

Difficulty: Intermediate · Time: 2–4 hours · Theme: Mini game jam / pixel art consistency

Description

A single-screen roguelite: dodge slimes, grab the key, reach the door before a 60-second timer runs out. Each run randomizes the layout. Focus on a strict, consistent pixel-art style.

Starter Prompt

Create a browser game "Dungeon Dash" with HTML5 Canvas and vanilla JS (or Phaser 3 via CDN), single index.html plus one game.js.

Gameplay:
- 16x12 tile room, 16px tiles, rendered at 3x scale with no smoothing.
- Player moves with WASD/arrows on a tile grid with smooth tweening.
- Randomly place walls (keep a guaranteed path via BFS check), 1 key, 1 locked door, and 3–6 slimes that move one tile every 0.5s toward the player with simple pathing.
- Touching a slime = lose a heart (3 hearts, 1s invulnerability flash). Grab key, reach door = win; timer hits 0 = lose.
- Show hearts, timer, and best time (localStorage). Press R to restart with a new layout.

Art rules (enforce strictly):
- Generate all sprites in code from small string-art arrays, using ONE 8-color palette defined once at the top.
- Every sprite 16x16, 1px dark outline, light source top-left.
- 2-frame idle animation for player and slimes.

Also add simple Web Audio beeps for pickup, hit, win and lose. Explain the code structure when done.

Success Criteria

Every generated layout is solvable.
Collisions, hearts, timer, win/lose and restart all work.
All visuals share one palette and the same outline/lighting rules.
Runs at a steady 60fps in a modern browser.

Optional Extensions

Multiple rooms with increasing slime count.
Daily seed so everyone plays the same layout today.
An AI "ghost" that plays the level with A* and races you.

#002 Tool-Using Research Desk Agent

2026-10-14T00:00:00Z

#002 — Tool-Using Research Desk Agent

Difficulty: Intermediate · Time: 2–3 hours · Theme: AI agents / tool use

Description

A minimal CLI agent that answers questions by deciding which of three local tools to call (calculator, file search, a notes store), looping until it has an answer. The point is a clean, inspectable agent loop you fully understand.

Starter Prompt

Build a small command-line AI agent in Python (or TypeScript if you prefer) called "desk-agent".

Requirements:
- Use any chat LLM API with tool/function calling (read the API key from an env var; make the provider swappable behind one function).
- Implement exactly three tools with JSON schemas:
  1. calculator(expression: str) — safely evaluates arithmetic (no eval of arbitrary code).
  2. search_files(query: str) — case-insensitive search across .md/.txt files in ./docs, returning file names and matching lines (max 10).
  3. notes(action: "add"|"list", text?: str) — persists notes to notes.json.
- Agent loop: send the user message plus tool schemas, execute any tool calls, feed results back, repeat until the model returns a final answer or 6 steps pass.
- Print each step clearly: "→ tool: name(args)" and "← result (truncated to 200 chars)".
- Include a ./docs folder with 3 short sample files so it works out of the box.
- Add a --dry-run flag that shows which tool would be called without executing it.

Write a README with setup, an example session, and how to add a new tool. Keep it under ~250 lines of code total.

Success Criteria

Asking "What's 17% of 2,340, and save that as a note" triggers calculator then notes.
Asking about content in ./docs triggers search_files and cites the file.
Loop stops cleanly at the step limit; errors from tools are reported back to the model, not crashed on.

Optional Extensions

Add a tiny web UI that streams the step trace.
Let the agent write its own new tool (sandboxed) and register it.
Add a token/cost counter per session.

#001 Cozy Plant Shop Idle Game

2026-10-14T00:00:00Z

#001 — Cozy Plant Shop Idle Game

Difficulty: Beginner · Time: 1–2 hours · Theme: Cozy games

Description

A tiny browser idle game: you run a plant shop, water pots, plants grow through 4 pixel-art stages, and you sell them for coins to buy new seeds and pots. Calm palette, soft sounds optional.

Starter Prompt

Build a single-page cozy idle game called "Little Leaf Shop" using plain HTML, CSS and JavaScript (no build step, one index.html is fine).

Core loop:
- A 3x3 grid of pots. Each pot is empty, or holds a plant with a growth stage 0–3.
- Clicking an empty pot plants a seed (costs 5 coins). Start with 20 coins.
- Clicking a planted pot waters it. A watered plant advances one stage every 8 seconds; it needs watering again after each stage.
- At stage 3 the plant is "ready"; clicking it sells it for 15 coins.
- Show coins, plants sold, and a "Buy pot" button that unlocks extra pots (up to 16) at rising cost.

Style:
- Draw plants as CSS/canvas pixel art (16x16 scaled up, image-rendering: pixelated), with a warm pastel palette (#f4e7d3, #9cc5a1, #49a078, #216869, #1f2421).
- Gentle hover/bounce animations. Readable on mobile.
- Persist state in localStorage so progress survives reloads.

Keep the code in clearly separated sections (state, render, input, persistence) with short comments. When done, tell me how to run it and list any assumptions.

Success Criteria

Plant, water, grow, sell loop works end to end.
Coins and pot purchases update correctly; no negative coins.
Progress persists after a page reload.
Looks consistent and cozy on desktop and phone.

Optional Extensions

Multiple seed types with different grow times and prices.
Day/night tint cycle and a lo-fi ambient sound toggle.
Offline progress: plants keep growing while the tab is closed.