# The 10-Step Launch Playbook > This isn't theory. It's the process I actually repeat: shipping three iOS apps to the App Store, > running a web service, and building AI products today. > **Claude is used at every step.** Each step includes the prompt I actually use. > > — Build Alone · buildalone.co --- ## The big picture ``` PHASE 1 Research 1. Market → 2. Revenue model → 3. Competitors → 4. Competitor teardown → 5. User complaints PHASE 2 Design 6. UX/UI design → 7. Handoff + lock stack, price, scope PHASE 3 Build 8. Build & deploy PHASE 4 Marketing 9. Competitor ad analysis → 10. Marketing plan ``` The core rule: **code doesn't appear until step 8.** Most products don't fail while being built. They fail because they didn't need to be built. Steps 1–5 protect you from that. Want Claude to walk you through it? Install the companion skill (`SKILL.md`) and say **start the launch playbook** in Claude Code. This document is the same process, laid out so you can read it first. --- ## PHASE 1 — Research (find out if it sells before you build it) ### 1. Market and niche research — Claude research When you get an idea, start with research, not code. Use Claude's research features (web search + deep research). ``` [Describe your idea in one paragraph] Research the market for this idea: 1. How many people actually have this problem (search volume, community size, market data) 2. How people solve it today (substitutes, including spreadsheets and manual work) 3. If we narrow to a niche, which segment is the most desperate 4. The case against: if there's a reason this won't work, what is it (be honest) Conclusion: is it worth building? If so, which niche first? ``` **Tip:** always include #4. AI is optimistic by default. You have to explicitly ask for the case against to get a balanced answer. ### 2. Revenue model research Some markets exist but don't pay. Decide how you'll make money before you build. ``` Research the revenue models that actually work in this market: 1. Pricing models in this category (subscription / credits / one-time / freemium) and actual price ranges 2. Pros and cons of each, based on how these customers actually pay 3. Public revenue data for similar products (Indie Hackers, public MRR, etc.) 4. For me to make $1,000/month: three scenarios of customers needed × price ``` ### 3. Competitor research ``` Find every competing product in this market (app stores, web, domestic and international): - For each: core features, price, launch date, number of reviews and rating - Split the ones doing well from the ones that aren't, and explain why for each - Put it in a feature comparison table ``` **Tip:** if there are no competitors, don't be happy. Be suspicious. It can mean there's no market. ### 4. Competitor teardown — Claude Code + browser This is where a builder's tools pay off. Use Claude Code's browser control to take a competing product apart. ``` [In Claude Code] Open competitor [URL] in the browser and: 1. Screenshot the main screens (landing, signup, core feature, payment) in order 2. Go through the onboarding flow and record what information each step asks for 3. Look at the network tab to see which APIs it calls and infer the backend (which services it uses, whether generation is sync or queued, where it charges) 4. Organize the screenshots and analysis in a competitors/[name]/ folder ``` **Tip:** the network tab reveals a company's technical choices: which AI model it uses, which payment system, how long responses take. Use that directly for cost estimates and stack decisions. Stay within public screens and your own normal account. No bypassing, no bulk scraping. ### 5. Collect user complaints — Reddit and communities Your competitors' complaints are your product's spec. ``` Collect user complaints about [competing product names] from Reddit, app store reviews and communities: 1. The top 10 recurring complaints, with direct quotes 2. How often and how strongly each comes up (one person's gripe, or everyone's) 3. Which are technically solvable and which are structurally unsolvable 4. Mark separately any complaint that sounds like "if only this were fixed, I'd switch" ``` --- ## PHASE 2 — Design ### 6. UX/UI design — Claude design Flip the step 5 complaint list and it becomes your design requirements. ``` Based on the research above, design this product's UI: - Structure it to directly solve the top 3 competitor complaints - Competitor screenshots to reference: [the folder saved in step 4] - Use fewer onboarding steps than [competitor] - In order: list of screens → a draft of each screen ``` ### 7. Handoff → lock stack, price and scope As you hand the design to Claude Code, pin down three things in a document before writing code. ``` Before we start building this design, create PLAN.md: 1. Tech stack: choices and reasons (drop anything that's overkill at this size) 2. Pricing model: reflect the step 2 research conclusion 3. Scope table: two columns, "Build now (MVP)" vs "Save for later (v1.1)". One line on why each deferred item is deferred. 4. Definition of done: "when this checklist is complete, we launch" ``` **Tip:** the scope table is the most important document in this playbook. AI will build anything you ask for, so if you don't decide what you *won't* build, you'll never launch. --- ## PHASE 3 — Build ### 8. Build & deploy — Claude Code With PLAN.md and CLAUDE.md (see the separate template), building becomes a continuous conversation. - Build one screen at a time → run it and look → fix. Repeat. - Start every session by checking "where are we against PLAN.md, and what's next" - Deploy with Claude Code too: web on Vercel/Railway, apps via build → TestFlight ``` Implement the next MVP item from the scope table: [item]. Done means: actually run it and [specific behavior] works. Commit when it's done. ``` --- ## PHASE 4 — Marketing ### 9. Competitor ad analysis — Meta Ad Library Once the product exists, start with the ads already proven in this market. The money is where ads keep running. ``` [Claude Code + browser] Research [competitors]' ads in the Meta Ad Library: 1. Every ad currently running: format (video / image / UGC), hook, CTA 2. The longest-running ads, by start date. Long-running means it makes money 3. Recently stopped ads: what they tried and dropped 4. Common patterns: which angles (price / time saved / fear / status) repeat ``` **Tip:** "the longest-running ad" is the key signal. No company keeps paying for an ad that doesn't perform for months. That ad's angle is the proven message in this market. ### 10. Marketing plan ``` Combine the ad analysis above with the step 5 complaint research into a first 90-day marketing plan: 1. Message: a proven angle × a complaint competitors can't solve = our hook 2. Channel priority: based on where these customers actually are, 3 or fewer 3. Content calendar: week by week, at a level I can actually execute 4. Two versions: a $0 plan and a $500/month plan ``` --- ## Finally - The point of this process is **order**, not speed. The temptation to do step 8 before step 1 shows up every time. - Save every step's output as a file (`research/`, `competitors/`, `PLAN.md`). You can hand them straight to Claude as context for the next step, and over time they become your own data. - Skipped steps always send the bill later. That's how I learned it. *Free from Build Alone at buildalone.co.*