I’ve been experimenting with automating mobile app development end-to-end. Not the “type a prompt and pray” kind — a structured pipeline where AI interviews you, researches the market, writes a spec, builds the app, checks its own work, and deploys to the App Store.

The whole thing runs on top of Claude Code. No custom framework, no cloud service, no SaaS subscription beyond what you’re already paying for. Just markdown files telling Claude how to do its job.

The problem I was solving

I wanted to ship mobile apps fast. Like, multiple-apps-per-week fast. Not prototypes — actual store-ready products with monetization, ASO materials, and marketing copy.

Tools like Rork exist, but they’re a black box. You pay per prompt, the code lives in their cloud, and you can’t customize the pipeline. I wanted something I own and can plug into a larger system.

What Etnamute actually is

A folder with ~25 markdown files and a few scripts. That’s it.

The markdown files define a pipeline:

  • discovery.md — adaptive interview, generates questions based on your specific app idea
  • spec.md — PRD generation with web research and user approval
  • qa.md — self-review with dynamic checklists generated from the PRD
  • release.md — fastlane config, Maestro screenshots, local builds
  • headless.md — accepts a PRD file, no interactive steps, runs autonomously

Claude Code reads these files and follows the instructions. Skills and rules in .claude/ get auto-discovered. An MCP server serves Expo and RevenueCat docs on demand so Claude doesn’t hallucinate API calls.

How it works

You run claude in the project directory and describe your app idea. From there:

Phase 0 — Discovery. Claude analyzes your idea and asks 5-8 adaptive questions via structured UI — not generic “what type of app” stuff, but domain-specific questions with relevant options. Then it runs web searches to find competitors, validate pricing, check market demand. You get a PRD summary to approve before any code is written.

Phase 1 — Plan. A 9-section implementation plan generated from the approved PRD. Tech stack, file structure, milestones with checklists.

Phase 2 — Build. Five milestones executed sequentially: scaffold, screens, features, monetization (if you chose it — it’s optional), polish + launch materials. QA check after each milestone.

Phase 3 — Finalize. Final QA pass across the entire app.

Phase 4 — Release. Optional. Generates fastlane config, captures screenshots via Maestro on a simulator, builds IPA/AAB locally, uploads to stores. You confirm before it submits.

There’s also an Improve Mode — point it at an existing app in apps/ and ask for changes. It reads the PRD and code, clarifies what you need, applies targeted changes, verifies.

The honest part

This is not magic. Claude can still ignore instructions. The QA step is self-review — the same model checking its own output. The “97% quality score” is a number Claude assigns to itself.

But the difference between “generate an app” and “follow a structured pipeline with checkpoints” is real. It’s the difference between a junior dev with no process and a junior dev with code review. Not bulletproof, but way less random.

The headless mode is the interesting bit

The whole point of having a formal PRD schema is that other agents can generate it. An upstream agent analyzes the market, picks a niche, writes a PRD, hands it to Etnamute — and out comes an app. No human in the loop.

That’s what I was actually building: an AI-first app publisher. Etnamute is just the developer in that chain.

Try it

./setup.sh
claude
> I want an app for tracking daily water intake

Apache 2.0: github.com/bes-dev/etnamute