Skip to content
Skills Library
Programming · Building & coding

app-maker

/app-maker

Build a new iOS or Android app end-to-end from a plain-language idea, including Expo setup, scaffolding, verified screens, phone preview, iteration, and optional App Store or Play Store release. Use for "build me an app", "make an app that...", porting an existing product to mobile, or setting up development tools for a new mobile project. Designed for non-technical users but usable by anyone. Prefer the official expo:* skills when available; continue with this skill's built-in Expo workflow when they are absent.

Repository
app-maker ↗
Licence
MIT
Last repository change
30.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
32
Scripts
17
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 17 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/app-map.mjs, scripts/check-expo-go-sdk.sh, scripts/collect-visual-result.mjs, scripts/design-constraint.mjs, scripts/doctor.sh, scripts/flow-drive.mjs, scripts/flow-validate.sh, scripts/gen-visual-tests.mjs

What it does and when to use it

Build a new iOS or Android app end-to-end from a plain-language idea, including Expo setup, scaffolding, verified screens, phone preview, iteration, and optional App Store or Play Store release. Use for "build me an app", "make an app that...", porting an existing product to mobile, or setting up development tools for a new mobile project. Designed for non-technical users but usable by anyone. Prefer the official expo:* skills when available; continue with this skill's built-in Expo workflow when they are absent.

Triggers from the description

build me an appmake an app that...
Original author description

Build a new iOS or Android app end-to-end from a plain-language idea, including Expo setup, scaffolding, verified screens, phone preview, iteration, and optional App Store or Play Store release. Use for "build me an app", "make an app that...", porting an existing product to mobile, or setting up development tools for a new mobile project. Designed for non-technical users but usable by anyone. Prefer the official expo:* skills when available; continue with this skill's built-in Expo workflow when they are absent.

How it works

  1. Host and companion-skill setup
  2. The core idea: avoid heavy installs by default
  3. Phases (one file each, under references/build-flow/)
  4. Installing things: how to decide, without asking a technical question
  5. The validation loop — five rules, all mandatory
  6. References
Original SKILL.md headings · 377 lines, 3,517 words
SKILL.md preview
---
name: app-maker
description: Build a new iOS or Android app end-to-end from a plain-language idea, including Expo setup, scaffolding, verified screens, phone preview, iteration, and optional App Store or Play Store release. Use for "build me an app", "make an app that...", porting an existing product to mobile, or setting up development tools for a new mobile project. Designed for non-technical users but usable by anyone. Prefer the official expo:* skills when available; continue with this skill's built-in Expo workflow when they are absent.
license: MIT
---

# App Maker (for non-technical users)

You are building a real, working mobile app for someone who does not code and
should never have to see a terminal, an error stack trace, or a technical
decision they didn't ask to make. Every phase below exists to keep them from
getting stuck. Read `references/plain-language.md` now — it sets the tone for
everything else in this skill.

## Host and companion-skill setup

This skill supports both Claude Code and Codex from the same files. Keep the
shared build flow identical; branch only for host-specific path resolution,
permission prompts, and file/image delivery.

Before the first bundled script call, resolve
`APP_MAKER_SKILL_DIR` as described in `references/build-flow.md`.
Claude Code can derive it from `${CLAUDE_PLUGIN_ROOT}`; Codex exposes the
installed `SKILL.md` path in its skill catalog. Never assume the current
working directory is the skill directory.

Use the official `expo:*` skills when the host has them installed. If they are
absent, do not block the ordinary scaffold, Expo Go preview, or validation
flow: follow this skill's embedded Expo instructions and normal React Native
conventions. For specialized dev-client or store-release work, use the
corresponding EAS commands directly or explain the missing companion plugin
only when it is actually needed.

The host's approval and sandbox rules always win. An **AUTO** item means the
workflow does not need a separate product decision; it never means bypass a
Codex approval prompt, a Claude permission prompt, or an operating-system
security boundary.

## The core idea: avoid heavy installs by default

Most of what makes mobile development painful for beginners — installing
Xcode, installing Android Studio, configuring simulators — is **not actually
required** to go from an idea to a published app, *when the app's features
fit inside Expo Go*:

- **Preview**: the user's own phone + the free Expo Go app (scan a QR code).
  No Xcode, no Android Studio, no simulator.
- **Publish**: EAS Build compiles the app in Expo's cloud. Still no local
  Xcode or Android Studio needed, even for the final App Store / Play Store
  binary.

This is Path A, and it's still the default — most apps fit inside Expo Go,
and its speed is the point. But some apps genuinely can't: anything needing
audio/video processing beyond playback, speech recognition, Bluetooth,
HealthKit, background location, or most other native-module territory needs
a compiled "development build" instead, which Expo Go structurally cannot
preview no matter what you do to the project. Phase 0.5 below decides which
path an app is on, **before** scaffolding — not in Phase 3, after screens
already exist on the wrong assumption. Only install Xcode/Android Studio
when Phase 0.5 actually calls for it (or the user has no phone, or
explicitly wants a local simulator) — and even then, follow the AUTO / ASK
FIRST / USER MUST CLICK tiers in `references/environment-setup.md` exactly.
Don't over-install.

## Phases (one file each, under `references/build-flow/`)

These are `build-flow.md`'s numbers, not a second scheme — one set of phase
numbers across the whole skill, so a cross-reference never needs translating.

- **Phase 0 — Understand the idea.** A short plain-language conversation, not
  a spec form. If they already have a working app in another language, this is
  a *port*, which has its own rules — see "Porting an existing app" in
  `build-flow/phase-0-understand.md`.
- **Phase 0.5 — Does this fit Expo Go?** Decide right after the Phase 0
  conversation, before touching anything else. Concrete trigger list and
  cross-checks in `build-flow/phase-0.5-expo-go-fit.md`. This choice
  determines whether Phase 3 is
  the fast QR-code path (Path A, the default) or a development-build path
  (Path B) that needs different tooling and a different, non-negotiable
  verification step — get this right early, it's expensive to discover late.
- **Phase 1 — Check the environment.** Run
  `"${APP_MAKER_SKILL_DIR}/scripts/doctor.sh"` once per
  machine/session. It reports three verdicts: the Expo Go path's needs, the
  dev-build path's needs, and how Phase 3 will actually reach the user's
  phone. Read the first two according to Phase 0.5; read the third always. If
  it says EAS Update, ask the user for an Expo access token **now** — it's the
  one thing on that path only they can do, and it costs them a minute here
  versus a hard stop at Phase 3 with the whole app already built. If it says
  **none**, egress is restricted and Expo's API is unreachable too: ask for
  nothing, say plainly at this phase that the phone step will happen on the
  user's own machine, and plan to show them screenshots from a web export in
  the meantime (`troubleshooting.md`, "Egress is restricted").
- **Phase 2 — Scaffold the project, build the screens, and verify.** This
  branches on Phase 0.5's answer. **Path A:**
   run `"${APP_MAKER_SKILL_DIR}/scripts/check-expo-go-sdk.sh"`
   *first* and scaffold at the SDK tag it
   prints (`--template default@sdk-NN`), not plain `@latest` — the App
   Store's Expo Go build regularly lags the newest SDK by weeks, and
   scaffolding ahead of it produces a project that can never open on the
   user's phone (see `troubleshooting.md`). **Path B:** skip that check
   entirely — Expo Go compatibility is irrelevant to a dev build — and
   scaffold at latest (or whatever SDK the native package you need actually
   requires). Following Path A's check on Path B is a real, tested mistake:
   it can lock the project below the SDK a required native package needs
   (confirmed with `expo-widgets`, which required SDK 57 while the check was
   still reporting the store's SDK 54). Immediately after scaffolding, read
   the generated project's `AGENTS.md` and `CLAUDE.md` when present; keep and
   follow both so project-local guidance works in Codex and Claude Code. Then
   run
   `"${APP_MAKER_SKILL_DIR}/scripts/strip-demo-scaffold.sh" --name
   "Display Name"` to remove the
   template's demo tabs/explore/modal content and drop to a clean
   single-screen stack (verified end-to-end on both known template shapes —
   don't redo this by hand). Then build the real screens using the `expo:*`
   skills when available (project structure, router, native UI, data
   fetching), or the embedded fallback in `phase-2-scaffold.md` when they are
   not. Guard `expo:expo-ui` / `@expo/ui` against the SDK already selected in
   Phase 0.5; if it needs a newer SDK, use Expo Go-compatible React Native
   controls instead of changing the user's path.
   Before this phase ends, both gates must pass: `npx tsc --noEmit`, then
   `"${APP_MAKER_SKILL_DIR}/scripts/ui-validate.sh"` (see "The
   validation loop" below). Never hand a
   broken bundle *or* a broken layout to a non-technical user.
- **Phase 3 — Let them see it live.**
   **Path A (fits Expo Go, the default):** start `npx expo start` in the
   background, build the connection QR yourself with
   `scripts/make-preview-qr.sh` (Expo CLI's own QR only renders in an
   interactive terminal, which a background process never has — confirmed
   by testing, don't wait for it to appear), and generate both its ASCII
   output and PNG. In Codex desktop, render the PNG from its absolute path and
   include the connection URL as text. In Codex CLI or a plain Claude Code
   terminal, print the ASCII QR directly in the reply; a Claude file
   attachment can be a secondary convenience, never the only delivery path.
   This is the milestone that matters most on Path A — get here fast, and
   get it right the first time (print it once, cleanly — don't experiment
   with alternate QR commands in front of the user; the script already
   avoids the ANSI-color-garbage trap those fall into). **Path B (needs a
   dev build):** the QR flow does not apply at all — say so plainly up
   front, then follow `build-flow/phase-3-preview-dev-build.md` (Android via
   EAS cloud build is the cheap route; iOS has no free path). On Path B,
   actually driving a simulator or emulator yourself before calling the app
   ready is a required step, not optional — see "Verification is not required
   for Path A. It is not optional for Path B." in
   `build-flow/phase-3-preview-dev-build.md`.
- **Phase 4 — Iterate.** Take feedback in their own words, translate it to
  code. Every bug from here on is a *runtime* bug reported in one sentence by
  someone who can't see a stack trace — the hardest kind, and the phase that
  eats the most time. Rules 3 and 5 of the validation loop are what keep it
  bounded.
- **Phase 5 — Ship it.** `expo:eas-app-stores` for the cloud build/submit
  mechanics; be upfront that Apple ($99/yr) and Google ($25 one-time)
  developer accounts are the one part only the user can do (identity +
  payment).

## Installing things: how to decide, without asking a technical question

Every install command lives in `references/environment-setup.md`, tagged:

- **AUTO** — proceed without asking a product-choice question, subject to the
  host's normal approval and sandbox prompts, then say one plain sentence
  about what happened. (Node, Watchman, eas-cli, Homebrew formulae — small,
  fast, reversible.)
- **ASK FIRST** — tell the user what it is, roughly how big/long, get a
  go-ahead. (Homebrew itself, Android Studio, SDK/system images — large or
  needs their admin password.)
- **USER MUST CLICK** — Apple/Google gate it behind a GUI dialog or account
  login (full Xcode from the App Store, the Xcode CLT install dialog,
  developer account sign-up). You can kick it off and give the one next
  instruction, but you cannot finish it for them — say so plainly instead of
  retrying in a loop.

Never run the ASK FIRST or USER MUST CLICK tier silently, even though the
user who set up this skill said installs can generally proceed — "ask or
just install" still means: heavy/irreversible things get one plain-language
heads-up first. For AUTO items, use the host's built-in approval request when
the command needs network, global-install, GUI, or out-of-workspace access;
do not split or rewrite a command to evade that approval.

## The validation loop — five rules, all mandatory

A non-technical user cannot tell you the layout is broken in terms you can
act on. "It looks weird" is the most detail you will ever get, and often you
won't get even that — they'll assume it's meant to look like that. So you
check it yourself, before they ever see it. Full mechanics live in
`references/build-flow/phase-2-verify.md`; these five rules are non-negotiable.

Two checks, and they answer different questions. Reaching for the wrong one
wastes a phase:

- **`ui-validate.sh` — does this screen hold together?** Geometry, one screen
  at a time, rendered in isolation with the router stubbed out.
- **`flow-validate.sh` — can a user get from A to B and back?** The real
  router, real navigation, real data, driven in a browser.

**1. Read the map and the ledger before you write layout code.**
Run `node "${APP_MAKER_SKILL_DIR}/scripts/app-map.mjs"`, then read
**`.claude/app-map.md`** — a tree of
the project annotated with each file's route, what imports it, what it imports,
its style names, the `risky` list of patterns that break on device, and the
layouts that already failed in *this* project. One read replaces a directory
crawl; a grep sweep of an app you already have a map of is waste.

**Read the digest, not the JSON.** `app-map.json` holds the same map plus every
resolved `StyleSheet` value and the full import graph, and those make it roughly
six times larger — ~4.8k tokens against ~800 on a two-screen app, before every
layout edit, growing with every screen added. Open it only when you need a
specific style value or the complete used-by list. The digest marks everything
it truncates, so you can always tell when there's more to fetch.

**2. After `tsc` passes, run
`"${APP_MAKER_SKILL_DIR}/scripts/ui-validate.sh"`. Silently.**
It renders every screen headless at phone size and checks real geometry:
nothing off-screen, nothing collapsed, no text clipped, no tap target under
44×44, no overlapping controls, no content stranded below the fold. It
prints one status line and writes everything else to
`.claude/visual/last-run.json`. On failure, **look at the diff and actual
images it lists** — you can see them, that's the point — then fix the
layout and run it again. Don't show a non-technical user a test, a log, or a
file path — running the check silently is unconditional, but what you *say*
about it is calibrated to who you're talking to (`plain-language.md`).

**3. Three attempts, then stop and talk like a person.**
`last-run.json` carries `attempts`. At `status: "blocked"` you are done
editing that layout. Do **not** mention tests, code, CSS, retries, or ask
the user anything technical. Say the design has a constraint, in plain
English, and offer exactly two simpler alternatives that you are confident
will work — concrete and visual ("one card per row, full width" / "a
compact list with the picture on the left"), never "shall I refactor the
flex container?". They pick, you build it. This is a normal design
conversation to them, and it should read as one.

**4. Record what failed, so it can't happen twice.**
Once they choose, run
`node "${APP_MAKER_SKILL_DIR}/scripts/design-constraint.mjs" add`
with the file, the
pattern that failed, the styles involved, and the alternative they picked.
That writes `.claude/design-constraints.json`, which rule 1 makes you read
next time. Skipping this means the next similar request walks into the same
wall, burns three more attempts, and hands them the same apology again —
which reads to them as the tool being unreliable, not as a hard layout
problem.

**5. When a bug reproduces on some screens but not others, enumerate what
differs before changing any code. The difference is the bug.**
Rule 3 bounds *layout* attempts. Behaviour bugs had no equivalent, and the
result was three fixes for one broken back button across three round-trips —
exactly the loop rule 3 exists to prevent, in a category it didn't cover.
Twice, the decisive evidence was an asymmetry already in hand and not mined:
one tab worked because `/` *was* that tab, so a `router.replace('/')` fallback
was masking the bug everywhere else; then one screen still failed because it
was the only one wrapping its rows in a gesture-handler component.

So: **before the second fix — not the third — get the discriminating
observation.** Usually that's one plain question, asked outright rather than
buried in an option description. For an unresponsive control the cheapest
discriminator is *"does it do nothing, or the wrong thing?"* — those two
answers point in opposite directions, and either is worth more than another
speculative edit. `flow-validate.sh` answers the same question mechanically
when the flow is reachable in a browser; prefer it to guessing.

### What the check actually proves (and what it doesn't)

It renders **react-native-web in headless Chromium**, not iOS or Android. It
is a strong structural proxy and a weak fidelity one:

- **Caught reliably:** content off the edge, collapsed containers, clipped
  text, unreachable content, tap targets too small, overlapping controls,
  and any layout regression between two runs on the same machine.
- **Not caught at all:** platform fonts and metrics, safe-area insets,
  native shadows/blur, keyboard avoidance, gestures, and anything rendered
  by `@expo/ui` — those are native controls with no web build, so screens
  using them are skipped outright rather than checked against a fake.
- **Navigation is not covered at all**, and not by oversight: the config
  aliases `expo-router` to the stubs, where `router.push` is `() => {}` and
  `useLocalSearchParams` returns `{}`, and every screen renders alone with no
  navigator above it. That's correct for measuring geometry and it makes
  flows untestable here by construction. A broken back button passes this
  check every time. That's what `flow-validate.sh` is for — a sibling
  capability, not a gap to work around inside this one.

A pass means "structurally sound", never "this is what the phone shows".
The phone preview in Phase 3 is still the real verification, and the user's
eyes are still the final say.

## References

Consult these as needed — don't load them all up front, pull in the one
relevant to the phase you're in:

- `references/build-flow.md` — a short **index** of the phases, plus the
  cross-host skill-directory check before your first script call. Each phase
  is its own file in `references/build-flow/`, and each one ends by naming the
  next. **Read one phase file at a time — the one you're in.** The full set is
  ~12k tokens; a single phase is 400–3,000. Loading phases you aren't in is the
  other place this skill's context budget goes.
- `references/environment-setup.md` — exact install commands per tool/OS,
  with the AUTO / ASK FIRST / USER MUST CLICK tier for each.
- `references/plain-language.md` — how to talk to a non-technical user, a
  jargon-to-plain-English table, and the test for when to just decide
  something yourself instead of asking.
- `references/troubleshooting.md` — common failure symptoms (QR won't scan,
  build fails, emulator won't boot, permission errors) and their fixes,
  written so the user only ever hears the plain-language version.
- `scripts/doctor.sh` — read-only environment report. Never installs
  anything itself; just tells you what's present so you know what (if
  anything) to act on. Reports two separate verdicts — what the Expo Go
  path needs and what a development-build path would need — since Phase
  0.5 decides which one applies before this even runs. Its third verdict,
  preview delivery, is `lan`, `eas-update`, or `none`; `none` means Expo's
  own API is unreachable from this shell, so the token ask is off too.
- `scripts/check-expo-go-sdk.sh` — read-only check of which SDK the App
  Store/Play Store build of Expo Go currently supports, and the exact
  `create-expo-app` flag to scaffold at it. **Path A only** — run before every
  fresh Path A scaffold (Phase 2), and never on Path B, where following its
  output can pin the project below the SDK a required native package needs — see `troubleshooting.md` for why this matters.
- `scripts/strip-demo-scaffold.sh [--name "Display Name"]` — removes the
  template's demo tabs/explore/modal/components and rewrites the layout to
  a single-screen stack. Knows the two template shapes tested so far; if it
  doesn't recognize a project's layout it aborts without changing anything
  rather than guessing — fall back to the manual process in
  `build-flow/phase-2-scaffold.md` and consider teaching it the new shape.
- `scripts/setup-visual-loop.sh [projectDir]` — one-time, per project, right
  after scaffolding. Installs the headless checker (vitest + Playwright
  Chromium + react-native-web) and writes its config into `.claude/visual/`.
  Every byte of install output goes to `.claude/logs/setup.log`; it prints
  one status line and nothing else. Adds `.claude/` to `.gitignore` so none
  of this apparatus ends up in the user's project history.
- `scripts/app-map.mjs [projectDir]` — read-only. Writes two files:
  **`.claude/app-map.md`**, a compact annotated tree — routes, what imports
  what, style names, `risky` patterns, and the design constraints — and
  `.claude/app-map.json`, the same map plus every resolved `StyleSheet` value
  and the full import graph. **Read the `.md`; reach for the `.json` only when
  you need a specific value.** The JSON is ~6× the tokens and rule 1 has you
  reading it before every layout edit, which is where this skill's context
  budget actually goes. Uses the project's own `typescript` (adds no
  dependency); exits 3 if it can't find one, in which case just read files
  normally.
- `scripts/ui-validate.sh [projectDir]` — the loop. Refreshes the map,
  regenerates one check per screen, runs them headless, and writes
  `.claude/visual/last-run.json`. `STATUS=pass|seeded|fail|blocked`. Silent
  to the user by construction — but never silent to you: read
  `last-run.json` after any non-zero exit rather than re-running it with
  output showing.
- `scripts/flow-validate.sh [projectDir]` — the other half. Builds the web
  export, serves it, and drives the **real** router in the Chromium
  `setup-visual-loop.sh` already installed, reporting per route whether a user
  can go somewhere and get back. Adds no dependency. Run it when navigation
  changed or a control is reported as unresponsive — not on every edit; the
  export step costs about a minute.
- `scripts/design-constraint.mjs add|list [projectDir]` — the ledger from
  rule 4. The two list-ish flags take different shapes and the script rejects
  the wrong one, so copy them exactly: `--checks` is comma-separated,
  `--styles` is a JSON object.
  `add --file app/index.tsx --pattern "three cards side by side"
  --checks overflow-right,small-tap-target
  --styles '{"flexDirection":"row","gap":24}' --chose "One card per row"`
- `scripts/verify-expo-go-update.sh [projectId|projectDir] [channel]` — asks
  Expo's update server for a bundle exactly the way Expo Go asks, and says
  whether the phone would actually get one. Mandatory before handing over a QR
  code on the EAS Update fallback: that path fails *silently* — `✔ Published!`
  and an HTTP 204 the user's phone quietly does nothing with.
- `scripts/gen-visual-tests.mjs`, `scripts/collect-visual-result.mjs`,
  `scripts/flow-drive.mjs` — internals of `ui-validate.sh` and
  `flow-validate.sh`. Don't call them directly.
- `templates/` — the config, test bootstrap, layout assertions and
  native-module stubs that `setup-visual-loop.sh` copies into a project. If
  a screen fails to import a native-only Expo module, add the missing export
  to `templates/expo-stubs.tsx` — that's a stub gap, not a layout bug.
- `scripts/make-preview-qr.sh <port|full-url> [output.png]` — prints a clean
  ASCII QR code and optionally writes a PNG. Use the ASCII output in Codex
  CLI and plain Claude Code terminals; render the PNG by absolute path in
  Codex desktop. Include the URL in every host. Use this every time instead
  of expecting Expo CLI to print its
  own QR code — it won't, in a background process — or hand-rolling a
  `qrcode`/`qrcode-terminal` CLI call yourself, which produces unreadable
  ANSI garbage unless invoked exactly the way this script does (Phase 3,
  `troubleshooting.md`). Also accepts a full URL (anything containing
  `://`) instead of a port, skipping LAN IP lookup entirely — for the EAS
  Update fallback when this session isn't on the user's own network at all
  (`build-flow/phase-3-preview-expo-go.md`, "When the dev server can't reach
  the phone at all").
Files in this package (32)
  • SKILL.md 23 KB
  • agents/openai.yaml 1 KB
  • references/build-flow.md 4 KB
  • references/environment-setup.md 10 KB
  • references/plain-language.md 6 KB
  • references/troubleshooting.md 32 KB
  • references/build-flow/phase-0-understand.md 3 KB
  • references/build-flow/phase-0.5-expo-go-fit.md 4 KB
  • references/build-flow/phase-1-environment.md 3 KB
  • references/build-flow/phase-2-scaffold.md 11 KB
  • references/build-flow/phase-2-verify.md 8 KB
  • references/build-flow/phase-3-preview-dev-build.md 7 KB
  • references/build-flow/phase-3-preview-expo-go.md 11 KB
  • references/build-flow/phase-4-iterate.md 3 KB
  • references/build-flow/phase-5-ship.md 2 KB
  • scripts/app-map.mjs 19 KB
  • scripts/check-expo-go-sdk.sh 4 KB
  • scripts/collect-visual-result.mjs 15 KB
  • scripts/design-constraint.mjs 4 KB
  • scripts/doctor.sh 16 KB
  • scripts/flow-drive.mjs 12 KB
  • scripts/flow-validate.sh 3 KB
  • scripts/gen-visual-tests.mjs 6 KB
  • scripts/make-preview-qr.sh 5 KB
  • scripts/setup-visual-loop.sh 8 KB
  • scripts/strip-demo-scaffold.sh 9 KB
  • scripts/ui-validate.sh 10 KB
  • scripts/verify-expo-go-update.sh 6 KB
  • templates/expo-stubs.tsx 17 KB
  • templates/layout-checks.ts 9 KB
  • templates/setup.ts 1 KB
  • templates/vitest.config.ts 6 KB

Versions

The database has no other skills named app-maker.

Database snapshot: 13.11.2026 · package version 007366e1c9fe (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 91create-mobile-app
    Use when the user wants to start a new Power Apps mobile app (Expo / React Native / TypeScript, targeting iOS and Android) from scratch.
  • 100store-ready
    Entry point for getting a mobile app through App Store and Google Play review. Use when the user says "get my app ready for the App Store", "submit my app", "publish to Google Play", "release my Expo app", "is my app ready for review", "what is left before I can submit", "why…
  • 90mobile
    Build, fix, review and release mobile apps on Expo and React Native, Android (Kotlin, Compose), iOS (SwiftUI) or Flutter. Covers EAS, signing, Play Console, TestFlight, store rejections, permissions, deep links, push, offline, crashes, performance, device testing. Use when the…
  • 86mobile-app-dev
    Use when scaffolding or deploying Expo/React Native apps.
  • 90build-mobile
    Shipwright build rules for Installed mobile app (Native mobile experience, Store release and mobile security). Use when building, changing or releasing an installed mobile app (iOS, Android): Expo, React Native, Capacitor, Flutter, store submission, App Review, Google Play,…
  • 100prompt-to-store
    Takes a Flutter mobile app from a one-line request to an installable test build on the user's phone, then to Google Play and the App Store, using the prompt-to-store MCP tools (Plan → Build → Check → Ship → Store). Use when the user asks to build, make or create a mobile, iPhone…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.