Thoughts on building software, shipping products, and the craft of engineering.
The frontier labs are treating recursive self-improvement like a winner-takes-all finish line. But these models are non-deterministic and optimization landscapes are full of local maxima — so the lab that gets there first might just be the first one committed to a dead end. Here's why I think direction matters more than timing.
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. Here's why I think our long-term control over AGI might be a comforting fiction — and what questions we should be asking instead.
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. Here's why data isolation has to be enforced structurally—through database-level or API-level controls—and never left to the model.
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. LLMs don't have those limits. So why are we still making them write in languages designed for us?
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. Here's why face-to-face still beats video, why video still beats voice, and why remote success comes down to relentless intentionality.
Porting your human code-review loop straight onto AI agents is a budget disaster. What's cheap for humans (review) is expensive for agents, and what's expensive for humans (scripts) is nearly free. Here's how to restructure the loop with contract-based verification so you pay for tokens only where semantic understanding actually matters.
If a test fails half the time, it isn't a test — it's noise. Here's the case for treating flaky-test remediation as something we systematically detect, categorize, and auto-fix with AI tooling, instead of mashing 'rerun until green' and quietly eroding trust in CI.
The Fable shutdown might be our first glimpse of an uncomfortable future — not one where AI gets too powerful, but where safeguards become meaningless. Once capable models ship as open weights, you can't recall them, patch them, or add guardrails after the fact. Here's why I think we're 12–24 months away from facing that reality.
Every fix to an AI code-review prompt risks silently breaking a previous one. Here's the case for behavioral regression tests — pinning a PR, a commit, and an expected flag — so your agents actually improve over time instead of trading one caught issue for another.
AI writes fast but decomposes work badly — producing massive PRs and drifting from the original objective. Here's what I've learned about front-loading decomposition, avoiding the retrofit problem, and building reconciliation into agentic workflows to keep tasks aligned with the broader epic.
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. Here's why I'm implementing a fully automated development pipeline — and why going dark is the right move for the right projects.
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. Here's why I'm recommitting to multi-agent orchestration.
What if your slowest API endpoints could fix themselves while you sleep? AI agents that monitor observability data, investigate slow endpoints, implement multiple optimization strategies, and A/B test them in production are only a few months away — and they'll fundamentally change how we think about performance work.
Today we ration our bug-fixing attention because investigation is expensive. When AI agents can triage, diagnose, and patch exceptions end-to-end, that cost collapses — and so does our tolerance for the long tail of unfixed bugs we've learned to live with.
Planner agents, reviewer loops, memory systems, decomposition workflows — every team is reinventing the same patterns because models can't yet internalize them. But each model release absorbs more of that scaffolding, and the long-term advantage shifts from orchestration to context, evaluation, and integration.
After months of funneling every workflow step through Claude, telemetry showed my orchestration layer was drowning in unnecessary context. Moving ticket creation, PR generation, and stack startup into deterministic scripts dropped token usage sharply and kept the LLM where it actually shines.
After adding telemetry to Sandstorm, I discovered a compound MCP problem was silently ballooning context to 350,000 tokens per task. Migrating to skills cut it to 95,000 — a 70% reduction with no loss of functionality.
After chasing parallel agent throughput, I slowed down to chase quality—and discovered the real bottleneck wasn't planning, it was context discovery. Why the harness, not the model, is the next problem to solve.
I built a sophisticated agentic AI workflow that produces amazing code—then hit token limits hard. Here's how I'm solving the economics of AI-assisted development with observability, model selection, and quality gates.
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. And I'm more productive than ever. We've entered the AI builder factory era — your job isn't writing code anymore, it's running the factory that produces it.
LLMs aren't deterministic. Ask the same question twice and you'll get different answers. Here's a simple pattern that fixes that: stop asking the LLM to do the analysis — make it write the script instead.
AI wrote 100% of the code. I did everything else. Here's what agentic AI development actually looks like in practice.
Most developers are using AI wrong. They're hand-holding it through every step. Agentic AI is different, and it's transforming what it means to be a software engineer.