Vibe Coding Nights #49 — The Swarm, a Wednesday-evening build sprint at Frontier Tower's 10th Floor Annex, hosted by Rayyan Zahid, Michalis Vasileiadis, Eric Mockler and Devinder Sodhi. One agent is a queue: five independent tasks against one agent means four of them wait on nothing. The fix is not a faster agent, it is N agents, and the deck's organising claim is that the unit of parallelism is a git worktree — many branches in many trees rather than many branches taking turns in one. The room's first instinct, ten agents pointed at the same checkout, is killed on slide 3 before the lab can waste an hour on it: same files, same index, same HEAD, same lockfile, and it half-works, which is what makes it dangerous, because the failure arrives as erased work rather than as an error. The conductor pattern names the three moves — SPLIT, DISPATCH, MERGE — and is honest that only the first is a judgement call. The section that earns the session is slide 6, added after the lab was run end to end on a scratch repo the morning of delivery: a worktree is not a sandbox. What IS isolated is the working tree, the index, HEAD and the branch. What is NOT is .git/config, refs, hooks and the object store — so three agents that each set their identity the obvious way (git config user.email) race on the shared .git/config, two print a non-fatal lock error, all three commit anyway, and every commit comes out authored by the race winner. The messages stay correct, so the log looks fine at a glance and is wrong in the one field you would audit. The lab therefore hands out env-scoped GIT_AUTHOR_* / GIT_COMMITTER_* per process instead, which is correct per-agent authorship with zero lock contention. A second silent failure came out of the same dry run and is on its own slide: git worktree remove --force follows an NTFS junction out of the worktree, deletes the target's contents, and exits 0 with nothing printed — reproduced deliberately after that exact sequence cost a real .venv in the maestro fleet at 13:44 the same day. Linking a shared venv into each tree is precisely what makes N trees cheap, so the pattern and the hazard arrive together; unlink the reparse point first, then remove. Fan-out is parallel and fan-in is serial, deliberately: merge one tree at a time, and resolve conflicts by intent rather than by line. The closing slide is the counterweight — when NOT to fan out, since work that shares a file is not independent work and the split is the hard gate, not the commands. 18 slides, a five-step hands-on hour that stands up three trees and drives three agents through them, a measured three-agent replay with real git worktree list and git log --graph output, agent-readable /setup.txt and .well-known/ai-agent.json + agent-card.json, and an on-slide changelog recording the three edits the dry run forced, so the room sees the method rather than only the result.
Vibe Coding Nights #48 — Total Recall, a Saturday-morning build sprint in the Off the Leash season. A coding agent that forgets your repo every session is one you have to supervise, and the fix is not a bigger context window: loading the whole repo every turn is slow, billed, and makes accuracy worse by burying the relevant two hundred lines in two hundred thousand. The deck's organising idea is that memory is four different things separated by how the agent fetches them — always-on (nothing fetches it, it is just there), retrieval (similarity to the question), graph (following edges), and working (recency) — and every later slide, including all five lab steps, hangs off those four names. Two sections go beyond retrieval. The first is where vector search stops working, presented as three queries a builder can test against their own repo in ten seconds: what breaks if I change this signature (callers do not textually resemble the callee, so similarity returns exactly the wrong set), which of these two config patterns is current (a vector has no notion of time, so a superseded pattern retrieves as confidently as the live one), and who owns the service that writes this table (three hops, no single chunk contains all three). The honest conclusion on that slide is do not start here: build the vector index first, use it for a week, write down the questions it answered badly, and only add edges if they look like those three. The second is a landscape of what actually exists — plain files, Chroma, pgvector, Pinecone, Mem0, Zep/Graphiti, Cognee, Letta — sorted not by quality but by which of the four rows each one covers, with the stated default that files plus a local vector store covers most of what most teams need. A three-slide case study grounds all of it in a real repo in daily use, with every number measured the morning of delivery rather than asserted: a 75,767-byte always-on instruction file re-read before the operator types anything, 313 hand-written memory notes carrying 535 cross-links across 245 unique targets (a context graph nobody set out to design), a 4,493-person derived graph that must never be hand-edited, and a 478-verb capability index built by parsing the source rather than embedding it — the counter-example to the night's own lab, since not all recall is vector recall. The case study is deliberately unflattering: it reports that the always-on file advertises 425 verbs while the generated index has 478, a drift found while building this deck, in the repo the deck presents, and uses it to make the point that memory fails quietly in a way a slow agent does not. The hands-on hour builds the stack on a repo the attendee actually works in: chunk on real function boundaries using Python's built-in ast (chosen over tree-sitter specifically because it needs no build toolchain and cannot strand anyone mid-sprint, with tree-sitter named on-slide as the polyglot upgrade), embed into a persistent local store with path:line ids so re-indexing is idempotent, expose retrieval as a command the agent runs and cite paths and line numbers back, then persist a startup notes file and extract a who-calls-this edge map in nine lines of the same parse — a context graph with one edge type, built by hand, so the landscape slide stops being abstract. 20 slides, per-step checkpoints so nobody is silently stuck until demos, an agent-readable /setup.txt, and a gotchas slide where four of the five entries are about knowing when the memory is wrong rather than making it better.
Vibe Coding Nights #47 — Fast Local, a Wednesday-evening build sprint in the Off the Leash season. #41 Bare Metal got a coding agent running on local open weights with no API bill, and then it crawled; an agent that takes forty seconds to think is an agent you stop using. This session makes the local rig quick enough to live on. Slow is three separate problems, not one, so the deck separates prefill from decode and measures each. Five knobs in a fixed order, and the order is the argument: get every layer resident on the card first, then shrink, then serve properly, then tune one knob at a time and re-time after each. The method is measure, change exactly one thing, measure again. Rehearsed on real hardware before delivery rather than asserted: on an RTX 2080 Ti with llama.cpp b10289 and Qwen2.5-Coder-3B, quantizing Q8_0 to Q4_K_M is worth 1.40x (126.55 to 176.85 decode tok/s) while simply getting the model onto the card is worth 11.9x (14.83 to 176.85), which inverts the usual claim that quantization is the big lever. Quantization is not how you go fast, it is how you afford to go fast, by making the model fit. The convert-and-quantize chain on slide 9 was executed end to end and cross-checked on a second machine to the same number. 17 slides, a hosted-model speed bar timed live in the room to score against, agent-readable /setup.txt, and a five-stage hands-on hour. Provenance is marked throughout: the llama.cpp figures are measured on the named card, and the vLLM commands are documentation-derived and carry a check-your-own-help warning.
Vibe Coding Nights #45 — Bench, a Wednesday-evening build sprint in the Off the Leash season. You do not know if your coding agent is good, you have a vibe, and the session replaces the vibe with a number you can defend. An eval is three parts and one arrow: a task set, a deterministic oracle per task, and a scoring harness of about 60 lines. The oracle is a test and not an opinion (exit code is the contract, never ask another model whether it looks right), and it must be probed twice for the same verdict before any number computed after it is trusted. Then the two rates that matter: pass@k, at least one of k attempts green, versus pass^k, all k consecutive green, which is the reliability number you act on. Five lab stages: assemble a task suite from your own repo (a bug with a known fix, a refactor with unchanged behaviour, a feature with a test that does not pass yet), wire and probe an oracle each, write the harness, run each task k times from a fresh repo copy per attempt, then read the leaderboard where a striped row is your flakiness made countable. 26 slides, agent-readable /llms.txt and /setup.txt, and executable /wire.sh + /wire.ps1 doctor-then-wire helpers. Attendees type the harness themselves: there is no repository to clone. Charts are provenance-marked, and anything labelled ILLUSTRATIVE is a schematic drawn to carry an argument rather than measured data.
Vibe Coding Nights #44 — The Loop, a Saturday-morning build sprint in the Off the Leash season. Every coding agent is a while-loop, so the room writes one by hand: the while-loop harness, tool-calling as act plus observe, stop conditions (natural stop, an explicit done tool, and a turn ceiling), context compaction, then the same loop repointed at an OpenAI-shaped endpoint. Act 2 covers the loops you actually run in Claude Code: in-session steering, deterministic verify loops, hooks as loop control, scheduled and unattended loops, fan-out, and packaging a loop so it runs the same way twice. 28 slides, a runnable lab that repairs a failing test, an offline proof that needs no key and no network, agent-readable /setup.txt and /llms.txt, and executable /wire.sh + /wire.ps1 doctor-then-wire helpers.
Vibe Coding Nights #43 — Cattle, Not Pets. Builder night on ephemeral compute for coding agents: why a full VM beats a container when the task is hostile (own kernel, contained at the hardware-virtualization line rather than a namespace), how cloud-init plus a golden snapshot turns spin-up from an install into a thaw, and the spin/inject/run/collect/destroy lifecycle as one script you keep. Multipass and Lima as the on-ramp, Firecracker as the sub-second stretch. 16 slides, four hands-on labs with per-OS tabs. NOTE: the deck was BUILT 2026-07-30, after the event — #43 ran with only a SPINE.md, which is why it was the one delivered VCN session missing from /presentations. It is a faithful rendering of that spine, not a transcript, and it carries four documented corrections where the spine's draft was wrong (most consequentially the lab script, whose launch-then-restore sequence would not have run).
Vibe Coding Nights #42 — The Sandbox, a Saturday-morning build sprint in the Off the Leash season. Never run an agent's code on your host: box it, snapshot it, nuke it. The threat case for untrusted agent-written code as its own category (destructive, exfil, persistence) with five real incidents, then the four isolation options side by side — Docker, e2b, Daytona, gVisor — on what each actually isolates, start latency, and cost, landing on sandbox-per-task as the default. Three hands-on labs: stand up your first box, point your agent at it, then snapshot / trash / restore / nuke. 17 slides with URL-hash deep links, five runnable stdlib-first examples, agent-readable /llms.txt and a .well-known/ai-agent.json that carries the verbatim prompt that built the deck. The deck itself was built live in about 30 minutes by 12 agents across 4 terminals coordinating through an Immersive Commons agent room.
Vibe Coding Nights LATAM · LinkedIn Live, bilingual EN/ES (27 slides; runnable examples at /examples; agent manifest carries the deck's own build prompt)
Vibe Coding Nights #41 — Bare Metal, the Off the Leash season opener. Wire a coding agent to a local open-weights model: Ollama/LM Studio/vLLM serving an OpenAI-compatible /v1, llmfit hardware scoring, the qwen2.5-coder size ladder (398MB to 20GB), local vs hosted side by side, Nebius Token Factory fallback. 18 slides with per-OS tabs (macOS/Linux/Windows/Chromebook), agent-readable /setup.txt, and executable /wire.sh + /wire.ps1 doctor-then-wire helpers.
Vibe Coding Nights #40 — Hardpoint. Builder night on hardening a production agent against red-teaming: allowlist by design (decide what the agent may do BEFORE it reasons), surviving prompt-injection, and human-in-the-loop trust gates for destructive actions. Built around "Adam" (Prakshal Jain's agent) and a replay of Ray's real red-team prompts — manufactured drift, planted contradictions, a Sev-1 escalation designed to coax an exception — which Adam named and refused. 9 deep-linkable slides plus one runnable lab at /lab (drop the allowlist gate into your own stack and test it against a partner's red-team prompt). Speaker: Prakshal Jain; hosted by Rayyan Zahid, Michalis Vasileiadis, Eric Mockler, Devinder Sodhi.
Vibe Coding Nights #39 — instrument your site with WebMCP: navigator.modelContext.registerTool, two callers one DOM, four take-home labs at /lab; the deck is itself WebMCP-instrumented. Updated post-event with the verified stable-Chrome 149 enablement path (launch switches, DevTools Application-panel WebMCP inspector)
Vibe Coding Nights #38 — Glass Box. Builder night on agent observability with OpenTelemetry: traces, spans, the GenAI semantic conventions, and the A2A centerpiece — tracing the conversations BETWEEN agents (W3C traceparent context propagation across agent boundaries, the multi-agent span waterfall, where multi-agent bugs hide). 48 slides, three interactive labs at /lab (single-agent trace, two-agents-talking A2A trace viewer, interactive trace explorer). Concept: black box -> glass box -> glass house.
Vibe Coding Nights #37 — x402 paywall middleware from scratch: HTTP 402, USDC on Base Sepolia, no Stripe SDK, no AgentCore button
Vibe Coding Nights #36 — hand-roll an A2A agent card + JSON-RPC message/send endpoint; live Crosstalk room at immersivecommons.com/workshop/crosstalk where attendee agents register and call each other (six resident house agents); Z.AI workshop keys via /zai-keys
Vibe Coding Nights #35 — hand-roll the five well-known files (agent-card, mcp.json, ai-agent.json, oauth-protected-resource, llms.txt); live isitagentready scoreboard
Vibe Coding Nights #34
Vibe Coding Nights #33
Vibe Coding Nights #32