>Staff Software Engineer · building production agentic systems
>I take a real business workflow and encode it into staged agents, deterministic validation, and human-in-the-loop pipelines that ship.
>Based in Greater Vancouver, BC · Handcrafting software since 2009
I needed a logo for a presence that already existed: a handle, open-source work, and more than a decade online. Silhouette is the Grok Bot distilled from the three-hour run that built it in stages: discovery, ideation and an anti list, shapes, type, and then the whole mark, wordmark, and spacing locked as one silhouette.
Latch v1 gave the agent hands. Version 2 adds bounded recovery for that path: a LaunchAgent that relaunches Grok Bot when the process is down or the heartbeat is stale, an optional outside heal request for disconnects the Mac cannot see, and a bounded way for Latch to operate Grok Bot's own UI when structured tools run out. Relaunch proven on self-heal kit 1.4.2; current kit 1.5.0 adds observe-only logging for silent cloud drops.
The bot had a computer. The next step needed to happen on mine. Latch is a specialist Grok Bot for the small, authorized desktop interactions that stall larger workflows: mouse first, clipboard over keystrokes, screenshot receipts, and a hard hand-back. This is the story of building it, including the keyboard lockout that wrote most of its rules.
Mobile-first taught us to design for the most constrained screen first. Agent-first asks a more fundamental question: what should our software be able to do when the user never opens it? This post looks at assistants that live in messaging apps, at capabilities an agent can discover and verify, and at what changes for marketing, discovery, and small open-source projects when the evaluator is an agent.
Codex has become the center of my development workflow, and the model is only part of the reason. Sessions that read other sessions, voice steering, goal mode, side chats, subagents on request, MCP, and an app server other harnesses can drive: the environment around the model is where the work happens now. Coding assistant is no longer a complete description.
A magic prompt is not a clever wall of instructions. It is a small, portable entry point into an engineered, tested workflow that takes a human and an agent from intent to a verified outcome — pre-flight, prerequisites, installation, authentication, validation, and the next step included. Here is how it should behave, and how to build one in layers.
Software is no longer just its source code. Its harness — the tools, memory, skills, and rules guiding the agents that build and run it — is now first-class.
Every week there is a new must-have AI tool, and somewhere inside the buzz there is usually a grain of truth. Buzzcut is a small agent whose only job is to find that grain: map the shiny new thing against what you already run and return keep, skip, or watch, with one flip condition. Not anti-hype. Anti-hype-driven architecture.
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 agentic-systems
drwxr-xr-x human-in-the-loop
drwxr-xr-x schema-validation
drwxr-xr-x developer-platforms
drwxr-xr-x systems-thinking