ClipTips is a live video marketplace where you book a verified expert by the minute, ask your question on camera, and hear the answer in your own language in real time. A Spanish chef can take a session from a Japanese asker. A Queensland lawyer can answer a Mandarin-speaking small-business owner without either of them typing a word.
I started ClipTips in August 2025, paused for several months when other priorities took over, and picked it back up in April 2026. Part of why I paused was that the AI tooling I had at the time wasn’t where it needed to be - I’d hit a six-month ban dispute with the IDE I was using and didn’t feel comfortable rebuilding momentum on a complex project without the right tools to come back to. By the time I picked it back up, the toolchain had settled (more on that below).
I work on it whenever I’m not running kitchen operations. Yesterday I sat down at noon and walked away from the keyboard at 1:30am. That’s a normal day on a coding stretch. The build isn’t a sprint - it’s the steady accumulation of evenings, weekends, and the hours after the day job’s done.
What it is right now: 118 API routes, around 54,000 lines of TypeScript, a Postgres schema sitting at 20 tables, Stripe Connect, Stripe Identity, Clerk, live video via Jitsi (with backend hooks already in place to migrate to Daily.co), HeyGen for voice translation, an admin dashboard, a Knowledge Nexus 3D map, and a Knowledge Repository for published sessions.
Claude Code was my IDE for effectively all of it. I'm going to walk through what that actually looked like, because the conversations I keep having about AI-augmented building are either breathless or dismissive, and neither matches what it's like on the inside.
// ClipTips landing. 3D Knowledge Nexus renders live in the background.
Why ClipTips exists
I spent twenty years in professional kitchens. The best chefs I learned from weren't the ones with the fattest English vocabularies. Some of the most important cooking I picked up came from a Cantonese head chef at a venue where I was the only native English speaker, and from a Japanese pastry chef who communicated mostly through hands, pointing, and whatever kanji I could read off recipes. The knowledge was there. The language was the bottleneck.
Multiply that out across every profession. A Brazilian surgeon knows something a Portuguese-only speaker in Angola needs. A Korean textile dyer has answers a Turkish student would pay for. A Rajasthani stonemason's technique solves a problem an Italian heritage restorer is stuck on. These people exist right now. They are online right now. They cannot reach each other because the internet's default expectation is English.
AI translation has quietly gotten good enough to close that gap for live conversation. Voice cloning plus real-time transcription plus decent MT models is a mature enough pipeline in 2026 that you can have a natural-sounding dubbed session with a sub-second buffer. What wasn't built was the marketplace around that pipeline. Verification, payments, trust, bounty economics, matchmaking, dispute resolution. The dev-facing problem is trivially understood but expensive to actually ship. Nobody solo was going to do it three years ago.
In 2026, solo is the default shape for this kind of work.
// The end product. Browse Experts page with per-minute rates and verified credential badges.
The decision to go solo + Claude-assisted
I could have raised. I chose not to. Two reasons.
First, the surface area of the product is exactly the size of the surface area of my thinking on it. Every design decision in ClipTips has a reason that traces back to something I learned in hospitality or something I observed about how marketplaces actually work. Adding another founder or raising money means dilating that surface area to match the new input. For a product that depends on taste judgements about trust and verification and payout fairness, that dilation is a cost, not a benefit. At the seed stage, at least.
Second, AI-augmented solo development is not slower than a small team any more. It's different-faster. Where a two-person team might ship features in parallel but pay coordination tax, a solo with Claude Code ships sequentially but skips every single sync meeting, every PR review back-and-forth, every "wait, what did you mean by that" Slack thread. The tradeoff tips a certain way depending on the domain. For ClipTips, where the decision quality of each feature matters more than the raw count of features, solo tips the right way.
Claude Code specifically, as opposed to Cursor or Copilot or any of the adjacent tools, because its agent mode has enough autonomy to take a multi-step plan and execute against it without me babysitting every decision. The work happens; I review and adjust afterwards. That's not a productivity bump. That's a different shape of work.
The stack
Default picks for 2026 solo-shipped SaaS:
- Next.js 15 App Router, TypeScript throughout. Thin route wrappers over a well-designed Postgres schema.
- Supabase for Postgres + Realtime + Storage. Row Level Security everywhere. Supabase's SQL tooling cuts migration friction dramatically.
- Clerk for auth and session management. One of the few places I paid for a hosted SaaS instead of rolling it myself. Worth every cent for the time saved on edge cases.
- Stripe for top-ups, Stripe Connect Express for expert payouts, Stripe Identity for one-passport-one-account verification.
- Jitsi Meet External API for the live video rooms today. Loads at runtime, no SDK install, the iframe handles itself. Daily.co backend hooks (room creation, webhook handling) are already wired and the swap-over to Daily.co for the React component is queued. Mid-migration, deliberately.
- HeyGen for the voice clone + dubbing pipeline. Machine-translated subtitles run in parallel as a separate text layer.
- Resend for transactional email, called via raw REST since the SDK adds nothing useful for the few flows I have.
- Vercel for hosting + cron.
- Tailwind CSS 4 + Radix UI + Lucide for the design system. React Three Fiber for the Knowledge Nexus 3D map.
Nothing exotic. Modern tools used with intent. Every one of them has good documentation Claude Code can ingest and reason over. That last point is a selection criterion I only consciously noticed halfway through the build.
How the toolchain settled
→
→
→
→
// 2024-2025 toolchain progression. Greyed = tried + moved on. Highlighted = current.
The Claude Code part wasn’t day one. Here’s the actual sequence, because every "I built X with AI" article skips this and pretends the author landed on the right tools immediately.
Started in mid-2025 with ChatGPT 3.5. Good for ideating, useless for actually doing work in a codebase. Couldn’t reach files, couldn’t run commands, couldn’t hold context across a session.
Switched to Warp, the terminal-with-embedded-AI. Burned about $400 in credits across multiple side projects in 2025 and built out the early frameworks for ClipTips and a few other ideas. Worked well until I tried to scale to multiple agents under one team account and hit a terms-of-service dispute. Got banned for six months while we sorted it out. The ban was eventually lifted but I’d already moved on by then. That ban dispute is the main reason ClipTips paused - I didn’t want to come back to a complex codebase without an IDE I trusted.
Tried Wave next. Mixed results. The agent loop wasn’t tight enough.
Then ran an OpenClaw setup with thirteen agents through OpenRouter on free models, each scoped to a different part of the build. It produced output but the coordination overhead was bigger than the win. I deleted the whole rig and migrated the useful files into Claude.
Settled on Claude (Pro) by late 2025. Started at $20/month, immediately ran the credit allocation in three days, paid about $880 in overages over the next stretch in $5 and $10 increments before I bit the bullet and upgraded to the $169/month plan. That’s where I still am.
The criterion I didn’t have words for at the start but now do: an AI dev tool that can’t reach the live web, can’t install or use third-party tools, and can’t download skills on demand isn’t actually doing development work. It’s autocomplete with extra steps. Claude Code crossed the threshold because it can read external documentation in real time, reach into actual systems with the tooling I configure, and add new capabilities through the skills + MCP servers I install. Everything else I tried was either too sandboxed (couldn’t reach out) or too unwieldy (multi-agent overhead with no payoff).
What Claude Code accelerated hardest
The places where it was absurdly fast:
Boilerplate-heavy CRUD features. An admin dashboard with listing/detail/edit for a dozen entity types is something it'll produce in a single session if the schema is clean. My admin tool has views for users, credentials, Gold verification applications, tier management, session disputes, and expert suggestions. I would have hated writing those by hand. I didn't. Claude Code did, I reviewed, I tweaked copy and spacing, shipped.
Schema migrations. Give it the current SQL state and the desired end state and it'll write the migration, including the data backfill, including the rollback script. It doesn't forget to add the indexes. It doesn't skip the RLS policy updates. This is the work that most solo devs cut corners on because it's tedious. With Claude Code it's no longer tedious, so the corners don't get cut.
Route consistency. 118 API routes in a codebase will drift stylistically when written by a human over months. Claude Code maintains voice across hundreds of files. Every route returns its errors the same way. Every route validates its inputs in the same position. This matters later when something breaks and you need to reason about a route you haven't touched in months.
Integration glue. Wiring HeyGen translation jobs into Supabase storage rows into a session record that triggers a Jitsi room handoff on spec is the kind of task where the domain knowledge of each tool matters more than the code. Claude Code has read every piece of documentation for every mature tool in my stack. I don't have to context-switch to read their docs. I ask it to wire X into Y, and it does, and it knows where the edge cases live.
What it didn't help with
The places where I had to do the work myself:
Taste. Claude Code will produce a functionally correct landing page in ten minutes. That landing page will look like every other landing page that Claude Code has produced for every other founder this year. Making it feel like mine took me a full day of fiddling with typography, spacing, colour, and microcopy. The model can generate infinitely. Only I can tell it which of the generations actually lands.
Product decisions that depend on operator intuition. Should Scholar Experts earn Teaching Credits that stay on-platform, or should they just cash out like everyone else? Should the Gold Verification badge stay attached if an expert's re-application is rejected? Should we show CLIP token prices in local currency, and if so, should we convert at spot rate or a stickier cached rate? Those decisions needed me, holding the product in my head, thinking about what the asker feels when they see each of these paths.
Hard bugs in live traffic. Webhook retry loops, race conditions that only show up under load, things that look fine in test mode and only break when the real Stripe live API does something subtly different. Diagnosing those means manually running event triggers, bisecting commit history, reading provider logs, and building a hypothesis from incomplete evidence. Claude Code couldn't see the live production system. It can speculate. It can't watch.
Judgement calls under time pressure. Things that look like bugs might be misconfiguration. Things that look like misconfiguration might be the provider being down. A model can help triage but the final call about whether to rollback, hotfix, or sit tight is human.
The three problems I'm proudest of solving
The translation pipeline
Live dubbing has three failure modes and any one of them burns the session. The voice clone can drift, especially on unusual names or technical vocabulary. The machine translation can miss technical context (kitchen, legal, medical, trades - every domain has terms that look ordinary in English but mean something specific in context). The synchronisation between speaker lip movement and dubbed audio can get out of sync enough that people disengage.
My fix: run the voice and text layers independently, with a small intentional buffer delay on the audio side. Subtitles land immediately so the asker gets the literal translation, and dubbed audio comes in slightly behind with a matched voice clone. Post-session, the final artefact is re-generated from the complete transcript with higher-quality translation and re-dubbed cleanly, replacing the live version in the session record. The asker sees live translation that's good-enough to have the conversation, and gets the higher-quality recording to reference afterwards.
// Voice layer and text layer run in parallel, with a small buffer so the dubbed audio catches up cleanly.
Webhook idempotency
Every marketplace eventually hits the problem where a webhook handler gets called twice for the same event, and if you're not careful, you credit the wallet twice or deduct the fee twice. The typical fix is a "processed events" table with a unique constraint. I got aggressive and put the unique constraint on the business record directly. The transactions table has a unique index on stripe_payment_intent_id. The attempt to insert a second transaction row for the same payment intent fails with a 23505 constraint violation. We catch that and return 200 to Stripe as idempotent-success. The wallet credit only runs after the transaction row commits. Double-fires become no-ops at the database level, not at the application level.
Writing this felt trivial once I'd thought of it. Every marketplace I've looked at since has solved the same problem in a messier way.
Gold Verification state machine
The deeper-tier verification flow has six valid states (pending_payment, paid_pending_review, in_review, approved, rejected, refunded) and about ten invalid transitions. Getting this right meant that a rejected application couldn't revoke a previously-approved badge. Meant that a pending application couldn't be approved before payment confirmation. Meant that admins claiming a review couldn't accidentally step on each other.
I modelled the whole thing in SQL with a CHECK constraint on valid status values and conditional updates that only fire from specific prior states. The TypeScript layer validates intent. The database enforces reality. Belt and braces. The state machine has held up cleanly in test-mode end-to-end runs; the real test is when the first paying Expert hits it.
The honest time and cost accounting
Tooling spend across the build is real but a clean ClipTips-specific number doesn’t make sense. I’ve been on a rolling AI-tooling experiment since 2025 - ChatGPT credits, Warp subscriptions and overages, Wave trials, OpenRouter testing pools, Claude subscriptions and overage charges, domain registrations, hosting renewals - and they bleed across multiple projects. ClipTips is one of several frameworks I’m building out from the same set of tools.
The relevant comparison is the alternative. Hiring a small team to ship this scope over the same elapsed timeline would have cost somewhere north of six figures in salary alone. The total tool spend across all my projects, however much it actually was, is what let one person hold a complete product in their head and ship it.
The hours are the harder part to count. I run kitchen operations during the day. The coding fits around that. I’m not less busy than I was before this project started - I’m doing more with the same hours, which is what people mean when they talk about AI-augmented solo dev, even if they don’t usually frame it that way.
What I would do differently
Two things, looking back honestly:
Test coverage earlier. I wrote tests reactively whenever a bug scared me, not proactively for the critical-path flows. Wallet, session booking, and Connect onboarding each have enough edge cases that they should have had test coverage from day one, not retrofitted later when something went sideways.
Real user feedback earlier. I built the whole platform end-to-end before putting it in front of any asker or expert outside of myself. The next product will not get to that stage of completion before someone unrelated to me has clicked through the core flow. The amount of design work that survives contact with a real user is always less than you think.
Both points generalise to the same lesson. Claude Code is biased toward producing clean, complete-feeling code. It will happily spend hours making something elegant when the elegance isn't what the product needs yet. Knowing when to push back on the model's default instinct - tell it to ship dirty, tell it to mock something out, tell it the test isn't worth writing yet - is its own skill, and one I'm still learning.
What this says about solo builders in 2026
Every era of software development has a dominant unit of production. In the 1980s it was the lone hacker. In the 2000s it was the two-to-three-person startup team. In the 2010s it was the tightly-aligned engineering org of ten to fifty. In 2026 the dominant unit is the solo builder with an agent.
That's not a prediction. That's just where the cost curves crossed. The friction of coordination is still real. The friction of using a capable model as your IDE is effectively zero. When coordination is more expensive than model usage, you pick the model. For most product categories, we're past that crossover.
What it rewards is a specific profile. Operators who have felt a problem viscerally. People who can write well enough to direct a model precisely. People with enough taste to reject 80% of what the model produces. People patient enough to hold a full product in their head across a long build. Hospitality trained me for three of those four by accident. The writing I learned from running sites like this one.
// The Knowledge Nexus. 141 domains seeded, live session activity per sphere.
ClipTips is the first thing I've shipped where I felt the full speed of this mode. It won't be the last. And I suspect over the next eighteen months we'll see a lot more solo-built platforms of the same shape show up in categories that historically needed teams of ten to launch.
If you're an operator sitting on a problem and wondering whether you can ship the solution yourself in 2026, the answer is almost certainly yes. The tooling is there. The model is good enough. The only real question is whether you're willing to do the hours.
What's queued after ClipTips
Two builds I started in 2025 and parked, both due for the rebuild treatment now that the toolchain’s right. Neither is what you’d guess from the names.
ReportBot.AI-OS is AI-powered cleaning inspection. A cleaner shows up to a property, scans a QR code, films before and after, and the system runs the footage through a YOLOv8 pipeline that detects dust, stains, debris, and structural issues, then scores cleanliness against the property’s standard. The full system is multi-tenant: admin, property manager, supervisor, and cleaner all see different views, with QR-code-bound property assignments, performance metrics, and supervisor approve/reject flows on every report. End of dispute. Provable quality. The cleaning industry runs on disputes; this kills them.
I built the first cut in 2025 with a real client chosen and an interactive mockup in their hands. Multi-port FastAPI architecture, real role-based auth, working YOLOv8 inference, the lot. Couldn’t ship the full scope at the time - vision API costs were too high per inspection and the comparison models weren’t reliable enough for a tool whose entire job is to be objectively right about whether a job was done properly. Paused deliberately: compute prices needed to drop and the video-comparison tech needed to mature past hobby-grade. Both have happened in the last six months. The numbers work now and the accuracy clears the bar where a cleaning company would actually trust the call.
The rebuild moves the platform onto the same Next.js + Supabase stack ClipTips uses, with a mobile-first capture flow that doesn’t make a cleaner fight a desktop UI on their phone. Cleaning industry is enormous. Disputes are constant. Nobody’s solving it with computer vision yet.
ChefBot.AI-OS is the bigger of the two, and it’s the actual reason ClipTips had to come first. The central innovation is a Dynamic Digital Recipe Card (DDRC) that combines an AI-assisted input flow, a video-synced step timeline, automated multi-language translation of every recipe and training video, regional cost adaptation, and chef-attribution so the person who created the recipe is credited and traceable across whichever kitchen ends up using it.
The recipe-card half is already real and battle-tested. Currently a Google Sheets monster - templates, formulas, cross-sheet automation - that turns a recipe input into a costed, standardised, supplier-mapped card with prep times, labour cost, packaging cost, retail price, and CCPs. Every kitchen I’ve worked in had some version of this on a clipboard or in a beat-up Excel file. The Sheets version proved the concept enough to scope the full platform. The rebuild moves it into a proper web app + PWA where a head chef adds a recipe once and it ripples through stock orders, costings, multilingual training docs, the menu page, and the regional-cost adapter so a recipe priced for a Brisbane kitchen automatically reprices for a Singapore one.
The translation half is what ClipTips paid for. ChefBot needs to translate every recipe card AND every kitchen training video - a Cantonese head chef demos a knife cut once, gets it dubbed into Vietnamese for the new prep cook and Spanish for the line cook by the next shift, with subtitles in whatever language the trainee reads. That’s the exact pipeline ClipTips just built: voice cloning, sub-second buffered dubbing, parallel subtitle layer, post-session re-rendered final artefact. Build it once for live conversations under real-session load on ClipTips, harden it, then port the same engine into ChefBot for asynchronous training content + recipe localisation. Every kitchen I’ve worked in had a version of this exact problem. Nobody’s solving it.
Both rebuilds are getting the same treatment ClipTips just got: thin Next.js routes over a clean Postgres schema, RLS everywhere, Stripe Connect for whichever payouts apply, the translation engine ClipTips just hardened, and the same Claude Code workflow that lets one person hold each product in their head.
ClipTips is live at cliptips-mvp.vercel.app. The full project writeup is on streamables.live/projects/cliptips.html if you want the feature-level breakdown.