work
How I take a project from a conversation to something shipped.
I build end to end, without handing the work off between roles. Not because handoffs are bad in principle, but because translation loss compounds at every one of them: the brief drifts from what the customer actually said, the design drifts from the brief, the build drifts from the design. Collapsing that chain into one person running one continuous loop removes the drift, not just the delay.
two habits of mind
a systems thinker
I don't evaluate a feature, a screen, or a query in isolation. I trace it through the whole system it lives in: what problem triggered it, what data model it touches, what it costs to serve, what it signals about the next request like it. A single prototype can double as market validation, technical spec, and UI reference at once, if it was built with the whole system in view from the start.
a vertical integrator
Most teams split product, design, front-end, and AI integration across different people, and pay for it in translation loss at every handoff. I run that stack as one loop myself: frame the problem, design the interface, build it, wire it to real data, adjust on what the data shows, without waiting on a handoff to move to the next step.
the loop
Six steps, run personally, in the same sitting.
A real conversation with a real prospect, not a persona or a backlog ticket.
step 1 of 6: feeds back into product framing, not into a backlog
Step six feeds back into step two, not into a backlog. AI tools compress the mechanical part of each step, so the saved time goes into judgment: deciding what's worth building, and checking that what got built is actually correct.
how I run each layer
Same method applied five times: turn the mechanical part over to AI, keep the judgment for myself.
product
Turn a customer conversation directly into a scoped prototype brief: no separate requirements document that drifts from what was actually said.
AI compresses it: drafts the first prototype scaffold and competitive framing from raw notes, in minutes.
Stays reliable because: the brief and the build share one source of truth, so nothing needs reconciling later.
interface / UX
Design in-code with a component system, not in a separate design tool that has to be re-implemented.
AI compresses it: generates first-pass layouts and copy variants against the existing component library.
Stays reliable because: every screen is reviewed and fixed by hand before shipping: bad patterns and accessibility gaps get caught at the source.
state / logic
Split state on its actual shape: server-derived data is owned, cached, and invalidated in one place; anything that only exists in the browser is owned separately.
AI compresses it: accelerates the boilerplate around that pattern once the pattern itself is defined.
Stays reliable because: server state and client state never drift out of sync, because each has exactly one owner.
API / edge
A typed, machine-readable contract between front end and backend, validated at the boundary, deployed close to the client.
AI compresses it: scaffolds routes and validation from the same definitions the contract is generated from.
Stays reliable because: the contract is the single source of truth: a change is caught before it ships, not in production.
AI layer
Ground every AI-facing feature in real, verifiable data, with reasoning visible to the user rather than a black box.
AI compresses it: is the feature here: streamed responses and visible reasoning steps, built on the underlying data.
Stays reliable because: trust comes from traceability: every claim in the interface can be traced back to a real source.
the stack I default to
Specific choices, not a grab bag: each one earns its place over a plausible alternative.
Next.js
Tailwind CSS
shadcn/ui
TanStack Query
Zustand
Hono
Cloudflare
Mastra
AG-UI- frontend
- Next.js, Tailwind CSS, shadcn/ui
- state
- TanStack Query for server state, Zustand for client state
- backend & edge
- Hono on Cloudflare Workers, Cloudflare Pages, KV, R2, Hyperdrive, Workflows
- AI layer
- Mastra for agent orchestration, AG-UI for visible reasoning
Locking a stack isn't brand loyalty: it's not re-deciding the same question on every feature. Each choice above is a decision made once, so the next one doesn't have to be.