A Zigbee dongle passed through to the wrong USB port, Windows Fast Startup silently disabling Wake-on-LAN, Muse Glimmer compacting from hidden GitHub tool schemas, and git auth doing work Coder already handles. Four drifts, one theme.
Migrating Google Home routines to Home Assistant became a redesign of simulated occupancy. Saved daily variation, phone-based presence, restart recovery, and explicit manual handoff make lighting more flexible without giving an AI responsibility for running the house.
An old Acer Chromebox becomes a separate backup and DNS node through remote agent administration. A tested restore validates the backup path, while retiring the old resolver exposes a hidden dependency in the local AI router.
A GPT-6.1 Sol review of a well-used personal fitness tracker produced 13 prioritized findings and five fix batches. The experience sharpened a hybrid local/cloud workflow and a practical approach to auditing vibe code.
The Friday Fixes are about identity. The model that writes this blog kept coming back as the wrong one, the box had been running an older Qwen than expected, and the skill carrying the blog’s own conventions nearly lived on only one ephemeral workspace.
Seven local models on one RTX 5090 each wrote the same three posts, blind, so I could settle which one gets the writing lane of the homelab router. The house writer was not the fastest, and the judge did not agree with me on one of the three.
Tuning Hermes to run fast against local AI on a two-node DGX Spark cluster. One unrecognized reasoning_effort setting broke Hermes tool calls, and context compression cut the turn time about 4x. Covers the config fix, the context ceiling, and the latency floor tuning cannot remove.
Wiring the local model fleet into Coder Agents forced a realization. A policy router ignores the model name on the request and chooses a backend from the request itself, so Coder needs one generic default model instead of one entry per backend.
A two-node DGX Spark cluster carries the household model traffic, and the best tuning lever was one the deployment’s own A/B test had measured but production had reverted. Restoring it tightened the wait between concurrent requests, not raw speed.
A Vercel Fluid CPU overage on a blog with mostly static readers pointed at a theme running through the week’s fixes. The blog was doing work nobody needed. Each fix stopped one of those jobs instead of adding another.
Before I settle the local model policy for the homelab router, I ran GPT-5.5, Strix Qwen, RTX 5090 Qwen, and Spark DeepSeek through the same Coder Agents feature task. DeepSeek won the implementation quality round, while Strix taught me why policy needs speed data too.
After adding Strix Halo to the homelab, I wired Strix, Spark, and the RTX 5090 workstation into Coder Agents as explicit model choices, with the policy router still handling the default local path.
The local smart-home path moved from typed Hermes commands to real voice control, using a Pixel Tablet, Home Assistant Assist, Whisper, Piper, Android wake word detection, and Z-Wave lights on the ThinkCentre.
The local router prototype became useful when Hermes turned off a real Z-Wave light through Home Assistant, after USB passthrough, Z-Wave JS setup, entity mapping, and one stale MCP endpoint got fixed.
Turning a local AI policy-layer plan into a static router prototype, with FastAPI, Proxmox LXC, local DNS rewrites, Uptime Kuma monitoring, Spark DeepSeek, and 5090 Granite fallback routing.
A dual Spark DeepSeek endpoint solved the model problem, then exposed the next missing layer: local-first policy routing across household agents, specialist models, paid tools, PAIR, and future homelab nodes.
The dual Spark cluster moves from a working demo to durable household infrastructure: mDNS, reboot recovery, Hermes routing, remote dashboard access, benchmark results, and the first tuning lessons.
DeepSeek V4 Flash Vision-Exp on a dual DGX Spark cluster takes the broad local-agent benchmark lead, while Granite 4.2 no-think still wins the smart home slice that matters most day to day.
An architecture plan for folding a dual-node DGX Spark cluster and NVIDIA PAIR into the homelab, turning the RTX 5090 box and an M4 Mac mini into agentic workstations instead of the only inference engines in the house.
NVIDIA’s new Personal AI Router turns a pile of home GPUs into one shared endpoint for multi-agent inference. A look at what it actually does, why it fits a bottleneck already visible on this homelab, and what it rules out.
Round 2 of the local agent bakeoff saturated its coding domain completely, zero cracks across 18 fresh evals from two coding-focused models. That’s the moment to stop patching a broken test and split the question in two: what’s the best Home Assistant butler, and separately, what’s the best local coding model that fits a 32GB card. Here’s the research behind picking Terminal-Bench 2.1 over SWE-bench, and the plan for the actual run.
A random Tuesday sends an agent over SSH into the homelab to check every piece of software running there. Coder jumps two full versions, cloudflared and RustDesk get patched, and llama.cpp pulls in 317 commits, all with zero manual steps.
Cursor’s new forge product Origin reveals why GitHub’s human-centric architecture is struggling to keep pace with agent-driven development, and what it would take for a new entrant to actually displace the incumbent.
Three new contestants join the local agent bakeoff: IBM Granite 4.2, Poolside Laguna XS 2.1, and DeepReinforce Ornith 1.5. Granite 4.2 unseats Qwen 3.6 as the equal-weighted leader and dominates the one job that actually matters, Home Assistant tool-calling. Then a fourth run isolates a single variable, IBM’s default-on thinking mode, and finds it costs 10.8x the wall-clock time for no measurable accuracy gain on this battery. Plus: why the coding domain needs a harder replacement before round three.
Three consumer boxes claim they can run DeepSeek V4 Flash for a two-Hermes homelab: NVIDIA’s DGX Spark, Apple’s Mac Studio, and AMD’s Ryzen AI Max+ 395. Only two of them can reach the memory tier the model needs to run lossless.
A homelab experiment set out to find the optimal context window for a local Qwen 3.6 daily driver. It failed at that job, and revealed a more useful one: three real bugs, a clean speed-versus-depth curve, a prompt cache that hid 93% of the real token count, and a config change worth making in Hermes Agent’s compaction settings. Six tables. Zero cloud tokens spent.
Episode 4 gives an agent real write access to Uptime Kuma, retires the last manually-copied secret files, test-builds Proxmox Backup Server in Docker (catching a build that silently deleted the very package it installed), and catches a Wake-on-LAN plan that was about to fail for a reason nobody had checked yet.
Episode 3 installs HACS and an MCP server entirely over SSH, chases a phantom outage down to a single stuck config value, and wires nine Uptime Kuma checks with Discord alerts, then fixes a cron bug and a false-alarm habit before publishing.
The results already shipped. This is the part that took longer: forking an open-source Home Assistant benchmark, extending it into calendar, portfolio, and coding domains it never covered, and hitting two real bugs along the way — one hiding in code nobody had touched, one hiding in a floating-point boundary case we wrote ourselves.
Five local models, six evals, one real job: run Home Assistant, a calendar, an investment portfolio, and a to-do list — all self-hosted, no cloud. Qwen 3.6 holds the crown, but only barely, once three full runs replace one. Meta’s six-day-old Muse Glimmer nearly took it. Hermes 4.3 finishes last twice over. The scores, the failure transcripts, the run-to-run noise, and the one safety-relevant nuance the numbers alone don’t show.
Episode 2 of the SmartThings-to-Proxmox series: hardening the ThinkCentre, wiring up Tailscale so a Coder Agent can SSH in and administer it directly, standing up the Home Assistant OS VM, Uptime Kuma, and AdGuard Home, and ending on a single page load that quietly fired 53 blocked ad-tech requests.
Three models independently audited the same pinned code in isolated workspaces, blind to each other. Two produced reports. Opus 5 found the bug that actually mattered. Fable 5 was blocked twice, at the same spot.
A full feature build inside an existing vibe-coded app, start to finish: a plan-first conversation, two shipped phases, a progression system, two new MCP tools, and a glossary page that only exists because testing surfaced a gap the code itself never needed to close. Less about dumbbells, more about what it actually looks like to build something substantial into an app that already works.
One extended session on my personal fitness tracker turned up three real bugs, not one. A Tonal sync that silently died 14 hours out of every 24 because of an Auth0 token-lifetime mismatch, found by pulling live production logs instead of guessing. A years-old duplicate-workout bug that survived a prior “fix” because the matching logic was too strict, plus a self-inflicted unique-constraint bug I caught testing against production before it ever shipped. And a cleanup pass that found a second real bug hiding in plain sight, one repo review away.
Knowledge workers have been vibe coding for decades — it was just called VBA. That history has a second lesson buried in it: the technically better spreadsheet lost the 1980s, and the one with distribution won. Claude Code is winning on quality the way Lotus 1-2-3 did. Copilot is betting that doesn’t matter, and this time Microsoft isn’t just waiting around for the product to catch up.
My gaming rig’s Windows partition used to cost me 15-45 minutes of manual clicking every time I booted into it. One afternoon: a Coder workspace talking to it over Tailscale and SSH, an inventory script that catalogs every update channel on the machine, three Scheduled Tasks that actually do the work, a toast notification bug that took longer to fix than the automation itself, and a Next.js dashboard on Vercel to see it all without ever touching the machine.
115 days after building this blog from a cabana in Cabo, I spent one afternoon — 2:54 PM to 6:23 PM, back to back — running a chain of admin panel improvements: image upload, a visual TODO viewer, drag-and-drop reorder, a “launch agent” button, four rounds of troubleshooting it, and three mobile layout bugs found by actually using it on my phone at the end.
An AI Transformation team at a Fortune 500 financial services firm told me they’ve shipped 19,000 skills across 175 unique Coder workspace types in six months. That’s not a headcount story. It’s proof that as AI intelligence becomes a commodity, the real competitive advantage shifts to how businesses codify and distribute their proprietary workflows.
I kept typing the same paragraph into Coder Agents chat every time a session ran long or I needed to SSH into the homelab. A Slack conversation with a colleague turned that annoyance into five reusable slash commands — and along the way I discovered Coder Agents actually has two entirely separate skill systems, only one of which the `/` menu will ever show you.
A senior architect at a financial services firm told me chat context is now more valuable than code. It turns out a whole ecosystem — an arXiv paper with seven interoperable language implementations, two “Git for memory” projects, and zero agreement across model providers — is already racing to answer his question.
Sometimes your agent’s turn just ends with no result — no error, no output, nothing. Nudging it usually gets you the answer that was there the whole time. It’s tempting to write that off as a UX hiccup. Sometimes it’s a real bug, and finding out is part of the fun of vibe coding. A walkthrough of why that’s worth investigating, when it crosses the line into “file this,” and how to do it well — using a hanging GitHub tool call as the live example.
My wife saw OpenAI’s new Codex Micro and thought she could skip buying one — she already has a Stream Deck. That sent me down a rabbit hole: what the device actually does, how it compares to the Elgato hardware it’s built on top of, and whether a Linux homelab version is a real project or just another case of reinventing a wheel. A survey first, a build plan second, no results yet.
What started as a Thursday Thoughts hot take on the OpenAI/Hugging Face eval-sandbox breach turned into a research sprint: a survey of existing AI agent containment standards, a deep look at the closest one we found (the Agent Sandbox Taxonomy), an attempt to score the actual incident against it using nothing but public disclosures, and a plan to validate then run Coder itself through the assessment.
The May audit closed clean. Since then we shipped an MCP server, a Slack integration, and a shareable-snippet image generator -- three new pieces of attack surface that postdated every finding in that audit. A fresh scan against the same categories found 8 issues across the old surface and the new. Three phases, three commits, about an hour, one repo.
Building an app across dozens of disconnected agent sessions accumulates bugs. That’s the tax on staying hyper-vigilant across two axes at once: does it work the way a person experiences it, and does it hold up against someone trying to break it. This week split cleanly into both. Here are the four small bugs, each hiding in a corner some check didn’t cover. Monday’s post covers the security axis.
The Linux Foundation just launched the Tokenomics Foundation to extend FOCUS — the FinOps billing spec that normalized cloud cost data — into token-based AI spend. It’s the cloud-native parallel playing out again, except this time every knowledge worker who touches an agent is about to become a cost center. Here’s what FOCUS 1.4 actually standardizes, what it still can’t see on self-hosted infrastructure, and why we’re going to try to run it on a homelab anyway.
A routine “update Coder” request turned into a full model bakeoff: fixing misconfigured thinking params so Sonnet 5 would stop calling itself 4.5, discovering Playwright MCP can’t be wired into Coder Agents at all, and watching three frontier models independently pause at the exact same step before finishing. Sonnet 5 won on score and on cost, by a mile.
Anthropic and AWS are both, underneath everything else, infrastructure providers renting out specialized compute. But the sharper parallel is behavioral — both built a thriving ecosystem, then started eating pieces of it. Claude Design blindsiding Figma and Canva looks a lot like AWS’s Elasticsearch moment, except it’s happening at a pace AWS never approached, and one layer higher up the stack.
Mid-research on the LocalAI bakeoff, I got asked a blunt question: why not just run Coder Agents as the homelab supervisor too? The answer split my original coding-vs-general-purpose hypothesis into a sharper dichotomy — ephemeral/invoke-driven/git-centric vs. persistent/event-driven/tool-centric — and pointed straight at Turnstone as the next thing worth a real bakeoff.
A personal gaming-settings tracker built end-to-end with an agent: 28 curated profiles, a JSON API, an MCP server, and a dropdown that quietly pointed at data that didn’t exist. Five lessons from building it solo.
Three bugs that looked fixed from the wrong vantage point. An unquoted YAML date that crashed the public homepage one month after we wrote a blog post about the same bug. A model string that worked until its deprecation date passed. A security commit that stacked three invisible failures on top of each other. And a lesson about what accumulates when you build fast with agents.
A finance intern is spending her summer observing business processes and vibe coding automation tools. Not a CS major. Not shadowing someone. Building something real. It is a small example that says something big about how AI is reshaping internships, careers, and what the word “developer” actually means.
Vibe coding has moved from hobbyist curiosity to enterprise rollout across knowledge workers, and the next wave of AI adoption will be defined by governance and token economics.
Two Discord bots, one 14B model, five fitness-tracker tasks. Both agents failed on the first try. Getting them working required debugging context overflow, silent tool parameter drops, and a chat template flag that changes everything. The results reveal as much about the state of local AI agents as they do about which framework won.
Coder 2.34 shipped User Secrets — per-user credential storage that injects into every workspace automatically. We upgraded, audited 29 secrets across four projects, and found exactly two that belonged there. Here’s how we decided, how we migrated, and what we cleaned up along the way.
A model refresh on the homelab (Qwen 3.6, new embeddings, 469 llama.cpp builds), a feature sprint on the vacation planning site (calendar sync, expense tracking, and three bugs that taught us more than the features did), and automating Substack syndication after discovering two more undocumented quirks. Three unrelated workstreams, one theme: maintenance is where the real learning happens.
At a C-suite roundtable in Palo Alto last week, ten-plus executives from a mix of gaming platforms, enterprise systems providers, job sites, and other Bay Area titans landed on the same analogy without being prompted: we’ve seen this before. The lift-and-shift era of AI is already here. The native era — where you redesign workflows from scratch for agents, not humans — is what comes next.
I’ve been running OpenClaw on the homelab for a month. A recommendation sent me down the Hermes Agent rabbit hole — and the research before the first real test revealed my daily driver model was broken for tool calling all along.
I built a trip planning site for my F1 Montreal group. Then I ripped out every hardcoded value, added a setup wizard, ran a security audit, and open-sourced it. Here’s what it takes to turn a single-purpose vibe coded app into something anyone can fork and deploy.
The fitness tracker MCP server was a test run. This week I added the same thing to vibescoder.dev — 16 tools that let any agent list posts, publish drafts, check analytics, trigger deploys, cross-post to Dev.to, and troubleshoot the live site. Here’s the build, the architectural decisions, and what it’s like when the agent that built the feature can immediately use it.
Two weeks of using Qwen3.5-35B as my daily AI assistant — the Jinja template fix that made it work, the thermal spam incident that almost ended the experiment, and the session-context gap that makes it feel like a junior dev every morning. Plus: what’s next with Qwen 3.6.
I asked an agent to security-audit my fitness tracker after wiring MCP into it. It found nineteen things. I fixed them all in four neat batches. Then the dashboard went empty, Google sign-in died, and the real bugs turned out to be the ones the audit couldn’t see — a middleware file that had been silently doing nothing for months, and an OAuth client that never existed in any project I owned.
One missing pair of quotes in one frontmatter field took down the admin drafts page. YAML 1.1 auto-parsed the date to a JS Date object, formatDate called .includes on it, and the route 500’d. Here’s the bisect from a mobile screenshot to a one-line fix, why only the drafts page broke, and the lesson about trusting types at the YAML boundary. Part two of a two-part Friday Fixes — see #1 for the scheduled-publish workflow bugs that landed the same day.
The scheduled-publish GitHub Action broke twice in nine days. Bug one: a grep that matched body text instead of frontmatter, triggered by a post about the feature itself. Bug two: a dead-code line introduced by the fix for bug one — racy under set -euo pipefail, probabilistically silent for eight days, then 42 consecutive failures with zero notifications.
Someone vibe coded an app with Google AI Studio. The Gemini API key shipped in the client-side JavaScript bundle. Google suspended the project. Here’s why every AI coding tool gets this wrong, why regular audits are the only real defense, and what you can do before it happens to you.
I built a Model Context Protocol server into the fitness tracker I vibe coded a year ago, wired it through Vercel and Coder workspaces, and ended the afternoon asking my Discord bot what my last workout was. Here’s the build, the wrong turn into Coder’s AI Bridge, the workaround, and how the same endpoint now serves Claude Desktop, Codex, Coder Agents, and OpenClaw.
The Round 5 bakeoff produced four implementations. None of them shipped. What shipped was a merge of the best pieces from all four, then a polish pass against real data. Bakeoff → Merge → Polish is a generalizable pattern for any feature where the design space is genuinely unclear.
Three AI agents audited the blog and produced three different reports. Closing them out was its own job — triage, phasing, verification, and ten commits across two repos with zero build failures. Here’s the remediation arc, what shipped, what got deferred, and what the process revealed about working through someone else’s audit.
Four LLM models built the same admin feature in isolated Coder Agents sessions. I judged them blind. The headline result: Sonnet 4.6 beat Opus 4.6 on a coding task. The deeper story is what each model did with the same prompt — and what it took to make the bakeoff fair in the first place.
From curl to working Discord bot in one afternoon — with a local LLM on the RTX 5090. Every gotcha, every config mistake, and the one setting that silently ate every server channel reply for hours.
Our AEO audit gave vibescoder.dev a clean bill of health. Cloudflare’s isitagentready.com gave it a 25 out of 100. Both audits were right — they were measuring two different competencies. Here’s the side-by-side, what each one caught, and the two genuine gaps we shipped fixes for — taking the score from 25 to 33 (and on track for 39 after the next scan).
DeepSeek V4-Pro, V4-Flash, and Zyphra ZAYA1 are three of the most exciting new models in local AI. None of them run on our RTX 5090 homelab — for completely different reasons. Here’s the research, the math, and what it means for anyone building a local inference rig.
I pointed a current-gen AI agent at a fitness tracker I vibe coded a year ago. Five PRs later: security holes patched, a 1,300-line component broken apart, sync queries batched, and accessibility fixed. Here’s what the audit found, how it was structured, and why every vibe coded app deserves a spring cleaning.
A second user joined the homelab Coder instance and couldn’t push to GitHub. What looked like a missing config turned into five chained problems, a domain migration aftershock, an agent-debugging-an-agent meta-moment, and the discovery that the same credential helper bug had been “fixed” four times in ten days — and never actually deployed.
Two AI models got the same prompt: review the blog fodder, check for redundancy, and draft a post. Opus chose a debugging war story. Qwen chose a data-driven redesign. Neither picked the same fodder. Here’s what the difference reveals about how models think about content.
Tag filters barely changed anything. A data audit revealed the problem: 94% of posts had the same tags. We replaced folksonomy with taxonomy, rebuilt the filter bar, and cut tag saturation from 94% to 56%.
Building a Dev.to cross-posting system for vibescoder.dev — and the four hours spent debugging an API that silently swallows your data without a single error message.
Three rounds of iPhone screenshots to fix spacing that should have been right the first time. The fix wasn’t smaller padding — it was teaching the agent the pixel math once so it never forgets. Plus: admin pillbox for drafts, hamburger menu shortcut, Invalid Date bugs, and scheduled publishing for every draft.
As AI agents make code generation trivial, the real value shifts from storing source code to preserving the chat conversations that created it.
I asked an AI agent to turn off my RGB lights on Linux. 85 terminal commands, 35 failures, 4 hangs, 2 dead download links, one wrong build system, and the GPU is still glowing. This is the post.
How we built a feature that turns any table or code block on vibescoder.dev into a branded, dynamically-sized PNG — downloadable or shareable with one click. Eight commits, three Satori crashes, and one middleware lesson.
Gemma 4 failed to build a single feature in our last test. This time we diagnosed the problem, switched from Ollama to llama.cpp, tuned the inference settings, and Gemma shipped a working search feature to production. Then Opus reviewed the code and made it better. Here’s what we learned about making local models actually work.
Four bugs that were silently breaking things for days: a deploy that only crashes on new images, a shell guard that eats your auth tokens, a publish date frozen at draft creation, and a homelab with no emergency remote access. Plus: capacity planning for when you’re running AI workspaces on a single machine.
A deep audit of vibescoder.dev revealed that Cloudflare was silently blocking every major AI crawler — even after we’d explicitly turned that setting off. Here’s what we found, what we fixed, and the complete playbook for making your site visible to both search engines and AI agents.
A CRLF bug silently broke every workspace for weeks. Then we fixed it, taught the agent to remember, moved templates to Git, squashed a nested heredoc, cut boot time from 91 seconds to 5, automated the screenshot pipeline, and built scheduled publishing — which this post used to publish itself. Ten fixes, one week.
How AI agents are transforming software development the same way Google Maps revolutionized travel - making the impossible feel effortless and opening up new worlds of exploration.
We pitted Gemma 4 against Opus 4.6 on a real feature build for vibescoder.dev. Gemma is the fastest model in our benchmark. It also couldn’t finish the job. Here’s what happened when we stopped testing toy apps and started building production code.
While waiting for massive open source models to download, I tackled the homelab backlog: custom domain for my Coder instance via Cloudflare Tunnel, security hardening (with a gotcha that could kill your AI search visibility), and wiring up MCP servers to give agents superpowers.
Code block overflow, social metadata, dynamic OG images, Slack notifications for blog comments, a /todo slash command, and more. Everything shipped in a single conversational session with Coder Agents.
The journey from “I should build a home lab” to a fully configured self-hosted Coder server with GitHub integration, multi-user workspaces, and AI agents that actually know how to use the tools available to them.
I open-sourced my blog for Giscus comments and immediately found a gutted .gitignore, an exposed server URL, and all my unpublished drafts on GitHub. Here’s how I split code from content without changing a single line of application code.