Skip to main content
Vibe GuidePart 06

Transmission 06 / 06  //  EDGE

Beyond the Browser

The open source payoff: the same stack, adapted for IoT, edge devices, and everything the hosted builders will never touch.

The Vibe Guide, Part 6 of 6 — IoT, edge devices, and the real payoff of open source

The Question That Sorts the Tools

Here's a simple test for any development tool: ask it to do something its makers never imagined.

Hosted builders fail this test by construction — their capability surface is their feature list, and their feature list is their business model. Ask Lovable to help program a RISC-V sensor board and you get a polite shrug. That's not a criticism; it's just what closed platforms are.

Open source tools pass the test differently: they don't have to have imagined your use case, because you can read the code and take it there yourself. This final part is where that stops being philosophy and becomes hardware on your desk.

The Thread We've Been Pulling

Every choice in this series quietly optimized for this moment:

  • Part 2: We chose Quests partly because Apache 2.0 meant the agent itself was adaptable beyond web apps — including for "programming my IoT and other ancillary and edge devices," which sounded like a footnote at the time.
  • Part 3: Standard files, standard Git, CLAUDE.md conventions — a workflow with no platform assumptions bakes in no platform limits.
  • Part 4: We kept a self-hosted box, because real control means running things platforms won't.
  • Part 5: PicoClaw entered the story — Go, single binary, <10MB memory, sub-second boot, runs on $10 RISC-V boards. That spec sheet wasn't trivia. It was the setup for this part.

What "Vibe Coding the Edge" Actually Looks Like

Let's stay concrete. Three escalating projects, all real workflows with today's tools:

Level 1: The device dashboard (pure carryover)

Your existing skills, pointed at hardware. A home or shop full of sensors and devices needs a control surface — and a control surface is just a web app that talks to local endpoints.

  • Bootstrap in Quests: "Build a dashboard that polls these MQTT topics / REST endpoints, charts sensor history, and exposes toggle controls with optimistic UI." Five-minute Abyss Drift energy, industrial usefulness.
  • Refine in Claude Code: reconnect logic, offline states, auth for the exposed bits.
  • Deploy on the self-hosted box from Part 4 — it's on the same network as the devices, which is exactly why you kept it.

Nothing new was learned; the workflow simply didn't care that the "users" are temperature sensors.

Level 2: The edge service (the stack shrinks to fit)

Now push compute onto the small hardware. A single-board computer watching a camera feed, aggregating sensor data, or bridging protocols — this is where the lightweight ethos pays off.

  • Claude Code is genuinely strong at systems code: Go services, cross-compilation (GOOS=linux GOARCH=riscv64 and friends), systemd units, and the read-the-datasheet drudgery of GPIO and serial protocols.
  • Your CLAUDE.md discipline transfers whole: document the board, the pinout, the constraints ("this device has 64MB RAM; no dependency may assume more") and the agent respects them the same way it respected the 60fps budget in Part 3.
  • The deploy pipeline is the Part 4 muscle again — except wrangler pages deploy becomes scp and a systemd restart. You have decades of exactly this.

Level 3: The autonomous edge (PicoClaw's home game)

The frontier: agents living on the devices. PicoClaw's whole design brief — single Go binary, <10MB, one-second boot, multi-provider LLM support, multiple messaging channels — reads like it was written for this:

  • A sensor node that doesn't just report anomalies but describes them in a WhatsApp message, with context.
  • A field device that can be asked questions in natural language over a chat channel, with a local or cheap remote model doing the reasoning.
  • The Part 5 architecture in miniature: NanoClaw on the big box orchestrating containerized engineering work, PicoClaw instances on the edge as tiny autonomous outposts, all reporting into the same channels you already use.

And because both claws are open source, when a device's constraints demand something bespoke — a different transport, a weirder board, a stricter memory ceiling — the path forward is a fork and an afternoon, not a feature request into a vendor's void.

The Compounding Loop

Step back and look at what the full stack does now:

Idea ──Quests──▶ Prototype ──Claude Code──▶ Product ──Part 4──▶ Deployed
                                                              │
        ┌─────────────────────────────────────────────────────┘
        ▼
  NanoClaw maintains it ──▶ PicoClaw extends it to the physical world
        │                                    │
        └────────── issues, fixes, ──────────┘
                    branches, tests

Every layer is open source. Every layer is inspectable. Every layer runs on hardware you control, with models you choose, at costs you set. That's not a workflow; that's a capability. The specific tools will evolve — some of these names will be different in two years — but a builder who owns their stack top to bottom adapts with the ecosystem instead of waiting on it.

The Manifesto, Restated

Part 1 opened with a rule: use the fastest tool that leaves you owning the result. Six parts later, we can state the full version:

  1. Speed is a starting requirement, not the goal. Five minutes to deployed is table stakes; surviving year two is the game.
  2. Ownership compounds. Open code, open models, open deploy targets — each freedom multiplies the others.
  3. Judgment is the scarce resource. Agents made typing cheap. Taste, architecture, and risk assessment got more valuable, and this whole system is a machine for applying your judgment at scale.
  4. The browser was never the boundary. It was just where the tooling started.

Where This Series Goes Next

This six-part run is the genesis of a full course. The course version will add what a written series can't: screen-recorded builds (the Abyss Drift five minutes, unedited), the live handoff session, a real NanoClaw onboarding week, and hardware-on-camera for the edge parts. If a section here made you want to see it rather than read it — that's the module list writing itself.

Until then: pick the smallest idea you've been sitting on. Open Quests. Set a five-minute timer.

Ship the vibe.

The Vibe Guide — Part 6 of 6. Back to the series index.