Coming soon · Waitlist open

Autotomy Expo Starter Kit

A production-ready Expo + React Native + TypeScript codebase built for AI coding tools. The architecture is checked by machines, not by memory, so AI-generated code lands in the right place, and changes stay contained.

Read the FAQ ↓

Where things stand

  • The kit is not on sale yet. We're finishing it and will email the waitlist first.
  • It's built on Autotomy Foundation Expo v1.0.0, the locked architecture base released on July 17, 2026. For that release, the full check passed in GitHub Actions on main: 84 tests passed, measured logic had 100% statement, branch, function, and line coverage, and dependency-cruiser reported no violations.
  • Not included: product authentication, vendor integrations (payments, analytics, and similar), and native capabilities that need OS permissions. You add the providers you choose behind the services/ layer.
  • Pricing has not been announced. Waitlist members hear first.
  • Kits are sold as digital downloads, with lifetime access to the version you buy (see Terms).

What's inside

Stack (from the foundation's package.json)

  • Expo SDK 56
  • React Native 0.85
  • React 19.2
  • TypeScript 6
  • Expo Router
  • TanStack Query (offline persistence via AsyncStorage)
  • Immer
  • React Hook Form
  • Zod
  • Axios with retry
  • NativeWind
  • 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, swappable styling engines
    ├── 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 add or delete a styling engine, and what never to edit by hand. AGENTS.md is the cross-tool convention that tools such as Claude Code, Codex, and Cursor read (per Expo's agent docs).
docs/PRINCIPLES_PROFILE.md
About 200 lines. The authoritative profile of which correctness techniques are required, which are scoped, and what counts as evidence.
docs/MOBILE_CORE_GUIDE.md
About 1,000 lines. More than 20 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
About 700 lines. 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.

Guardrails that fail the check, not suggestions that get ignored

  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. Logic is fully tested, or the gate fails. 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 gate locally, in a pre-commit hook, or in CI. For the v1.0.0 foundation release it passed in GitHub Actions on main.
  4. Effects stay in adapters. Network, storage, clock, logging, and navigation live in services/, behind typed contracts. Screens and business rules stay pure and testable.
  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. The UI layer is one contract with interchangeable styling engines. StyleSheet and NativeWind are implemented; Tamagui and Expo UI are placeholders. Switching engines is one command, and deleting an engine touches no routes or screens.

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 catch structural drift the moment it happens.
  • 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?

Not yet. It's coming soon. Join the waitlist and you'll be the first to know when it launches, including pricing and the early-bird discount.

How much will it cost?

Pricing hasn't been announced. Waitlist members will hear first, and early signups get a launch discount.

Which AI coding tools does it work with?

Any tool that edits a normal repo: Cursor, GitHub Copilot, Claude Code, Windsurf, Codex, and others. The architecture rules live in AGENTS.md and docs/, and the enforcement is tool-independent: the dependency, type, lint, and coverage checks fail no matter who wrote the code.

What does it include out of the box?

An Expo SDK 56 + React Native + TypeScript app with Expo Router, TanStack Query (with offline persistence), an API client with retry and circuit breaker, typed navigation, structured errors, swappable styling engines (StyleSheet, NativeWind), Vitest with a 100% logic-coverage gate, dependency-cruiser layer rules, ESLint, EAS config, and about 1,900 lines of architecture docs for humans and AI agents.

Does it include authentication, payments, or analytics?

No. Product authentication, vendor integrations such as payments and analytics, and native capabilities that need OS permissions are not part of Autotomy Foundation Expo v1.0.0. You add the providers you choose behind the services/ layer, so they stay replaceable.

How do I know the guardrails actually pass?

For the v1.0.0 foundation release (July 17, 2026), the full check passed in GitHub Actions on main: 84 tests passed, measured logic had 100% statement, branch, function, and line coverage, and dependency-cruiser reported no violations.

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 join the waitlist.