Daroms Speed App

English · Français

An idea in the morning, the app on your phone by evening.

Real output from a demo app: the app was created in 42 s (measured). Watch the full 50 s demo.

An Expo + Tamagui + Supabase mobile framework built for Claude Code. The core ships the theme, components, data layer, modules and store publishing; your app only writes what is specific to it, under rules checked on every file.

• Generate before writing: screens, tables and modules come from deterministic templates, no AI involved. Claude only fills in what is specific.
• One brand, one theme: 5 values in brand.ts produce OKLCH palettes, light and dark themes, radii, spacing and springs.
• Enforced rules: hard-coded color, Supabase inside a component, text outside i18n: a hook rejects the write and says what to do instead.
• Opt-in modules: auth, payments, push, AI chat, photos, maps... one command each.
• Low token cost: a short always-loaded core, rules loaded only for the files being touched, a component catalog instead of sources, and mechanical steps run in fresh-context Sonnet or Haiku subagents.

Full documentation: https://daromsartof.github.io/daroms-speedapp/en/

The documentation site starts in English with the home, installation and tutorial pages; guides and reference are in French for now. The AI layer (skills, rules) and CLI messages are in French; Claude understands prompts in any language.

Create an app

Requirements: Bun >= 1.3, Node >= 22.18, Git, Python 3, and Expo Go on your phone.

npx @daromsart/daroms-speed-app new my-app --name "My app" --variant list-detail
cd my-app
cp .env.example .env    # Supabase URL and public key
bun daroms dev          # scan the QR code with Expo Go

Global command: npm install -g @daromsart/daroms-speed-app, then daroms new my-app. The CLI runs on Bun.

daroms new copies the template, adds the core in core/, writes brand.ts and app.manifest.ts, enables the variant's modules, generates tables and screens, icons and splash, installs dependencies, syncs the AI layer into .claude/ and makes the first commit. core/ is a git submodule pinned to the installed version; if the core repository is unreachable, it is a copy of the core shipped in this package.

No Supabase to start with: --local keeps data on the device, behind the same hooks.

With Claude Code

Open Claude Code in the app, then:

/daroms-day An app to track my reading habits

Time	Skills	Result
Morning	/daroms-idea, /daroms-new	app.spec.md brief, app created, QR preview
Noon	/daroms-inspire, /daroms-brand, /daroms-design, /daroms-data	Dribbble, Pinterest and Mobbin references and a chosen direction, brand and icon, wireframes, Supabase tables with RLS
Afternoon	/daroms-screen, /daroms-module, /daroms-check, /daroms-polish	screens, modules, checks, UX polish
Evening	/daroms-store, /daroms-build, /daroms-submit	FR/EN store listing, EAS build, TestFlight and internal track, then app.cost.md: what the app cost in tokens and dollars

22 skills, 3 subagents (designer, reviewer, store) and 6 hooks (sync, context router, rule checks, typecheck, .env protection, token stats). The ECC method is built in: ecc-tdd-workflow, ecc-security-review, ecc-accessibility and ecc-typescript-patterns, vendored in the core and mapped to daroms commands by daroms-ecc. Details: skills, hooks.

Example: a table and its screen

bun daroms g table books --fields "title:text, author:text?, pages:int=0"
bun daroms g screen books --tab --icon BookOpen --title "Livres" --title-en "Books"
bun daroms db push

The first command writes the migration (owner RLS on all 4 operations), the zod schema and the useBooks, useBook, useCreateBook, useUpdateBook, useDeleteBook hooks. The second writes the route, the screen with its 4 states, FR/EN strings, the test and the tab. The screen is filled with @daroms/ui:

// src/features/books/BooksScreen.tsx
import { useT } from '@daroms/i18n'
import { Header, ListItem, QueryView, Screen } from '@daroms/ui'
import { BookOpen } from '@daroms/ui/icons'

import { useBooksScreen } from './hooks'

export default function BooksScreen() {
  const t = useT()
  const { query } = useBooksScreen()
  return (
    <Screen header={<Header title={t('books.title')} large />}>
      <QueryView query={query} empty={{ icon: BookOpen, title: t('books.emptyTitle') }}>
        {(books) => books.map((book) => <ListItem key={book.id} title={book.title} subtitle={book.author ?? undefined} chevron />)}
      </QueryView>
    </Screen>
  )
}

This is the beginning of the README. Read the rest at the original. Read the full README ↗