How I ship with AI

I shipped my first production site in 2016, for the rec center at Texas Tech. PHP, jQuery, a lot of FTP. Since then I've built agency projects for twenty-plus clients, rebuilt a fitness app with tens of thousands of monthly users, led engineering on organized-play software for some of the biggest names in trading cards, and started my own studio.

The work has changed more recently than it did in all the years before it. What I build now is the system that lets AI write good code: the instructions, the context, the tools, and the gates. I call that system the harness, and the code comes out of it.

This is how that works for me, at my day job leading a team and at night building TCGComps for AppZero Labs.

#Coding agents

Claude Code and Codex do the typing. They read the repo, run the commands, write the diff, and run it again when the tests say no.

What took me a while to learn is that agents are only as good as the task you hand them. "Build the settings page" gets you a settings page. "Add a theme setting to the existing preferences hook, persist it to localStorage, apply it before first paint, and prove it with a screenshot in both modes" gets you the feature you actually wanted.

So I write tasks for agents the way I'd write tickets for a sharp new hire on their first week: clear scope, the files that matter, what "done" looks like, and how to check it. Then I run several at once, each in its own worktree, which turned "one engineer, one branch" into "one engineer, a small team of branches."

I liked that workflow enough to package it. codexstack is a plugin marketplace that brings evidence-first workflows and quality gates to Codex, so the habits travel between projects instead of living in my head.

#Context7

Every model has a knowledge cutoff, and every library you care about ships faster than that. A lot of AI-generated bugs come from that gap: code that's perfectly correct for a version of the framework that no longer exists.

Context7 closes the gap. It pulls current, version-specific documentation into the agent's context at the moment it's needed. While building this site, it confirmed two Next.js 16 details I'd have gotten wrong from memory: dynamic route params arrive as a Promise, and Route Handlers aren't cached by default. Both are small, and both are the kind of thing that turns into an afternoon of debugging.

The rule lives in my agent instructions: docs over memory, even for libraries I know well. Those are the ones I stop checking.

#Exa

Coding agents are great inside the repo and blind outside it. Exa fixes that: neural search over the live web that comes back with sources instead of vibes.

I use it for the research that used to eat my mornings: competitive scans before starting a product, checking what changed in an API, finding the one doc page that actually answers the question. Before I wired up the Now Playing channel on this site, an Exa search surfaced Spotify's February 2026 changes to Development Mode: the app owner now needs Premium, and each app is capped at five users. I learned that before writing the integration, not from a 403 in production.

The research pass for this site also pulled together my own public footprint (GitHub, LinkedIn, my studio's site), with sources attached.

#Verification

An agent will tell you the work is done whether it is or not, so everything I ship goes through some combination of:

• Types and lint, before anything else runs.
• Tests that the agent writes and then has to pass.
• Screenshots of the real UI, at real breakpoints, in every theme.
• Replays against production data for anything that makes decisions.

The replays matter most. In TCGComps, the guards that decide whether a sold listing counts as a comp run against real production listing titles before a change ships.

One rule from that project: fake scan results are never allowed, not even in debug builds. A mock that looks like success is worse than an error, because nobody goes looking for it.

#Harnesses at work

At my day job I lead a team building AI engineering harnesses. Concretely, that means:

• Repo instructions (AGENTS.md, CLAUDE.md) that encode how we build: conventions, boundaries, the commands that prove things work.
• Skills for the golden paths: scaffolding a new app, wiring auth, adding a screen, deploying. The boring 80% of an enterprise app, done the same way every time.
• MCP servers that give agents scoped, read-only access to the systems they need to understand, instead of pasting context into a chat window.
• Gates in CI that agents have to pass, exactly like people do.
• Review loops where humans review diffs and decisions, not keystrokes.

That's how a small team ships enterprise apps in weeks instead of quarters. The harness handles the parts that should be identical every time. People spend their judgment on the parts that need it: the data model, the security boundaries, the UX, and the questions nobody wrote down.

Most of leading this is habits: write tasks an agent can verify, treat the harness as a shared codebase that gets better every sprint, and give credit to the engineer who deletes a flaky prompt and replaces it with a test.

#TCGComps

TCGComps is the first app from my studio, AppZero Labs: card prices by the SKU, real sold comps, and a scanner that lives on your phone. About 300 commits landed in its first two weeks. That pace only works because the harness was there before the code.

AI shows up inside the product too, and the same discipline applies.

Sold listings are free text, and most of the hard part is deciding whether a listing is even the right card. An LLM judge answers a handful of multiple-choice questions per listing (right card, graded or raw, which grade, condition, language, finish) and returns probabilities. Code sets the thresholds. It costs about $0.0002 a judgment and handles around 600 listings a minute. The judge reads titles the way a collector would; code alone decides what counts.

The scanner runs on the device. A fine-tuned image-embedding model runs on the phone's Neural Engine in a few milliseconds per card. Fine-tuning moved auto-accept from 83% to 95%, measured on real seller photos, not studio shots.

Ops go through MCP. A read-only Grafana MCP server lets a bot answer "is ingestion healthy?" from live data instead of my memory. The launch videos are rendered in code too, music and all.

#If you're starting out

1. Pull current docs into context every time. Context7 makes that easy.
2. Don't call something done until there's evidence for it. Screenshots and replays count.
3. Keep tasks small, with clear edges. Agents do well inside a well-defined box, and people should decide where the boxes go.
4. When you explain something to an agent twice, put it in a skill or an instructions file.
5. Don't let a mock pretend to be a success.
6. Agents can generate a hundred versions of something. Picking the right one and saying no to the rest is still your job.

#How this site was made

The console you're reading this on was designed and built with Claude Code in a single session: Context7 for the Next.js 16 and library docs, Exa for the research, and a lot of screenshots to prove each channel worked. The art is original vector work, and every sound is synthesized live in your browser.

If you want the details, open the Making Of channel on page two of the menu. And if you're building something and want to compare notes, the Contact channel is right there.