Work / Method
The operating system behind the work.
Tools change every six months. The method is what compounds. This is how I run projects, how I run AI agents, and how I keep both sharp.
The delivery loop
Five steps, then it feeds itself.
Same loop whether the deliverable is a design system, a migration, or an agent workflow. Step five is the one most teams skip — and it's the one that makes the others cheaper every cycle.
Understand
Sit with the users and the stakeholders before touching the architecture. Editors, attendees, business owners — the problem is never where the ticket says it is.
Decide & write it down
Every load-bearing choice becomes an Architecture Decision Record: the options, the costs, why this one won. Documents end debates; opinions restart them.
Build on rails
Design tokens, component schemas, idempotent scripts. The system enforces its own conventions so quality doesn’t depend on anyone’s memory — mine included.
Verify like a skeptic
Parity suites, usability rounds, accessibility audits. The test decides when we ship. If verification is a vibe, it isn’t verification.
Feed the system
Every gotcha becomes a runbook, every lesson becomes a rule the tooling loads next session. The loop is why year two is faster than year one.
The agentic stack
How I make AI agents safe enough to be fast.
A year of daily agents on a production platform distilled to four layers. Most AI adoption fails at the bottom two — teams hand out tool licenses and skip the infrastructure that makes them work.
Judgment
Deterministic first. A 30-line script that solves it forever beats re-prompting a model every week. The LLM gets the work that needs reasoning.
Gates
Validation in front of everything an agent produces: props schemas, idempotency audits, parity suites. Fast is only safe because the gates are there.
Context
Custom skills that load project conventions in one command, runbooks both humans and agents read, a memory index that spends context like a budget.
Hard rules
Non-negotiables enforced by the harness itself — hooks the runtime executes. Discipline that lives in tooling survives; discipline that lives in memory doesn’t.
Read it bottom-up: hard rules hold everything, context makes agents competent, gates make them safe, judgment makes them worth the money.
The UX method
Design the model, then the screens.
Most UX work starts with screens. Mine starts with the model in the user's head — because when the model is right, whole classes of error stop existing, and when it's wrong, no amount of visual polish saves it.
On semashow.com that meant collapsing five competing page structures into one entity with five variants. On the sema.org redesign it means usability testing rounds where I watch what people actually do, then turn the findings into direction a vendor's design team can act on. Evidence over opinion, in both directions — including when the evidence says I'm wrong.
And because I ship what I design, the method doesn't stop at handoff: tokens carry the design language into code, component schemas keep it honest, and accessibility is a build gate rather than a retrofit.
Staying sharp
How I keep up when everything changes monthly.
I learn in production
Every technique on this site was pressure-tested on a live platform with real traffic. I don’t collect frameworks; I keep what survives contact with production.
I write to understand
ADRs, runbooks, case studies. Writing is how I find out whether I actually understand a thing — and the archive compounds into a system that teaches the next person.
I build my own tools
When the workflow has friction, I build the tool: agent skills, audit scripts, migration extractors. Tool-building is how you learn what the platforms really do.
I teach it forward
From Fortune 500 training rooms to classrooms to documentation. Teaching is the most honest test of understanding — if I can’t explain it simply, I’m not done learning it.
See the method applied — four case studies with the receipts.