The blank page is home
Build the operating model
Let users lead
Assume the model will fail
AI as partner
The blank page is home
My whole career has been 0-to-1 — in startups and inside big companies — and the part I love is the same every time: listening to real people, finding the insight nobody else has named, and turning it into something that didn't exist before. The stack changes; the work doesn't.
Build the operating model
I can't not think in systems — if I've done something twice, it should be automated; if something broke, the system broke (not just the bug); if a pipeline gets used, it should get better each use. I ship features — and I ship the system that makes the next feature easier.
Let users lead
Building has become cheap and fast — the real differentiation now is the person who knows their users best, and the insights no one else has decoded. Decoding what people actually mean (not just what they say) is the puzzle I love most, and the killer insight is what unlocks everything downstream.
Assume the model will fail
I build every pipeline with evals from day one, cross-model review, human gates on creative outputs, and failure-mode tests per output type — so drift gets caught before users ever see it. This is the part of the craft I think most teams still underinvest in.
AI as partner
AI works best for me as a thought partner — something that helps me think better, not something that thinks for me. The judgment about what to build, what to kill, and what to notice that nobody else flagged is the work I want to keep closest, because it's the part that doesn't delegate.
"Vibe coding has a ceiling. I built the bridge to Claude Code."
A VS Code extension for people graduating from Lovable / Replit / Bolt / v0 to Claude Code.
- Vibe coding platforms work until they don't — credit loops on dumb errors, ceilings on complexity, code that isn't production-ready.
- The existing options: keep burning credits, or "learn to code from scratch." Neither meets people where they actually are.
- Sets up a Claude Code environment with opinionated project templates.
- Pre-configures integrations (Supabase, Stripe, Vercel) so migration isn't a weekend of YAML.
- Built solo in a few months using Claude Code itself — the extension was built with the thing it helps you migrate to.
- Positioning landed on "Building Fast Is Easy. Building Right Is Hard." after 3–4 iterations — earlier versions led with features; this one leads with the feeling.
- A Reddit pipeline mining 30–50 users/day in their own words changed my positioning twice before I wrote a single landing page.
- What I'd do differently: ship evals on the setup flow from day one, not bolt them on after the fact.
"I stopped running surveys. I started mining 30–50 real users a day, in their own words."
A scraper + synthesis pipeline across vibe-coder subreddits. I used it to validate Vibecheck's core thesis before writing a landing page.
- Surveys filter users through questions you already thought of.
- Reddit gives you their words, their frustrations, their specific platform pet peeves — not what a PM assumed to ask about.
- Pulls 30–50 relevant posts/day across a watchlist of subreddits.
- Filters for "I'm stuck" signals (credit burn, refactor walls, platform-switching threads).
- Clusters themes weekly; flags rising ones.
- Writes back to my discovery doc so insights compound instead of evaporating.
- Discovery isn't an event — it's a pipeline that runs alongside the product.
- The silent majority isn't on Reddit. This is a biased sample, and I treat it that way.
- Running this changed my positioning twice before I wrote a single landing page.
"I didn't just use Claude Code. I designed a methodology around it."
The loop I built to ship AI features solo — from rough idea to deployed code without losing rigor to speed. Each step is a Claude Code skill with its own opinions.
- PRD-from-Airtable — signals from my roadmap synthesized into draft PRDs I edit against real priorities.
- /feature-design — conversational PRD for one feature, 3–4 exchanges.
- /implement — detailed plan with phases, checkpoints, testing checklist.
- Build (Claude Code).
- /verify — spec compliance, accessibility, brand, PRD reconciliation.
- /code-review — 8-lens deep review before shipping.
- /ship — final gate, rollback plan, docs, changelog.
- A standalone "research" step — it kept reopening decisions endlessly. Discovery now lives inside /feature-design, scoped to the feature.
- A formal UX review — code-review caught the same things earlier; the separate step wasn't earning its keep.
- Judgment about what signals go in (most of the work).
- Judgment about what to throw away (the other most of the work).
- This pipeline didn't exist three months ago. It exists because I kept noticing where I was doing the same work twice.
"A content pipeline dressed as a fashion business. 25K followers, $29K+/month, solo."
A fashion deals Substack + IG running at $29K+/month with zero headcount. A real business, but mostly a vehicle for learning what an AI-native content operation needs.
- IG + Substack distribution (25K followers, unsolicited reader praise on the open rate).
- Email scanner that pulls sale signals from brand newsletters as they hit the inbox.
- Content pipeline: trend → hook → caption → reel, generated in my voice.
- Sale data since November (brand + % off + timing) — a growing corpus for a future recommender.
- Content is a distribution moat, not a substitute for product — a lesson I'd already learned (painfully) at Uplift Parents, now re-earned with a working engine behind it.
- A fashion-deals pipeline and a B2B PRD pipeline are closer relatives than they look — same shape: signal → synthesis → human gate → output.
- The bottleneck isn't generation. It's judgment about what's worth generating.
"Same craft, older stack. 2–3 days of event production compressed to an hour. It's what got us acquired."
The Airtable-native content pipeline that ran Breakout's events. Same decomposition craft I use now, on a 2023 stack.
- Concept → run-of-show → script → tech notes → slide deck → site copy → prep emails → follow-up emails.
- Human gates on every creative output: 3 options, pick the best.
- Built inside Airtable because that's where the team's systems already lived. Deliberately core infra, not skunkworks.
- Decomposition. Concept → script in one step didn't work. Concept → run-of-show → script did, because the run-of-show was the editable skeleton the model needed.
- Same pattern I now use across every pipeline: break big steps into smaller steps with human checkpoints.
- The 15-minute event format wasn't viable without it — the pipeline enabled a new business model, not just sped up the old one.
- BarometerXP acquired us largely for this — different domain, same pipeline.
- Evals from day one. This was 2023, before eval tooling had matured — I was catching drift manually with 3-option gates.
- Today I'd have failure-mode tests per output type: tech-note accuracy, tone consistency across the email sequence, script pacing against the run-of-show.
"Interviews aren't the research. The pipeline from interview to roadmap is."
Turns user interview transcripts into structured roadmap inputs — and keeps them there.
- Ingests transcripts (Whisper for audio, paste for existing).
- Extracts verbatim pain quotes, themes, surprises, and open questions.
- Cross-model review: GPT drafts, Claude critiques. Catches failure modes neither sees alone.
- Tags each insight to a feature in my Airtable roadmap.
- Surfaces "surprise" flags — anything off-pattern gets escalated before it gets clustered away.
- Reddit gives breadth (sampling at scale); interviews give depth (the six quotes that reframe the feature).
- Two shapes of the same discovery system — neither alone is enough.
- Extraction isn't the hard part. The hard part is resisting the urge to cluster away the contradictions.
- The best insight in an interview is almost always the thing I didn't have a category for yet.
"30 companies, 100+ GPTs. The fastest way to learn AI is to teach it."
AI training ran in parallel with Breakout — I worked with 30 companies on strategy, custom GPTs, and adoption. Also the fastest way I found to learn AI myself.
- 100+ GPTs and workflow automations across 30 companies.
- Hands-on training frameworks — 90% of participants applied skills immediately.
- Training was problem-first, calibrated to where people actually were (not where AI Twitter assumed they were).
- Prompt building blocks — context, reasoning, rules, examples.
- Chain-of-thought decomposition — same craft that made Breakout's content pipeline work.
- Multi-model cross-review — if I'm building in GPT, I have Claude critique the output.
- Every org has champions and naysayers. The move that works: let the naysayers be heard. They're usually right about a specific risk — acknowledge it, address it, and they become informed allies instead of blockers.
- People are much further behind than AI Twitter suggests. You can't lead AI adoption until you understand how far behind most people actually are.