From Zero to #1 Paid App

The Big Idea

In November 2024, while recording a Cursor tutorial, the author's girlfriend — not a programmer — said: "Instead of a screen flashlight, what about a fill-light colour card?" He had never heard the term, but instead of dismissing it he searched Xiaohongshu. Posts with hundreds of thousands of likes; people using solid-colour screens as selfie fill lights and asking for "an app to adjust colour and brightness" — but no good one existed. The demand was already validated; it just had not been turned into a product. Five minutes later he described the feature in Cursor; an hour later Kitty Light was live.

Why This Topic Matters

• AI has made "writing code" a non-bottleneck, so competition shifts to finding problems worth solving.
• For app work specifically, ~70% of the process is non-code (account, certificates, privacy policy, review).
• Viral success has a large luck component — the chapter is explicit about setting realistic expectations.

Core Concept: The Five Minutes of Judgment

Looking back, the critical thing was three judgments made in five minutes:

Step-by-Step: Using AI to Build an iOS App

Kitty Light was built with Cursor (late 2024). The chapter shows how it would look with Claude Code today.

Create the SwiftUI project

Create a blank iOS project in Xcode first — this step must be manual, since Xcode project initialization needs a GUI. Then launch Claude Code from inside the project directory:

This is a SwiftUI project. I want to build a fill-light app. Core features:
1. Full-screen solid color display, user can choose the color
2. Adjustable brightness (from 0 to maximum)
3. A few preset color cards (warm white, cool white, warm yellow, pink, etc.)
4. Clean interface - open and use immediately
Take a look at the project structure, then help me implement the core functionality.

Why this works well: the core tech is simple — a full-screen Color view with a colour picker and a brightness slider. Clear goal, clear technical path — the kind of task Claude handles well, and the first version usually runs right away.

Iteration is the real work

Every iteration follows the same loop: user feedback → describe the need in Claude Code → implement → test → ship. Example request:

Users are saying they want to see the camera preview while using the fill light.
Please add a feature: the top half of the screen shows a live camera feed,
the bottom half shows the fill-light color, with a draggable divider between them.

Claude integrates AVCaptureSession for camera support. This is technically complex (camera permissions, live preview, layout), but Claude handles it well because these are standard SwiftUI / AVFoundation patterns.

App Store Submission: Where Things Go Wrong

Writing code is only ~30% of the process. The other ~70% is everything about getting onto the App Store.

Common rejection reasons:

• Missing privacy policy page (required even if the app collects no data at all)
• Screenshots that don't match the actual functionality
• Use of private APIs
• Functionality too simple ("anything achievable via a website shouldn't be an app")

I already have an Apple Developer account. Help me walk through the complete steps
from development to App Store submission - including certificate setup,
provisioning profile creation, and Xcode build configuration.
List out each step with specific instructions and common pitfalls to watch for.

Claude gives a detailed checklist. It cannot operate Xcode's GUI, but it can tell you exactly what each option should be and why. Kitty Light passed on the first submission — clear functionality, clean interface, no grey areas; review took ~24 hours.

Real-World Story: Going Viral

In the first week the author posted a simple before-and-after comparison on Xiaohongshu. Then it exploded:

• Within three days: 1.18 million views, 73,000 likes; app downloads crossed 30,000.
• The Pro version (camera feature, ¥6) hit #1 on the App Store paid chart and stayed for over a month.

What Came Next: From Viral Hit to Product Line

The Pro version kept getting professional features. On the same technical foundation the author launched a mini-program version (no iOS device needed) and a HarmonyOS version (Huawei users), then Kitty Album for the same audience (selfie enthusiasts).

"An app built in one hour eventually grew into a small product line." In traditional development this would be nearly impossible — the code alone would take months. AI-assisted development compresses the cost of building to near zero, enabling rapid experimentation and iteration. (People's Daily called this the "hand-crafted economy"; on the CCTV interview the author built a working mini-product in 10 minutes on camera.)

Replicating This Process with Claude Code (six steps)

Claude Code is directly involved in steps 1, 2, 3, and 4. Steps 5 and 6 need you to operate Xcode and social platforms — but Claude can still help write the app description, prepare keywords, and analyze user feedback. The step-1 analysis prompt:

I want to build [your app idea]. Help me analyze:
1. How real is this need (how many people actually want this)
2. What competitors exist and how they're rated
3. What differentiation angles I could pursue
4. What the minimum viable product should include

Code Example: A CLAUDE.md for iOS Development

# iOS Project Rules
## Tech Stack
- SwiftUI (avoid UIKit unless SwiftUI can't handle it)
- Minimum deployment target: iOS 16
- Swift Package Manager for dependencies

## Architecture
- MVVM pattern
- Each View has a corresponding ViewModel
- Network requests go in a Service layer
- Persistence via SwiftData or UserDefaults

## Code Style
- File naming: UpperCamelCase (ContentView.swift)
- Variable naming: lowerCamelCase (isLoading)
- Max 200 lines per file - split if exceeded
- Comments in English

## Common Pitfalls
- Don't perform async operations inside a View's body
- Use @StateObject instead of @ObservedObject to own a ViewModel
- Device testing requires signing configured in Xcode first

Explaining it

Each section removes a class of mistake: Tech Stack fixes framework and target so Claude doesn't reach for UIKit; Architecture keeps generated code in a consistent MVVM shape; Code Style enforces naming and a 200-line file cap; Common Pitfalls encodes hard-won SwiftUI gotchas (async in body, @StateObject vs @ObservedObject). The result: less cleanup later.

Visual Mental Model: Where the Effort Goes

  IDEA
   │  5 minutes of judgment  ── spot need · validate · commit to MVP
   ▼
  BUILD (~1 hour / a few hours)   ← Claude Code does this fast
   │
   ▼
  SUBMIT + REVIEW (~70% of total effort)
   account · certificates · signing · privacy policy · screenshots
   │
   ▼
  ITERATE FOREVER   ← the real reason a product succeeds
   user feedback -> describe -> implement -> test -> ship  (repeat)

Important Comparisons

Common Beginner Mistakes

• Judging an idea by technical feasibility instead of real demand.
• Skipping the 3-minute validation search.
• Shipping a feature-bloated v1 instead of one clear feature.
• Underestimating the non-code 70% — account, certificates, privacy policy, review.
• No privacy policy page because "the app collects no data."
• Screenshots that don't match the actual functionality.
• Editing the viral post mid-distribution and disrupting the algorithm.
• Assuming a viral outcome is repeatable.
• Treating "it went viral" as the finish line instead of continuing to iterate.

Best Practices

• Listen to non-programmers — they speak users' real language.
• Validate demand by searching before you build (30 minutes).
• Use Plan mode to cut the MVP to one essential thing.
• Iterate on real feedback with the feedback → describe → implement → test → ship loop.
• Budget for the non-code 70%; ask Claude for a step-by-step submission checklist with pitfalls.
• Always include a privacy policy; keep screenshots honest; avoid private APIs.
• During a viral window, ship fixes fast but leave the distribution post alone.
• Put iOS rules in CLAUDE.md (SwiftUI, MVVM, naming, pitfalls) to reduce cleanup.
• Execute every step well; don't assume the outcome.

Interview / Revision Questions

1. What are the three judgments made in "five minutes"?
2. Why does the book say validating demand is worth three minutes?
3. What did Kitty Light's first version do — and not do?
4. Roughly what share of the app process is writing code?
5. Name four common App Store rejection reasons.
6. Which submission steps can Claude Code do, and which must you do yourself?
7. List the four factors behind the app going viral.
8. Why was the original Xiaohongshu post deliberately left untouched?
9. What is the "realistic expectation check" the chapter insists on?
10. What are the six steps to replicate the process, and which involve Claude Code directly?
11. Give two rules you'd put in an iOS CLAUDE.md and why.
12. What are the three non-technical factors that actually determine success?

Practice Exercises

Quick Memory Map

From Zero to #1 Paid App
│
├── 5 minutes of judgment
│   ├── listen to non-programmers (real user language)
│   ├── validate demand by SEARCHING (3 min)
│   └── commit to a one-feature MVP
│
├── Build with Claude Code
│   ├── Xcode project = manual (GUI)
│   ├── describe core features -> Claude writes SwiftUI
│   └── iterate: feedback -> describe -> implement -> test -> ship
│
├── Submission (~70% of the work, code is ~30%)
│   ├── dev account (Y688/yr, 1-2 days)
│   ├── certificates + provisioning + Xcode signing (counterintuitive)
│   └── review: privacy policy (always), honest screenshots, no private APIs
│
├── Viral = strong need + dead-simple product + controversy + fast iteration
│   (large luck component - don't assume the outcome)
│
├── 6 steps: validate / MVP / build / polish / submit / promote
│            Claude in steps 1-4 (+ copy, keywords, feedback analysis)
│
└── iOS CLAUDE.md: SwiftUI, MVVM, naming, 200-line cap, pitfalls
   3 non-technical factors: spot the need · exercise restraint · keep iterating

Complete Chapter Revision

1. The story's value is the judgment before and the iteration after, not the hour of coding.
2. Three five-minute judgments: don't dismiss non-programmers, validate demand by searching, commit to an MVP.
3. Kitty Light v1 = full-screen colour + brightness, nothing else.
4. Claude Code (or Cursor) writes the SwiftUI fast; iteration on real feedback is the real work.
5. Code is ~30% of the app process; the other ~70% is account, certificates, signing, privacy policy, and review.
6. Common rejections: no privacy policy, mismatched screenshots, private APIs, too-simple functionality.
7. Going viral came from a strong need, a dead-simple product, helpful controversy, and fast overnight iteration — plus real luck.
8. The hit grew into a product line (mini-program, HarmonyOS, Kitty Album) because AI made rebuilding cheap.
9. Replicate it in six steps; Claude Code helps directly with steps 1–4 and with copy/keywords/feedback.
10. An iOS CLAUDE.md (SwiftUI, MVVM, naming, pitfalls) reduces cleanup.
11. Success comes down to three non-technical factors: spot the need, exercise restraint, keep iterating.

Final Takeaway

This teaching edition is based on the supplied April 2026, 2nd edition of Claude Code: The Complete Guide (§13, "From Zero to #1 Paid App on the App Store"). Prices, review timelines, framework targets and platform details reflect that edition and may change over time.