Introduction to ShipThatApp

ShipThatApp is a production-ready SwiftUI boilerplate for iOS. It gives you the parts every serious app needs — authentication, payments, AI, analytics, onboarding, settings, deep links, and review prompts — wired together, working, and ready to rename. Open the project, drop in your keys, and you are building features on day one instead of rebuilding the same login screen for the fifth time.

The promise is simple: save 50+ hours of undifferentiated setup. Everything here is real, working Swift you can read and reshape — not a scaffold with // TODO where the hard parts should be.

Why ShipThatApp exists

Every new iOS app starts with the same two weeks of plumbing: sign-in, a keychain, a subscription paywall, an API layer, analytics, a splash screen, a settings tab. None of it is the reason you started the app, and all of it has to be production-grade before you ship.

ShipThatApp is that plumbing, done well, once. It is opinionated where opinions save you time (modern Swift, MVVM with @Observable, async/await everywhere) and flexible where you need room (every AI engine and auth method sits behind a protocol or a manager you can swap). You inherit a codebase that already passes the bar you would otherwise spend a sprint reaching.

What makes it different

Most SwiftUI starter kits are generic, code-light, and stop at a login form. ShipThatApp leads with the things that are genuinely hard to build yourself:

On-device AI, not just cloud. Chat runs on Apple's Foundation Models right on the device — private, offline, and free per message — with cloud ChatGPT as a one-tap fallback. On-device chat is becoming table stakes; ShipThatApp ships a robust version (streaming, availability handling, session recovery) behind a single toggle. See AI Chat.
Built-in cloud AI that is actually safe to ship. Chat, image generation, and image analysis are wired to a backend you control. The app never carries an OpenAI key — every cloud call is HMAC-signed and proxied, so your secret stays on the server. See AI Image Generation, AI Vision, and API Client & Security.
The Dex scanner — on-device and cloud AI working together. Point the camera at anything and get a structured "Dex entry" back. Apple's Vision framework gives an instant, offline, private first guess; the secure cloud pass returns the rich result. It even degrades to an offline-only entry when there is no network. This is the flagship feature, and it shows off the whole stack at once — read Dex Scanner.
A genuinely modern stack. Swift 6, iOS 17+, the @Observable macro (no ObservableObject), async/await, @MainActor, and SwiftData for persistence. No Combine, no legacy patterns to unlearn.
Security-first by default. Secrets — API keys, the backend auth secret, Supabase credentials — live in a gitignored Config.xcconfig and are read at runtime, never committed. Auth tokens are stored in the Keychain. See Configurations.

Your keys never ship

The single most copied mistake in indie AI apps is embedding the OpenAI key in the binary, where anyone can extract it. ShipThatApp routes every AI call through an HMAC-signed backend request via ApiClient, so the key lives on your server. You get AI features without the bill someone else racks up on your account.

What's inside

A concise tour of what ships in the box. Each link goes to its own deep-dive page.

AI features

AI Chat — dual-engine chat: private on-device Apple Foundation Models plus cloud ChatGPT, switchable with one toggle, with persisted history.
AI Image Generation — DALL·E image generation from a text prompt.
AI Vision — send a photo, get an analysis back.
Dex Scanner — the hybrid on-device + cloud "scan anything" Pokédex.

Accounts & payments

Authentication — email/password, passwordless Magic Link, and Sign in with Apple, all through Supabase. The orchestration lives in AuthManager.
In-App Purchases — RevenueCat v5 integration with three ready-to-style paywalls, managed by PurchaseManager.
Review Request — Apple-compliant requestReview prompts that fire only after a usage threshold, so you ask happy users at the right moment.

App shell & UX

Onboarding — a customizable, data-driven onboarding flow built from the feature model.
Settings — a full settings tab with profile editing, feedback, and account actions.
Splash Screen — an animated launch screen with a clean state manager.
Lottie Views — three drop-in Lottie animation examples.
Analytics — TelemetryDeck event tracking, privacy-friendly and ready to extend.

Foundation

Project Structure — how the codebase is organized and why.
Configurations — Config.swift, the gitignored Config.xcconfig, and what each key does.
Installation & Setup — clone, configure keys, rename, and run.

How the app fits together

The entry point is ShipThatAppApp (@main). It configures RevenueCat and TelemetryDeck on launch, shows the SplashScreenView briefly, then hands off to ContentView. The real navigation hub is LandingView, which uses a typed AppRouter to drive the whole app:

// LandingView branches on auth state, then routes through AppRouter.
@State private var router = AppRouter(initialTab: .welcome)

var body: some View {
    Group {
        if authManager.currentSession != nil {
            authenticatedView      // TabView: Welcome / Content / Settings
        } else {
            unauthenticatedView    // SignInView in a NavigationStack
        }
    }
    .environment(router)
    .onOpenURL { handleIncomingURL($0) }   // Magic Link + deep links
}

AppRouter is a type alias for a generic router parameterized over the app's tabs, destinations, and sheets — so every screen is reachable through a single, type-safe navigation surface, including from deep links:

typealias AppRouter = Router<AppTab, AppDestination, AppSheet>

That means adding a screen is a matter of adding a case to AppDestination and a line to the destination switch — navigation and deep linking come along for free. See Project Structure for the full map.

Modern by design

ViewModels and managers use the @Observable macro, UI-mutating work is marked @MainActor, and dependencies are injected through initializers so features stay testable. If you have written SwiftUI for iOS 17, this will feel familiar immediately. New patterns are documented as you encounter them.

How this documentation is organized

The docs follow the path you actually take — from a fresh clone to the App Store:

Get started. Installation & Setup gets the project building, then Configurations and Project Structure explain where everything lives and how to plug in your keys.
Features. The app-shell pieces — Authentication, In-App Purchases, Onboarding, Settings, Analytics, and Review Request — each documented against the live code.
AI. The differentiators: AI Chat, AI Image Generation, AI Vision, and the flagship Dex Scanner.
Going live. Renaming, signing, and shipping — start from Installation & Setup and the configuration pages.

Where to go next

If this is your first hour with the kit, read these in order:

Installation & Setup — get it running.
Configurations — drop in your keys the secure way.
Project Structure — learn the lay of the land.

Then jump straight to the feature you came for — most developers start with Authentication or the Dex Scanner.