How Marc Lou ships a new product every month with Claude, Cursor, and v0
Why this story matters
The typical bootstrapper story goes: years of nights and weekends, slow traction, a lucky SEO hit, eventually profitability. Marc Lou rewrote that script. He's launched over two dozen products in roughly two years, with several generating meaningful revenue, and he's done it while working fewer hours than most people spend in meetings.
The reason is not that he's faster than other developers. It's that he treats AI tools as a full-time cofounder — not a code autocomplete, not a search engine, but a partner that handles the slow parts so he can focus on the one thing that's hard to automate: deciding what to build next.
The stack before AI
Marc's pre-AI workflow looked like most solo founders': write code in VS Code, Google everything, spend a day on UI for every half-day on logic. ShipFast started as a personal time-saver — a Next.js boilerplate with auth, payments, and email pre-wired so he didn't have to repeat that setup on every new project.
It worked well enough. When he open-sourced ShipFast as a paid product, developers bought it immediately. By early 2024 the business was profitable. But the per-product timeline was still measured in weeks, and Marc wanted to measure it in days.
The shift happened when he moved from using AI as a search tool to using it as a thinking partner.
How Claude enters the workflow
Marc's process starts before a single line of code is written. When he spots a potential product, he opens a Claude conversation and describes the idea in plain language: who it's for, what problem it solves, what the minimal useful version looks like. Claude's job at this stage is to push back — to find the holes in the reasoning, suggest the one feature that matters most, and flag the obvious failure modes.
This isn't prompting in the usual sense. He describes it as "thinking out loud with someone who's read everything." The output is a short spec: three to five sentences about what the product does, a bulleted list of what's in scope, and a list of what's explicitly out of scope for v1.
That spec goes directly into Cursor.
Cursor agent mode: from spec to scaffold in an hour
Marc's use of Cursor has evolved past tab-complete. He pastes the spec into Cursor's agent mode with a single instruction: "Build this using my ShipFast base. Start with the data model, then the API routes, then the UI." The agent writes the first pass, he reviews and corrects it, it iterates.
He describes the interaction as code review rather than code writing. He's not generating code to paste in; he's approving or rejecting what the agent produces and steering it when it goes sideways. A session that produces a working API takes forty minutes, not four hours.
Two things make this work:
-
ShipFast as context. The boilerplate gives the agent a known starting point. It knows the auth setup, the database schema conventions, the API route structure. The agent doesn't have to guess.
-
Small scope. Each product Marc ships solves one problem. A focused spec produces fewer agent mistakes than a sprawling one.
v0 for the UI layer
The part of building that Marc most wanted to automate was UI. Writing Tailwind classes by hand is tedious, and he found early AI assistants produced mediocre component code that he'd spend as long cleaning up as writing from scratch.
v0 changed that. His current process: describe the page or component in a sentence, generate the first draft with v0, copy it into the project, and adjust colors and spacing to match his branding. A page that would take two hours of Tailwind work takes twenty minutes.
He's not precious about the output looking generic — the products are priced for speed, not for design awards. What matters is that the UI is clean enough to convert and doesn't need to be rebuilt after launch.
The full launch checklist in Notion
Every product gets a single Notion document. The top section is the spec from the Claude conversation. Below it is a standard checklist that Marc has refined over two dozen launches:
- Stripe integration live and tested
- Email sequence written (Claude writes the first draft)
- Landing page copy finished (Claude writes the first draft, he edits)
- SEO title and description set
- Analytics event fired on first conversion
- Twitter/X launch thread scheduled (Postiz, in recent launches)
The checklist is not sophisticated. Its power is that it's the same every time, which means he never ships without checking something obvious, and he doesn't waste mental energy deciding what "done" looks like.
The economics of shipping fast
Marc is transparent about the math. Most products he ships don't make meaningful money. Some do well for a few months and then plateau. A small number — ShipFast being the clearest example — compound.
The reason to ship fast isn't that every product will succeed. It's that the cost of a failed product is measured in days, not months. He can run ten experiments in the time it would take a normal team to ship one, which means his expected value per quarter is higher even if his hit rate is low.
He's also been explicit about what AI didn't change: picking the right problem still requires judgment, distribution still requires showing up consistently, and customer support still requires patience. The tools compress the build; they don't compress the thinking.
What to take from this
Three things generalize cleanly from Marc's workflow:
Use AI for the slow, repeatable parts. Every product needs a data model, API routes, a landing page, email copy, SEO metadata. These are well-understood patterns that AI handles well. Reserve your own time for the decisions that require taste and judgment.
Build a base layer. ShipFast gives Marc a known starting point that AI agents can reason about. If you don't have a boilerplate, building one — even a minimal one — pays back the time investment on the second or third project.
Measure in days, not quality scores. "It's good enough to launch" is a complete sentence. Marc's standard is: does this solve the problem, does the payment flow work, and is the UI not embarrassing. If yes, it ships.
The companion tutorial
The tutorial on this site — building an automated changelog generator from Git commits with Claude — uses the same principles in a concrete, copy-pasteable format. If you want to see the pattern in code rather than strategy, start there.