DEV Community

Cover image for Starting a mobile app with Claude Code or Cursor: why start from a kit, not a blank project
Dave Kurian
Dave Kurian

Posted on Originally published at otf-kit.dev

Starting a mobile app with Claude Code or Cursor: why start from a kit, not a blank project

An AI coding agent is only as good as the project it opens. Ask Claude Code or Cursor to build a mobile app in an empty create-expo-app folder and you get one of two results. Sometimes the first screen works in one prompt. More often the agent invents its own styling pattern, installs a second date picker, and leaves you with code you cannot explain a week later.

The model is rarely the cause. The cause is that an empty project gives the agent no conventions to follow, so it makes every decision fresh, and it makes them differently on each prompt.

This post covers what a starting kit changes, what the agent needs written down before it writes any code, and where a kit still does not help.

What goes wrong on a blank project

Four failure modes show up again and again:

  • No conventions. The agent picks a styling approach per file. One screen uses inline styles, the next uses a stylesheet object.
  • Nothing to reuse. Each screen gets its own button and card. The tenth screen looks nothing like the first.
  • Dependency drift. Every new feature is a reason to install a package. Two icon libraries and two date pickers are common after a weekend.
  • Dark mode last. Theme support added at the end means the agent has to touch every file.

None of these is hard to fix alone. Together they turn a weekend prototype into a cleanup job.

What a kit gives the agent

A kit gives the agent three things it cannot get from a prompt.

A phone with a booking calendar beside a code editor, editorial dark illustration with no readable text.

  1. Working examples of every pattern. When every screen uses the same header, the same card and the same navigation call, the agent copies that pattern instead of inventing one.
  2. Components that already exist. A request for a settings screen should find the row, toggle and section components in the folder and use them.
  3. A written contract. A project instruction file says how the codebase works and what the rules are.

The third item is the multiplier. Claude Code reads a CLAUDE.md file from the project root at the start of each session, and the Claude Code memory documentation (read 16 Nov 2026) describes it as the place for persistent project instructions. Cursor reads its own rules file. A competitor's template post makes the same point with a CLAUDE.md of about 300 lines that states the stack, the versions and what is deliberately not included.

What the file should say

A useful instruction file is short and specific. Our booking kit's CLAUDE.md covers:

  • The stack, with versions. Expo SDK 58 with Expo Router, Supabase for Postgres, auth and storage, and a Hono server for the work the client must never do, such as Stripe checkout. A new model is less likely to guess an old API when the version is written down.
  • One rule per concern. Never hardcode hex colours outside lib/theme.ts. Toggles are always the SDK's OtfSwitch, never the raw React Native one. External links open through one helper, not Linking.openURL.
  • What not to add. The file ends with an out-of-scope list: SMS reminders, push notifications, recurring bookings and staff scheduling are named as not in the kit. Stating what is out of scope stops the agent from pulling in a payments SDK or a notification library for a demo feature.
  • Where the hard guarantees live. Double-booking is prevented by a database exclusion constraint, and the file says so: "never trust the app to police this". An agent that knows the rule lives in the database will not rebuild it in a screen.
  • Verification steps. The file's last rule is to never ship without bun run typecheck passing. An agent that knows how to check its own work fixes more of it before you see it.

The booking kit's file is written for the agent, not for a reader. That is the point. It is the same contract a new engineer would need on day one.

What the file changes in practice

A list of rules is easy to nod at. It is more useful to look at four places where a line in the file changes what an agent does next.

It says which side of the line a feature belongs on. The booking kit reads and writes almost all of its data straight from the app to Supabase, with row level security as the boundary. Only privileged work goes through the Hono server: the checkout route that creates the Stripe session, the Stripe webhook, the reminder job that emails clients 24 hours ahead, and the provider admin routes. The file calls this the most important architectural rule in the kit. Ask an agent to add a cancellation fee and it already knows that anything touching payments belongs on the server side, and that a booking list belongs in a client-side query.

It shows the copy-this-file pattern. For data hooks, the file tells the agent to copy hooks/useBookings.ts for a new read and hooks/useCancelBooking.ts for an optimistic write. It also flags one detail, the enabled: !!userId guard, as critical: without it a query fires before the session has resolved. An agent that has not seen that line can write a hook that looks right and fires too early. One that has seen it copies the guard.

It records a failure so the agent does not have to find it. The environment table notes that routes using auth: 'user', which includes checkout and admin, need SUPABASE_JWKS_URL, because new Supabase projects sign tokens with ES256 and the server must verify them. If the variable is missing, the server returns 401 with "Invalid credentials". An agent debugging a 401 on checkout can find the cause in the file instead of guessing at token handling.

It points to task recipes. The file links to an ai/prompts folder of 20+ tested prompts, with examples such as adding a service, editing availability and changing the theme colours. The recipes are written against the real file layout, so the agent starts from the kit's own names rather than generic ones.

None of this is clever. It is the information you would otherwise type into the first prompt, saved once so every session starts with it. The reliable part is the repetition: the fifth session follows the same rules as the first because the file does not forget between sessions.

Where a kit does not help

A kit is a starting point, not a finished app. Three things still fall to you:

  • Your domain. A booking kit does not know your cancellation window or how you price a session. You still define the data and the edge cases.
  • Store submission. Signing, store listings and review notes are outside the code. Plan for them early.
  • Your own design. A kit sets a system. Changing its accent colour or layout is a prompt. Changing its feel is design work.

If you already know the app you want, a kit gives you the sign-in, API and data layer on day one. If you do not know yet, a blank project is still a fine place to explore, as long as you throw the exploration away before you build on it.

A workflow that works

  1. Pick the kit closest to your app. Run it on a simulator or phone before you change anything.
  2. Read the instruction file. Note the rules the agent will follow.
  3. Ask for one change at a time: a new screen that uses existing components, then the data for it. Our post on Cursor agent best practices covers how to scope and verify multi-file changes.
  4. After each change, run the typecheck and look at the screen at phone width, in light and dark.
  5. When the agent proposes a new package, ask why the existing components do not cover it.

Second editorial illustration of a phone with a booking calendar next to a code editor, with no readable text.

Step 5 catches most drift. The agent often has a reason. The reason is usually already solved in the kit.

If the agent is going to edit a real app rather than an empty folder, start from one that already runs. The Booking Kit is an Expo app with Supabase sign-in, a Hono server for Stripe checkout and reminder email, and the slot logic already in the database, and its CLAUDE.md tells the agent which components, theme tokens and rules to follow. You can click through the live demo before you buy: https://otf-kit.dev/templates/booking-kit.

Sources

  • Claude Code documentation, "How Claude remembers your project" (CLAUDE.md behaviour), https://code.claude.com/docs/en/memory, read 16 Nov 2026.
  • Native Templates, "Starting a React Native app with Claude Code or Cursor: why a template beats a blank project", https://www.native-templates.com/blog/react-native-template-claude-code-cursor, dated 14 Sep 2026, read 16 Nov 2026. Used for the blank-project failure list and the CLAUDE.md structure described above.
  • OTF Booking Kit, CLAUDE.md in the kit repository (stack table, client-versus-server split, useBookings and useCancelBooking hook pattern, SUPABASE_JWKS_URL note, ai/prompts link, lib/theme.ts hex rule, OtfSwitch and openWebPage conventions, bookings_no_overlap exclusion constraint, out-of-scope list, bun run typecheck rule), internal main commit 184c312, read 19 Nov 2026.
  • OTF Booking Kit page, https://otf-kit.dev/templates/booking-kit, read 19 Nov 2026 (Expo SDK 58, Supabase Postgres, Stripe checkout; live demo linked from the page).

Top comments (0)