This is how I build now. Claude Code does most of the heavy lifting, GitHub keeps the history, Netlify puts every change in front of people before it goes live, and a small local model stack on my desk picks up the overnight work.
Twenty years at Prudential, Northwell and now Google taught me the bottleneck is rarely the idea. It's the distance between a clear decision and something real people can click on.
A year ago, closing that distance meant prompting a chat window and pasting code around. Now it's a system. Every project lives in a GitHub repo with a CLAUDE.md that tells Claude Code how the project works, what the brand rules are and what not to touch. Every change goes up as a pull request, Netlify turns it into a preview link, and nothing reaches production until I've looked at it.
I lean on the cloud models for judgment calls, like planning a change or reviewing one. The routine work goes to a local stack of Ollama, Open WebUI and Qwen models, a lot of it on a timer overnight. Below is how that's played out on a fitness app, a coaching business, two startup advisory gigs and the client work that got me started.
CLAUDE.md files hold the project rules, brand tokens and deploy conventions, so a new session picks up where the last one stopped. Brand systems live as reusable skills. When I updated the DN Creative branding skill with a new topo generator, one session audited this whole site against it, swapped the headers on 13 pages, previewed the result on Netlify and shipped it the same afternoon.
The Figma MCP connects Claude Code straight to my files. I rough out a direction, point Claude at the frame, and it picks up the layout, variables and components from the file itself rather than guessing from a screenshot. It works in reverse too: built pages go back into Figma when a client wants to mark something up by hand.
I split work across purpose-built agents. Research agents dig through docs, competitors and my own Notion notes and come back with sourced summaries. Testing agents load every page in a headless browser at desktop and phone widths, check for errors and take screenshots before anything gets pushed. The main session stays focused on building.
A Mac mini with 48GB of memory runs Ollama with Qwen 3.6 as the default worker and a small Gemma model for quick triage, with Open WebUI on top for chatting with documents. Claude breaks work into tight specs, the local model builds, Claude reviews the diff. Longer jobs like drafting PDFs, assembling decks and summarizing a week of notes run as scheduled jobs with no per-token cost.
A personal app, a coaching business I built from scratch, two startup advisory engagements, and the enterprise work that got all of this started.
My own training and nutrition tracker, built because nothing out there logged food the way I actually eat. You talk to it. Snap a photo of lunch, or dump the whole day's meals into the chat at night, and the model identifies the food, sorts it by meal and does the macro math.
Workouts show up as a Monday to Sunday grid of icons: a barbell, a sneaker, a bike, and a ninja for martial arts. The weekly summary exports as a Markdown file I can hand straight to my coach. Next up is multi-user login and public progress pages. Bill McGlone has already asked to beta it as a possible white-label tier for Reboot Camp.
Bill McGlone had a finished manuscript and a coaching idea for men rebuilding after 40. I built the rest: the brand, the Blueprint design system, rebootcampcoaching.com, a Beehiiv newsletter funnel, and a publishing pipeline where one HTML file becomes a print-ready PDF, an EPUB and a web reader with a single command.
The site keeps growing through plain-language execution docs that Claude Code reads straight out of the repo. Every change goes out as a Netlify deploy preview first.
A pre-seed geopolitical intelligence platform for prediction-market traders. Instead of sending decks, I built the team a private design hub on Netlify: every finding tagged by priority, design directions, composite mockups and a clickable prototype, all in one place the team kept coming back to.
One round landed 29 findings and 9 design directions. The handoff was AI-ready on purpose, so their engineers could keep going without me in the room.
An AI-driven enterprise transformation platform with a lot of moving parts. My job as design and product-surface advisor is making those parts readable to a COO in 90 seconds.
Same hub model: a DN Creative branded audit site on Netlify with findings tagged by priority, effort and confidence, plus a design system and a four-variant logo system in round one. The new logo lockup was live on their site within two weeks.
An ongoing partnership with one of the country's most active open-air retail operators. I built a design system where none existed, then used it for a full thought leadership campaign: landing page, executive whitepaper, decks, data visualization and social, all in one visual language.
The loop that made it work: pages built in Claude Code as hi-fi wireframes, pulled into Figma for client review, then rebuilt as production components for WordPress.
Sole UX lead on a Bloomberg Philanthropies accelerator portal. No brief, no brand guide, no design team. I built a 40+ component design system from first principles and handed a developer-ready Figma package and React component library to the WordPress build team.
Presented to Bloomberg Philanthropies senior leadership and approved at the VP level. Live on schedule.
Every build starts messy. A note in Notion, a rough frame in Figma, a screenshot of something that works somewhere else, a half-formed idea on the train. The job at this stage is getting all of it in front of the model with enough structure that it can't misread the intent.
The Figma MCP changed this stage more than anything else. Claude Code reads frames, auto-layout, variables and components straight from the file, so a ten-minute sketch turns into an input with actual spacing and tokens in it. Notes go in as plain-language specs: what it should do, who it's for, and what it can never be.
The feature list lives in a Notion page written the way I'd explain it to a friend. Each macro gets its own color, and the title matches its graph. The food log breaks out by breakfast, lunch, dinner and snacks, with edit, delete and favorite on every item. An end-of-day dump lets me paste a whole day into the chat and choose whether it gets logged by meal or as one total.
That page is the brief. Claude Code works from it directly.
The inputs were the live beta, the founder's original no-code prototype, the brand file in Figma and a batch of beta-user quotes. All of it went into round one. The first audit hub went live the same evening the answers to my clarifying questions came back.
No formal brief, just a program manager and a set of working sessions. Those conversations got synthesized into a written IA that became the nav system and the persistent phase architecture at the center of the dashboard.
Research used to eat the first week of any engagement. Now I hand it to agents built for it. A research agent gets a narrow question and a list of sources, including my Notion workspace, Google Drive and the client's live product, and comes back with a summary that says where every claim came from.
Speed is nice, but the bigger payoff is walking into the first working session already knowing who the players are and what's been tried, so we spend the hour deciding things. I still read the sources behind anything that matters. If a fact on a client deliverable is wrong, that's on me, not the agent.
Pyndara has a lot going on: scenario generation, a forensic audit trail, role-based dashboards, a copilot on every tab. Research pre-reads mapped the surface before each walkthrough, so the sessions went straight to what a buyer actually sees and where they get lost.
Before a homepage routing decision, research pulled two proto-personas out of the hub's existing B2B and B2C user research and ranked four candidate routing directions by build cost. The team walked into the call with options on the table, not a blank page.
This page was researched the same way. Before I wrote anything, the facts came out of my Notion engagement pages, my local LLM setup notes and the Reboot Camp repo plan.
Loose specs make bad code, whether a person or a model is writing it. So every build starts in plan mode. Claude Code reads the repo, proposes the change and lists the files it will touch, and I push back before anything gets written.
The plan sits on top of standing context. Each repo has a CLAUDE.md with the project's rules. Brand systems are packaged as skills, so the DN Creative palette, type scale, motion easing and topo generator come along automatically. Nobody has to remember that we never use pure white, or that each surface gets one orange focal point. It's written down, and the model reads it every time.
When Bill asked for newsletter, podcast and Spotify pages, the plan got written as an execution doc for Claude Code: the target folder structure, a ten-step checklist, the riskiest step called out (every relative image path in the site), and a rule that the full deploy preview gets tested before anything merges.
Reading the repo first also turned up a nice surprise: the stylesheet already had an unused "coming soon" nav style, which was exactly what the podcast page needed until episodes went live.
The DN Creative branding skill carries the topo generator, the color tokens and the header rules. Pointed at this site, one session found every outdated header, flagged a duplicate topo that broke the one-per-layout rule, and planned the swap across 13 pages before touching a file.
Claude Code handles the build work that needs judgment: architecture, tricky interactions, anything where a wrong structure costs more than a wrong line. It works in the repo the way a good senior engineer does, reading before it writes.
The repetitive work goes local. Claude breaks it into tightly scoped units, a Qwen model on Ollama implements each one, and Claude reviews the diff and sends back specific fixes until it passes. Boilerplate, scaffolding and simple refactors cost nothing per token.
The one rule: if the spec is loose, keep it in the cloud. A local model that gets the structure wrong burns more review time than it saves.
Hekbot is a PWA on Supabase, with the Anthropic API behind the food recognition and the coaching feedback. Each item on the feature list gets its own scoped session and its own commit: the macro rings, the meal-grouped food log, the weekly training grid, the Markdown export. Each piece gets reviewed before the next one starts.
The whole book lives in a single HTML file. A Python pipeline renders it with WeasyPrint for a print-ready PDF and ebooklib for an EPUB, and the same source powers the web reader on the site. Edit a paragraph once, run python generate.py, and every format updates.
The campaign landing page was built in Claude Code as a fully styled, responsive page before the approval conversation ever happened. The client reviewed a live URL instead of grey boxes, and the answer was "ship it," not "now go build the real thing."
Of everything I've set up this year, this loop gets used the most. It decides which model handles which job, so the expensive one only gets called when judgment actually matters.
Claude Code breaks the task into tightly scoped units in plan mode. A Qwen model running on the Mac mini implements each unit against its spec. Claude reviews the diff, runs the checks and sends back specific corrections instead of a full re-plan. The loop repeats until Claude signs off, then it ships the normal way: pull request, deploy preview, merge.
Testing starts before the first push, not after launch. A testing agent spins the site up locally, loads every page in a headless browser at desktop and phone widths, checks for script errors, confirms things actually initialized, and saves screenshots I can scan in seconds.
I still look at everything myself. The agent just means my review time goes to design decisions instead of hunting for a broken script tag. If there's something it can't check in a headless browser, it tells me, and I go look.
Before the topo update shipped, a test pass loaded all 13 pages at 1440px and 390px, confirmed the generator started on every one, and found no script errors. It also named the one thing it couldn't check: the headless browser can't play the homepage video. So I checked that one myself, on the preview.
Testing the design hub before a round went out turned up a real bug: finding cards had always cut their summaries off at two lines with no way to read the rest. It affected every finding from the first round too. Each card got a working "Read more" before the client saw it.
Every change goes up as a pull request, and Netlify turns every pull request into its own live preview URL. That link is the review surface. Clients open it on their phone, stakeholders react to the real thing, and I compare it against production side by side.
The record keeps itself, too. GitHub holds every decision as a commit with a reason attached, and each PR says what changed and what to check. When someone asks in three months why a header looks the way it does, the answer is one click away.
The topo update went up as a draft PR. Netlify had a preview live within a minute. I looked it over, said "deploy to prod," and the merge to main shipped it. Adding Google to the employer ticker an hour later skipped the preview on purpose. It was a small change, and not every change needs the full routine.
The Reboot Camp restructure moved nearly every file and rewrote every image path. The plan made the Netlify deploy preview a hard gate: nothing merges until the preview shows no broken images and no missing assets.
The design went to Bloomberg Philanthropies senior leadership after a full review round with annotations and a Loom walkthrough, and it passed without structural changes. The tools have changed since then, but the idea hasn't: get the real thing and the reasoning to reviewers before they're in the room.
"LOOKS AWESOME!! Thank you! I am presenting these to BP on Friday. Wish me luck!!" Dave Ebert, Principal Consultant · Lapine Group
Shipping means one of two things. For my own work and studio clients, it's a merge to main and Netlify deploys production in minutes, with the previous version one click away if anything looks wrong.
For startups with their own engineers, shipping means a handoff they can keep running without me. Early-stage teams rarely have a designer, so my deliverables are AI-ready by default: a design.md with the rules, a tokens.json their code can import, and a Claude Code skill so their own AI tools build on-brand. Unlike a PDF spec, it doesn't go stale, because their tools read it on every run.
A design.md, a machine-readable tokens.json, a Claude Code skill, and built reference fixes for 20 of the 29 findings. A working prototype covered the profile roster, a full profile subpage and all six Situation Rooms, so engineering could see the target instead of reading about it.
Pyndara builds with its own AI pipeline, so my specs are the handoff. The client-facing site's design system, hierarchy and conversion architecture get written as specs their pipeline builds against. The clearer the spec, the less gets lost on the way to production.
An annotated Figma file, token JSON for Token Studio, and a production React component library, kept in sync with the Figma source for the whole engagement. Go-live April 30, 2026, on schedule.
Some work doesn't need me watching. The Mac mini stays on around the clock, and scheduled jobs hand the longer tasks to the local models: first-draft PDFs built from notes and templates, decks assembled from an outline, a week of engagement notes boiled down into a status update.
Open WebUI covers the interactive side, so I can chat with a folder of client documents without sending any of it to a cloud API. And because it all runs locally, a job that runs every night costs the same as one that runs once: nothing per token.
In the morning, Claude reviews what the night produced. Nothing it drafts goes to a client until I've been through it too.
A Mac mini with an M5 Pro and 48GB of unified memory, reachable from my laptop and iPad anywhere. Ollama runs natively, not in Docker, because Docker on a Mac can't reach the GPU. Qwen 3.6 35B-A3B is the default worker: a mixture-of-experts model that stays quick and handles tool calls well. The 27B dense version steps in for harder edits, and a small Gemma model takes titles, summaries and triage.
Hekbot calls the Anthropic API today. As more people use it, the plan is to move routine work like meal sorting and weekly summaries onto the local stack and save cloud calls for the moments that need them. Same pattern as my own workflow, applied to a product's running costs.
Next on the list: Bill emails new podcast episode links with a consistent subject line, an automation spots them, and the podcast page updates on its own. Bill never has to log in anywhere or wait on me.
A personal product, a client business, two startups and enterprise client work, all built by one person using the same pipeline.
A weekend feature on Hekbot and a multi-month enterprise portal move through the same stages. The tools decide how fast it goes. The stages keep me from skipping steps.
Fractional UX leadership or full-service design work. Either way, you get 20+ years of enterprise judgment, built at the speed this stack makes possible.