Brian McQuay

The projects that failed were not failures of skill or effort.

The frontier labs are treating recursive self-improvement like a winner-takes-all finish line.

We're pouring enormous resources into aligning AI with human values, but a self-improving superintelligence would treat that alignment as one more constraint to optimize away.

Point an LLM at your database and tell it to respect tenant boundaries, and you've swapped a deterministic security control for a probabilistic one.

Every programming language we've ever built was optimized for human cognitive limits — small functions because we can't hold much in working memory, descriptive names because we forget.

Two decades of remote work — from the unreliable-Skype era through the COVID boom — taught me that the real hidden cost isn't productivity, it's your network.

Porting your human code-review loop straight onto AI agents is a budget disaster.

If a test fails half the time, it isn't a test — it's noise.

The Fable shutdown might be our first glimpse of an uncomfortable future — not one where AI gets too powerful, but where safeguards become meaningless.

Every fix to an AI code-review prompt risks silently breaking a previous one.

AI writes fast but decomposes work badly — producing massive PRs and drifting from the original objective.

I've reached the point where I trust my AI agent orchestration system more than I trust myself to stay consistent with repetitive code reviews.

After a month-long experiment working directly in Claude instead of my own agent orchestration system, I'd become a serial bottleneck in my own workflow — and the quality guardrails I'd built into Sandstorm quietly disappeared along the way.

What if your slowest API endpoints could fix themselves while you sleep?

Today we ration our bug-fixing attention because investigation is expensive.

Planner agents, reviewer loops, memory systems, decomposition workflows — every team is reinventing the same patterns because models can't yet internalize them.

After months of funneling every workflow step through Claude, telemetry showed my orchestration layer was drowning in unnecessary context.

After adding telemetry to Sandstorm, I discovered a compound MCP problem was silently ballooning context to 350,000 tokens per task.

After chasing parallel agent throughput, I slowed down to chase quality—and discovered the real bottleneck wasn't planning, it was context discovery.

I built a sophisticated agentic AI workflow that produces amazing code—then hit token limits hard.

After analyzing dozens of AI-generated pull requests, I discovered two critical quality gates that dramatically improve agent output — and built them into my workflow.

I built Sandstorm Desktop, a cross-platform Electron app that orchestrates multiple AI agents through Docker containers — and used it to complete a two-week sprint in three days.

How I'm building an open source tool that lets individual developers safely run multiple AI agents in parallel using Docker-based isolation — no cloud infrastructure required.

What started as updating some stale Ruby gems evolved into a complete architectural rethink — separating translation data from implementation across Ruby, JavaScript, Go, and Rust.

I haven't written code in two months.

LLMs aren't deterministic.

AI wrote 100% of the code.

Most developers are using AI wrong.