AppKit — Lean Mobile App Launch Kit

An opinionated, lean AI development kit that takes a small mobile app from a vague idea to a store-ready release on Google Play and the Apple App Store. Works with Claude Code and OpenAI Codex — you pick the tool at install time, like a spec kit.

The AI gets broad freedom to make normal product and technical decisions. The workflow automatically enforces privacy, quality, advertising, and store-readiness — and only asks you when a decision is sensitive, expensive, legal, or hard to reverse.

Install

The recommended way is npx — no global install, always the latest:

# inside your app project directory — an interactive picker opens:
#   ↑/↓ move · space toggles AI tool(s) · enter confirms, then pick a platform
npx novaforge-appkit init

# or skip the picker with flags
npx novaforge-appkit init --ai claude --platform flutter
npx novaforge-appkit init --ai codex  --platform ios
npx novaforge-appkit init --ai both    --platform android

# target a different directory
npx novaforge-appkit init --ai claude --path ./my-app

Right after install, AppKit runs a dependency doctor for your platform — it checks Flutter, Xcode, Java, the Android SDK, CocoaPods, etc., and prints the exact install command for anything missing. It detects and guides only; it never installs anything for you. Re-check anytime with .appkit/kit/scripts/doctor.sh <flutter|ios|android> (skip the post-install check with --no-doctor).

Before it's published to npm, you can run it straight from GitHub:

npx github:NovaForgeOrg/appkit init --ai claude

Or install globally:

npm install -g novaforge-appkit
appkit init --ai codex

Prefer no Node? A pure-bash installer is included:

git clone [email protected]:NovaForgeOrg/appkit.git
./appkit/install.sh --ai claude --path ./my-app

Then open the project in your chosen tool and run the commands below. Re-running the installer is safe and refreshes the kit.

The workflow

/appkit.init      initialize the project + .appkit workflow
/appkit.idea      generate or evaluate a small app idea         -> idea.md
/appkit.shape     lean spec + vertical-slice task plan          -> app-spec.md, tasks.md
/appkit.build     implement slices with tests                   -> source + tests
/appkit.verify    full quality + policy gate                    -> verification-report.md
/appkit.release   prepare the store package                     -> .appkit/release/

Repair loop:

/appkit.fix       minimal fix for a defect / finding / rejection
/appkit.verify    re-run the gate

The commands are stateful: a gentle state machine (UNINITIALIZED → … → RELEASE_PREPARED) prevents skipping phases and routes blockers back to /appkit.fix.

The differentiator: it looks at the app and fixes it

After every big implementation, AppKit doesn't stop at "it compiles". It boots a simulator/emulator, captures every screen (light + dark), and reviews the result on two rubrics — quality and design — then fixes the findings itself, without you asking (bounded to keep it safe). The simulator + screenshot harness is scaffolded at init, so it works out of the box — no hand-wiring. See kit/screenshot-review-loop.md.

What's opinionated

• Small & local-first by default: one outcome, few screens, no login, no backend, no personal data unless truly required.
• Designed, not blank: a mobile-ui-design skill + a ready Material 3 theme give every app a real visual system (spacing scale, type hierarchy, color roles, dark mode, rich empty states) — store-directive-safe, never generic-grey.
• Baseline shell, free: every app ships a 1.2s splash (logo placeholder), a Settings screen with consistent Appearance (System/Light/Dark) and Language (System/English/Português-BR) switchers, and a fast-startup pattern (load in the background, show the UI right after the splash) — scaffolded at init.
• Privacy by default: declarations (Google Data Safety, Apple App Privacy, iOS privacy manifest) are built from real implementation evidence, not guesses.
• Monetization by design: AdMob placements are decided during Shape, never bolted on.
• Policy by design: Google Play, Apple, and AdMob rules are checked every phase.
• Evidence-based completion: "done" requires passing scripts and seen-and-judged screenshots — AI for judgment, deterministic scripts for certainty.
• Store-ready by the end: /appkit.release produces a copy-paste submission/ folder — metadata within each store's limits, multi-resolution icons, correctly sized screenshots, privacy policy, and a per-store "paste this here" guide.

What's inside

appkit/
├── install.sh            # picks Claude Code or Codex, renders the adapter
├── kit/                  # tool-independent source of truth
│   ├── constitution.md       # non-negotiable principles
│   ├── orchestrator.md       # state machine, gates, agent routing
│   ├── agents/               # product · builder · reviewer · release
│   ├── commands/             # init · idea · shape · build · verify · release · fix
│   ├── skills/               # 7 skills (product, dev, ui-design, testing/visual-QA, privacy, admob, store)
│   ├── templates/            # idea, app-spec, tasks, report, privacy, listing, manifest
│   ├── policy-rules/         # google-play · apple-app-store · admob · privacy checklists
│   ├── profiles/             # flutter (default) · android · ios
│   ├── scripts/              # doctor, simulator, capture/generate screenshots, icons, build, validators…
│   └── screenshot-review-loop.md   # the capture → review → auto-fix loop
└── adapters/{claude-code,codex}/   # how the kit maps onto each tool

In an installed project the kit lives at .appkit/kit/, runtime artifacts at .appkit/ (status.yaml, idea.md, app-spec.md, tasks.md, verification-report.md, screenshots/, release/).

Agents & skills (how the AI is organized)

Four agents, each owning a phase and never chosen manually by you:

| Agent | Commands | Owns | |-----------|----------------------------------|------| | Product | idea, shape | ideation, scope, spec | | Builder | init, build, fix | architecture, implementation, tests | | Reviewer | verify | independent quality + policy gate | | Release | release | store package preparation |

Seven reusable skills carry the domain knowledge: small-app-product-design, mobile-app-development, mobile-ui-design, mobile-testing-and-visual-qa, mobile-privacy-and-permissions, admob-best-practices, mobile-store-release.

Defaults & scope

Pick your platform at install time: Flutter (the deep path — Android API 35 / iOS 15), native iOS (SwiftUI), or native Android (Compose). Flutter has the most complete automation; native targets get the dependency doctor, profile guidance, and generic (simctl/adb) screenshot + asset generation. Defaults are local-first, portrait, AdMob planned but optional, no personal data. IAP, subscriptions, analytics, and automated submission are intentionally out of scope for this lean version but the architecture leaves room for them.

Safety

The kit prepares releases; you submit. It never exposes signing secrets, never invents legal/privacy text (placeholders are marked for your review), and requires your confirmation before anything sensitive or irreversible.