AutoAppMaker

Android build shop — Kotlin & Compose

Describe an app.
Collect a signed one,
with its paperwork.

You write a brief. It comes back as a numbered specification for you to approve. Then an agent writes the Kotlin, compiles it, runs its tests, boots it on a real emulator and signs it — and hands you the docket saying what passed, what failed, and what it could not check at all.

One measured build. A metronome, taken from one sentence to a 6,503,028-byte signed APK in 17 min 09 s, downloaded over HTTPS like any customer would. Small apps are proven end to end. Large ones are not — see the limits.

01

Write the brief

A sentence or a page. "A metronome." "Duolingo for Darija." Plain language, no format to learn.

02

Approve the specification

The brief is expanded into numbered requirements — screens, stored data, logic, edge cases. You read them before a single line is written.

03

Collect the build

An installable APK, a Play-ready AAB, the full Kotlin source, and the docket. Yours to keep, whatever the verdict was.

The gate

Anyone can show you a demo that works.

The harder question is what happens when it doesn't. Every build is put through the same eight checks, and the report you get is the one we get — failures included, and blind spots marked as ours rather than blamed on your app.

compile
The project builds from clean, with the real Android toolchain. Nothing downstream runs until it does.
unit_tests
The tests the agent wrote for your app are executed, not merely written.
boot
The app is installed on an emulator and launched. A build that compiles but dies on the first screen is not a build.
mutation_probe
A line of your app is deliberately broken to prove the tests notice. A green suite that cannot fail is decoration.
completeness
Every numbered requirement in your approved specification, checked one by one and reported by number — code found, and a passing test for it.
release
Signed with the key generated for your account, in release configuration.
bundle
The Android App Bundle is produced and validated with Google's own bundletool.
provenance
A record of what produced the artifact, so the file you downloaded can be tied to the build that made it.

What you take away

Artifacts, not a subscription to a preview.

.apk

An installable app

Signed, release-configured, and downloadable over HTTPS the moment the build finishes.

.aab

A Play-ready bundle

Validated with bundletool, targeting a current SDK, ready to upload to the Play Console.

src

The whole source

Every Kotlin file, the Gradle build, the tests. Export it and compile it yourself — people have.

key

Your signing key

Generated once, for your account, and yours. It cannot be reissued — so copy it somewhere safe.

Read this before you sign up

What this does not promise.

Every AI builder on the internet shows you the run that worked. Here is the rest of it, because you will find out anyway and it is cheaper to read now.

  • 01The agent can fail. It may build an app that compiles and runs but does not implement everything you specified. The completeness check exists precisely to tell you so, by requirement number.
  • 02Small, self-contained apps are proven. Large ones are not. A metronome went end to end to a signed APK. Ambitious multi-screen briefs are what we are actively working on, and we would rather say that than sell you a demo.
  • 03Review what you ship. Nothing built here is fit to publish under your name without you reading it first. You get the full source so that you can.
  • 04One server, no uptime guarantee. A build interrupted by a restart is not counted against your free builds.
  • 05Your brief goes to a model provider. Your description and the generated source are sent to a third-party AI provider — that is how the app gets written. It is stated plainly in the privacy policy rather than buried in it.

Bring a brief. See what comes back.

New accounts get free builds, and every build has a hard spending cap — it stops rather than quietly running up a bill.

Create an account