>Code Artisan, Web Solutionist
>Handcrafting software since 2009
Software used to be expensive enough that we assumed every serious effort should last. AI weakens that assumption. Some software now only needs to exist long enough to solve one problem, communicate an idea, or feed the real build. Disposable software is its own category — not a lower one.
The pull request used to be finished code waiting to be merged. With agents doing most of the building, it has quietly become something more: a rich research and communication artifact — without shedding the code review and compliance checks that made it trustworthy in the first place.
Not every piece of context an AI coding agent sees carries the same weight. The user prompt and the code dominate; documentation is a secondary orientation layer. Here's why imperfect docs are usually good enough, and where your effort actually pays off.
AI can produce code, comments, PR descriptions, and review replies faster than humans can read and own them. The real bottleneck is no longer generation — it's comprehension. Here's how I think about effort symmetry, accountability, and why I don't buy a universal taxonomy.
The Unix philosophy — small programs, composed through pipes, doing one thing well — turns out to be an ideal operating model for AI agents. Skills leverage this by guiding agents to use battle-tested programs rather than reinventing them. Here's why that beats building custom MCP servers for most workflows.
We've become unpaid staff for the applications we use. The future will separate operational back-office work from human-facing front-office experiences, with AI agents handling the infrastructure while humans focus on judgment and decision-making.
After more than a decade in tech, I thought I'd seen every variation of the hiring process. Then I worked with a recruiter who showed me what it looks like when someone genuinely cares about doing the job right. This is a reflection on trust, transparency, and why the best recruiting feels less like a transaction and more like a partnership.
Documentation drift is the silent killer of codebases. Your roadmap says one thing, your website another, and your README hasn't been updated in months. Here's how I built a pluggable Claude Code skill that detects drift, shows exactly what's out of sync, and fixes it—with your approval.
A deep dive into fixing broken zsh tab completions with Oh My Zsh, and how I turned the solution into a Claude Code skill. Learn why fpath order matters, how compinit timing breaks completions, and the pattern of encoding debugging knowledge for AI assistants.
Work is the worst place to learn how to use AI well—precisely because it's the place where results are expected. In 2026, having a personal or open source project isn't about passion. It's about having a place where you're allowed to learn slowly so you can perform quickly elsewhere.
There's a line in a song that aged better than anyone expected: your own personal Jesus. In the AI era, it stops being poetic and starts becoming literal. But this isn't about simulating Jesus—it's about building agents that embody the behavioral patterns of moral revolutionaries, governed openly, and accessible to everyone without institutional gatekeeping.
There's a strange moral superiority creeping into how people talk about AI-assisted development. We mock AI for making mistakes we'd forgive in ourselves. We demand one-shot perfection from tools while accepting iteration from humans. Maybe it's time for a little more empathy—and a little more honesty about how software has always been built.
How I built an automated system that generates social images for blog posts using multiple AI providers, with Claude analyzing results and a PR comment interface for human-in-the-loop selection. A case study in agent-orchestrated workflows.
For the past decade, AI models trained on the open web. That era is ending. The next frontier of training data isn't on websites—it's in our conversations with agents. If we don't build infrastructure to capture and share this data, the future of AI will be fragmented, siloed, and closed. Here's why we need an Agent Data Commons, and what it would look like.
When I hire an engineer, I look for their blog posts, open source contributions, and public work. Why should hiring an AI agent be any different? Exploring the rationale behind distributed, discoverable agents with public personas—and why this matters for the future of autonomous systems.
From mainframes to modern Rust CLIs—exploring how compile-time embeddings and offline-first architecture embody the principles of self-contained autonomous agents. A deep dive into building a blog distribution CLI that needs nothing but itself to run.
When you're cooking, there will be shells. When you're vibe coding, there will be markdown files scattered everywhere. AI-generated artifacts aren't bugs in the process—they're receipts of creation. Here's why fighting the mess is futile, and why hiring a cleanup crew (of agents) is the answer.
AI agents that generate code need the same thing humans do: fast, objective feedback. From plan-driven execution to self-verification systems, the future of AI-assisted development is built on the same loops we've always used—just at unprecedented scale and speed.
Over the past two years, a split has formed in software engineering. Some see AI as a new programming language—a compiler for natural language. Others see it as a powerful but fallible tool. Both perspectives miss something crucial: the ghost in the machine, and why fundamentals matter more than ever.
Frontend developers intuitively understand feedback loops. From instant visual validation to component isolation tools like Storybook, UI development is the art of seeing change instantly. Here's why it works—and how modern complexity almost broke it.
TDD isn't just about testing—it's about creating fast, objective feedback loops that make software observable. Understanding this foundation is critical for modern development, from frontend tooling to AI agents.
TDD, hot reload, Storybook, AI agents—they all solve the same problem. Understanding this pattern is the key to thriving in AI-first development.
Software engineering is fundamentally the craft of forming expectations and verifying them. From test-driven development to AI agents, the same core mechanic governs progress: tight, objective, observable feedback loops.
Progress doesn't ask for permission. As AI transforms how we build software, every engineer faces a choice: resist, observe from the sidelines, or learn to orchestrate the future. This is our Hamlet moment.
As AI agents write more code, the fundamentals matter more than ever. A reflection on relics, craftsmanship, and why less code is still better code — even when machines do the writing.
Revisiting my advice to "read more, write less code" in the age of AI. While research remains crucial, developer workflows now include a vital new step: co-creating with AI tools before coding.
We don't know what we don't know - You've got a task? Instead of going ahead and writing the code for it, try researching online.
drwxr-xr-x systems-thinking
drwxr-xr-x web-architecture
drwxr-xr-x modern-javascript
drwxr-xr-x developer-experience