Autotomy — Expo Starter Pack
EN
Your account
Expo Foundation + developer CLI

Autotomy Expo Starter Kit

Start an Expo app with explicit architecture, baseline checks, and instructions for your AI coding tool. Keep the source you purchase. Add Pro when you need deeper audits and a project-specific Expo upgrade plan.

Read the FAQ ↓

Choose the source and support you need

  • Lite is free: a minimal runnable Expo shell, folder structure, and setup documentation. Publication status is shown on Pricing.
  • Starter is US$149 once: full Foundation source, baseline checks, agent setup, the purchased release and published v1 fixes. Foundation remains MIT.
  • Pro is US$19/month or US$190/year: premium audits, maintained policies, and agent-guided Expo upgrades, per developer across unlimited Autotomy projects. Starter ownership is required.
  • The included 30 days of Pro begin when Starter payment is fulfilled and do not renew automatically. A separately purchased subscription bills immediately; unused included days are not credited.
  • When Pro ends, premium commands stop. Purchased source, baseline checks, builds, and deployed applications continue working. Read the terms.
  • App integrations are your choice: Autotomy's development account and billing are separate from authentication, payments, analytics, or native permissions in your generated app. Add those providers behind the services/ layer.

Installation and purchases open when the release is ready. You can explore the setup guide now.

What's inside

Stack (from the foundation's package.json)

  • Expo SDK 57
  • React Native 0.86
  • React 19.2
  • TypeScript 6
  • Expo Router
  • TanStack Query (offline persistence via AsyncStorage)
  • Immer
  • Zod
  • Axios with retry
  • NativeWind v5 + Tailwind CSS v4
  • Vitest + fast-check
  • ESLint
  • dependency-cruiser
  • EAS Build config

Platforms: iOS, Android, and web from one codebase.

Folder structure

expo/
├── AGENTS.md                 # rules AI agents read before editing
├── docs/
│   ├── PRINCIPLES_PROFILE.md # which techniques are Core / Scoped / Deferred
│   ├── MOBILE_CORE_GUIDE.md  # everyday patterns, one rule + developer check each
│   └── SLICE_ARCHETYPES.md   # how to add a route, screen, hook, or policy
├── .dependency-cruiser.js    # layer import whitelist (fails the check)
├── vitest.config.ts          # 100% coverage gate on measured logic
├── eslint.config.js
├── eas.json · app.json
└── src/
    ├── app/        # routes and intent only
    ├── ui/         # screens, presentation, shared primitives
    │   └── components/shared/   # one UI contract, NativeWind implementation
    ├── hooks/      # runtime composition
    ├── services/   # all I/O: API client (retry + circuit breaker), logging, navigation, query client
    ├── types/      # shared vocabulary: Result, structured errors, typed routes, async data
    ├── theme/      # tokens → generated CSS theme (light and dark)
    └── utils/

use-cases/ (deterministic business rules) and state/ (owned domain state) are defined layers, with their own import rules, that you add as features grow.

AI rule files included

AGENTS.md
Layer boundaries, where new code goes, how to work with shared UI primitives, and what never to edit by hand. The installer adds the supported integration for Codex, Claude Code, or Cursor, with generic instructions for other agents.
docs/PRINCIPLES_PROFILE.md
The authoritative profile of which correctness techniques are required, which are scoped, and what counts as evidence.
docs/MOBILE_CORE_GUIDE.md
Techniques (validation at boundaries, effects only in adapters, exhaustive state handling, typed navigation, safe mutations, offline query persistence, property-based tests, and more), each with a frontline rule, the bug class it prevents, and a developer check.
docs/SLICE_ARCHETYPES.md
Step-by-step shapes for routes, screens, composition hooks, business operations, and state owners.

The rules work alongside Expo's official agent skills, which you can install separately.

Checks that make the architecture reviewable

  1. Layer boundaries are enforced. dependency-cruiser checks every import against a layer whitelist. Routes can't reach into shared UI primitives, services can't import UI, and screen folders can't import each other. It also rejects circular dependencies and orphaned files. If an AI tool puts code in the wrong place, the check fails.
  2. Measured logic has a strict coverage gate. Vitest enforces 100% statement, branch, function, and line coverage on the measured logic: services, hooks, types, utils, and UI state files, plus the use-cases and state layers as you add them. Property-based tests (fast-check) cover input-heavy code like routing and the circuit breaker.
  3. One command runs every gate. pnpm check runs the typecheck, lint, dependency rules, tests, and coverage. Run the same baseline gate locally or in CI without a Pro subscription. Premium hooks provide bounded feedback and do not repair source automatically.
  4. Effects stay in adapters. Network, storage, clock, logging, and navigation live in services/, behind typed contracts. Screens consume the declared service contracts; logic can be tested in isolation.
  5. Impossible states are unrepresentable. Loading, error, and absence are explicit types. Expected failures return coded results instead of thrown strings. Navigation only accepts routes declared in a typed list.
  6. Replace instead of refactor. Shared UI primitives expose a semantic contract implemented with NativeWind v5. Keep feature code behind that contract so future replacements have explicit boundaries; alternative engines are not included.

Who it's for

  • Solo founders building with AI. You want Cursor or Claude Code to move fast without the app turning into something no developer will touch. The checks report structural violations when you run them.
  • Tech leads adopting Expo. You know the principles. This shows exactly where they go in an Expo app, with the rules written down and enforced.
  • Small teams that will hire later. New developers get a documented architecture and a passing check, not a tour of tribal knowledge.

Not a fit: if you need authentication, payments, analytics, push notifications, or i18n wired in on day one, this kit doesn't include them. Look at batteries-included kits instead. Our comparisons cover the trade-offs:

Expo starter kit FAQ

Is the Autotomy Expo Starter Kit available now?

The account service reports installation and checkout readiness. Follow Get started to inspect your directory and connect your account. If a release or provider is unavailable, setup stops with an actionable message; a displayed price is not proof that checkout is open.

How much will it cost?

Lite is free. Starter costs US$149 once and includes 30 days of Pro without automatic renewal. Pro costs US$19/month or US$190/year per developer and requires Starter. A separately purchased subscription bills immediately; unused included days are not credited.

Which AI coding tools does it work with?

The installer supports Codex, Claude Code, and Cursor, with generic instructions for other agents. Baseline dependency, type, lint, and coverage checks run locally.

What does it include out of the box?

An Expo SDK 57 + React Native + TypeScript app with Expo Router, TanStack Query (with offline persistence), an API client with retry and circuit breaker, typed navigation, structured errors, shared UI primitives implemented with NativeWind v5, Vitest with a 100% logic-coverage gate, dependency-cruiser layer rules, ESLint, EAS config, and architecture documentation for humans and AI agents.

Does it include authentication, payments, or analytics?

Autotomy service accounts and payments are for the developer toolkit. Generated apps do not include product authentication, vendor integrations such as payments and analytics, or native capabilities that need OS permissions. You add the providers you choose behind the services/ layer, so they stay replaceable.

How do I know the guardrails actually pass?

Run the documented baseline check in your installed project. Release verification also checks fresh installations and example removal. Passing checks establish the properties they assess; they do not certify every feature, device, or future change. Pro audit findings include evidence, stable rule IDs, repair prompts, and areas not assessed.

How is it different from create-expo-app or Ignite?

create-expo-app is Expo's official, minimal starting point. Ignite is a mature, batteries-included boilerplate. Autotomy focuses on enforced architecture for AI-assisted development: import boundaries, coverage gates, and written rules that agents follow. See our comparisons with create-expo-app and Ignite.

More questions? See the general FAQ or follow the setup guide.