●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30
The four acceptance checks I still run after the build turns green
A successful build does not mean a shippable build. Here are the four failure classes an AI build loop cannot see, and a dependency-free script that inspects the artifact itself before you submit.
After I shipped v2.0.0 of one of my Android wallpaper apps, the crash count in Crashlytics refused to come down. The build had never gone red. Upload passed, review passed. And yet on Android 6.0.1 devices, the app died on launch.
The cause was a Java 8 API reference without desugaring behind it, and the fix was a single line in Gradle. But the line was not the part that stayed with me. What stayed with me was finally feeling, rather than knowing, that there is a gap between "the build passes" and "this is shippable."
With Rork, where generation and building loop on the cloud side, that gap gets wider. The agent only ever sees what the compiler and linker report back. Distribution, real devices, and review sit outside its field of view.
What a green build actually guarantees
A green build guarantees roughly three things:
Every type and symbol you reference exists somewhere on the compile-time classpath
Resource references resolve well enough to produce a resource table
The output can be packaged into a valid artifact
Everything else is unguaranteed. Classes loaded at runtime through a different path, behavior after the artifact is split for delivery, the information you need to read a crash after the fact, and files that should never have been packaged at all. Every shipping failure I have hit as an indie developer fell neatly into one of those four buckets.
Check
Where it surfaces
Visible to the build?
Missing backward compatibility
Older OS devices
No — runtime only
Density bucket gaps
Subset of devices post-release
No — after splitting
Missing symbolication inputs
Your crash dashboard
No — separate pipeline
Files that should not ship
The published artifact
No — packaged as instructed
Check 1: verify backward compatibility in the artifact, not the config
Desugaring settings look like something you can confirm by reading the build file. That is how I treated it at first. The case that cost me time was one where the config looked correct, but a dependency pulled in newer API references through its own path. The lesson was that the build definition is not evidence. The artifact is.
The DEX inside your artifact carries referenced class names as plain strings. When desugaring is in effect you will see rewritten names like Lj$/util/function/Supplier;. When it is not, only Ljava/util/function/Supplier; remains. Opening the artifact as a ZIP and scanning the bytes is enough to tell them apart, with no special tooling.
What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.
WHAT YOU'LL LEARN
✦You will be able to decide, project by project, which steps to hand to an AI build loop and which ones need a gate you own
✦You will be able to catch post-release-only failures before submission by inspecting the artifact instead of the build config
✦You will be able to move from shipping on build status alone to shipping on a four-point acceptance check
Secure payment via Stripe · Cancel anytime
✦
Unlock This Article
Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.
Check 2: resources that vanish when the delivery shape changes
App Bundle delivery means the artifact is split per device. If an image only lives in drawable-xxhdpi/, devices outside that bucket receive a split that simply does not contain it. It renders fine on your test device, fine during review, and then breaks for a slice of users after release. That ordering is what makes it expensive.
The intuitive fix is to supply every density. I went the other way and removed density from the equation: anything in drawable-nodpi/ is excluded from density splitting and reaches every device unchanged. For a wallpaper app, where the images are the product rather than the chrome, there was little reason to carry per-density variants in the first place. The full account is in the drawable-nodpi fix for images lost to density splitting.
As a check, scanning res/drawable-*dpi/ inside the artifact and listing any filename that appears in exactly one bucket turned out to be sufficient.
Check 3: the gap that makes symptoms unreadable
The third class is not about something being broken. It is about not being able to read the breakage when it happens.
A bundle packaged as Hermes bytecode produces stack traces you cannot interpret directly. Unless the matching source map and identifier reach your crash aggregator, production crashes arrive as meaningless line numbers. I once let several weeks of crashes accumulate without that pipeline in place, and paid for it in the time it took to reconstruct causes afterward. The procedure is written up in wiring Hermes source maps and debug IDs into your crash aggregator.
What the artifact can tell you is whether the bundle really is Hermes bytecode. A configuration mismatch that leaves plain JavaScript in place will never line up with the source maps you generated. Reading the first eight magic bytes settles it.
Check 4: things that should never have been packaged
The fourth class is, from the build's point of view, entirely correct behavior. It packaged the files it was told to package.
Three kinds put me on guard: bundled source maps, environment files pulled in as assets, and anything resembling a signing key or API credential. Template-generated projects tend to treat the assets directory loosely, which makes stowaways easier. Moments when dependencies grow — adding AdMob mediation adapters, for instance — are worth an extra look.
This one is pure filename pattern matching. There is no judgment call involved, which is exactly why automating it pays off most.
Folding all four into one script
All four checks amount to opening the artifact as a ZIP and scanning what is inside. No extra dependencies, standard library only.
#!/usr/bin/env python3"""Open an artifact (.apk / .aab) as a ZIP and run four checksthat build status alone cannot cover.Usage: python3 preflight_artifact.py app-release.aab --min-sdk 23Exit code: 0 = pass / 1 = findings"""import argparseimport collectionsimport reimport sysimport zipfile# 1) Desugaring: each API has its own minimum level# (java.util.function and Optional need 24, java.time needs 26)DESUGARED_TARGETS = { b"Ljava/util/function/Supplier;": 24, b"Ljava/util/function/Consumer;": 24, b"Ljava/util/Optional;": 24, b"Ljava/time/Duration;": 26, b"Ljava/time/LocalDate;": 26,}DESUGARED_PREFIX = b"Lj$/"# 4) Files that must never ship inside the artifactFORBIDDEN_PATTERNS = [ re.compile(r"\.map$"), # bundled source maps re.compile(r"(^|/)\.env(\.|$)"), # environment files re.compile(r"\.(keystore|jks|p8|p12|pem)$"), # signing / API keys]DENSITY_RE = re.compile(r"^(?:[^/]+/)?res/drawable-([a-z]*dpi)(-v\d+)?/(.+)$")KNOWN_DENSITIES = ["ldpi", "mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"]HERMES_MAGIC = bytes([0xC6, 0x1F, 0xBC, 0x03, 0xC1, 0x03, 0x19, 0x1F])def check_desugaring(zf, min_sdk): """Scan the DEX string pool directly: trust the artifact, not the config.""" dex_names = [n for n in zf.namelist() if re.search(r"classes\d*\.dex$", n)] if not dex_names: return ["No classes.dex found (for an AAB, look under base/dex/)"] raw = b"".join(zf.read(n) for n in dex_names) if DESUGARED_PREFIX in raw: return [] # rewriting is active missing = [t.decode() for t, api in DESUGARED_TARGETS.items() if t in raw and min_sdk < api] if not missing: return [] return [ "minSdk %d references %s but no rewritten classes (Lj$/...) " "are present in the artifact" % (min_sdk, ", ".join(missing)) ]def check_density_coverage(zf): """An image in only one density bucket never reaches other devices.""" buckets = collections.defaultdict(set) for name in zf.namelist(): m = DENSITY_RE.match(name) if m: buckets[m.group(3)].add(m.group(1)) findings = [] for filename, found in sorted(buckets.items()): if len(found) == 1 and found & set(KNOWN_DENSITIES): findings.append( "%s exists only in %s (move to drawable-nodpi/ " "or supply every density)" % (filename, next(iter(found))) ) return findingsdef check_js_bundle(zf): """Confirm the bundle is Hermes bytecode. Plain JavaScript will never line up with the source maps you generated.""" targets = [n for n in zf.namelist() if n.endswith("index.android.bundle")] if not targets: return [] # native-only artifact findings = [] for name in targets: head = zf.read(name)[:8] if head != HERMES_MAGIC: findings.append( "%s is not Hermes bytecode (leading bytes %s)" % (name, head.hex()) ) return findingsdef check_forbidden(zf): findings = [] for name in zf.namelist(): for pattern in FORBIDDEN_PATTERNS: if pattern.search(name): findings.append("Must not ship: %s" % name) break return findingsdef main(): parser = argparse.ArgumentParser() parser.add_argument("artifact") parser.add_argument("--min-sdk", type=int, default=24) args = parser.parse_args() with zipfile.ZipFile(args.artifact) as zf: results = [ ("Backward compatibility (desugaring)", check_desugaring(zf, args.min_sdk)), ("Density bucket coverage", check_density_coverage(zf)), ("JS bundle format", check_js_bundle(zf)), ("Forbidden files", check_forbidden(zf)), ] failed = 0 for label, findings in results: if findings: failed += 1 print("FAIL %s" % label) for line in findings: print(" - %s" % line) else: print("OK %s" % label) print("---") print("%d findings across %d checks" % (failed, len(results))) return 1 if failed else 0if __name__ == "__main__": sys.exit(main())
Run a deliberately broken artifact through it and all four fire:
$ python3 preflight_artifact.py bad.aab --min-sdk 23
FAIL Backward compatibility (desugaring)
- minSdk 23 references Ljava/util/function/Supplier;, Ljava/util/Optional;, Ljava/time/Duration; but no rewritten classes (Lj$/...) are present in the artifact
FAIL Density bucket coverage
- hero_banner.png exists only in xxhdpi (move to drawable-nodpi/ or supply every density)
FAIL JS bundle format
- base/assets/index.android.bundle is not Hermes bytecode (leading bytes 766172205f5f4255)
FAIL Forbidden files
- Must not ship: base/assets/index.android.bundle.map
- Must not ship: base/assets/.env.production
---
4 findings across 4 checks
Run the same artifact with --min-sdk 24 and the Supplier and Optional findings disappear, but Duration stays. java.time arrived in API 26, so devices on API 24 and 25 still lack it. Only at --min-sdk 26 does the first check go quiet. Whether desugaring matters is decided by your distribution target rather than by the artifact, so pass that flag explicitly and keep it aligned with your Gradle minSdkVersion.
I'll admit the first version of this script missed exactly that. It had a single condition — "24 or above, everything passes." The check stayed green while an app that had just started using java.time crashed the same way the original one did, and that was how I learned the check itself had inherited my assumption. Each target class now carries its own minimum API level.
Which artifact to scan: AAB versus APK
A production profile on EAS Build hands you the .aab you upload to Play. The script opens both .aab and .apk, but they show you slightly different things.
Artifact
Path shape
Good for
Watch out for
.aab (what you submit)
base/dex/, base/res/, base/assets/
All four checks, on exactly what you ship
Not the post-split shape a device receives
Universal .apk
classes.dex, res/, assets/
Desugaring, bundle format, forbidden files
Depending on resource shrinking settings, res paths may be shortened, so the density check silently finds nothing
Device-specific APKs from bundletool
Split APKs per device
"Does this image actually reach this device?"
One extraction per device configuration
My rule of thumb: run the acceptance check once on the .aab you submit, and reach for bundletool only when a specific device worries you. Extraction uses Google's bundletool (official docs: bundletool).
# Capture the connected device's configuration (density, ABI, locales, SDK level)bundletool get-device-spec --output=device.json# Build the APK set, then pull out only what that device would receivebundletool build-apks --bundle=app-release.aab --output=app.apksbundletool extract-apks --apks=app.apks --output-dir=extracted --device-spec=device.json# See whether the image made it into any of the extracted splitsfor f in extracted/*.apk; do unzip -l "$f" | grep hero_banner && echo " <- $f"; done
If nothing prints, that device never gets the image. You have confirmed check 2's finding in the actual delivery shape rather than taking the script's word for it.
Triage table for when a check fires
When the script reports a failure, this is the order I work through so I don't stall on where to start.
Symptom (script output)
Likely cause
How to confirm
Fix
Desugaring fails and there is no Lj$/ at all
coreLibraryDesugaringEnabled never reached the build
Open android/app/build.gradle after prebuild and look for it
Inject it with a config plugin instead of hand-editing (prebuild wipes manual edits)
Desugaring fails with only java.time left
minSdk 24–25 while referencing java.time
Rerun with --min-sdk matching Gradle
Enable desugaring, or avoid the API
Density coverage fails
An image lives in a single drawable-*dpi folder
Extract for a low-density device with bundletool and check for the file
Move it to drawable-nodpi/ or supply every density
Bundle format fails (leading bytes 7661…)
Hermes disabled or an engine setting mismatch
hermesEnabled in android/gradle.properties after prebuild
Align on Hermes, regenerate source maps, re-upload them
A .map file in forbidden files
Source map output written under assets
Check the output path in your build script
Write it outside the artifact and upload to your crash tool separately
A .env file in forbidden files
.env sitting inside a bundled folder
unzip -l to confirm the path
Move .env out and keep real secrets on a server
That last row deserves a caveat. Variables prefixed with EXPO_PUBLIC_ are not shipped as files — they are inlined as strings into the JavaScript bundle. The script only catches what slipped in as a file; values baked into the bundle are invisible to it. Where API keys should actually live is covered in Rork environment variables versus a Supabase Edge Function.
Three misconceptions worth correcting
"With minSdk 24 or higher you don't need desugaring."java.util.function and Optional arrived in API 24, but java.time is API 26. Android's own documentation (Java 8+ API desugaring) describes library desugaring as filling in APIs that the device's API level does not yet have. The boundary differs per API.
"Inspecting the APK tells you what users get." A universal APK carries every density and ABI, so a skewed image will still be found. The skew only becomes a symptom after Play splits the bundle per device. To see the post-split shape, extract it with bundletool.
"If the build passed, the source maps match." A source map is a separate file and only means something when paired with its bundle. Shipping Hermes bytecode while uploading a plain JavaScript source map is a mismatch the build status never reports.
A note on fixing config in an Expo project
Projects that come out of Rork are Expo projects, and the android/ folder is regenerated on every npx expo prebuild. Put the desugaring line straight into android/app/build.gradle and the next prebuild erases it. I did exactly that once and watched a fixed crash return in the following release.
These days the Gradle change lives in a config plugin registered under plugins in app.json. Fix in the project config, verify in the artifact — keeping those two places separate means the check keeps giving the same answer across prebuilds. The injection itself is in the desugaring article linked near the top.
Putting the gate outside the loop
Rork Max runs Xcode on a cloud Mac, lets the agent read the errors it produces, and rebuilds — the same cycle a developer runs by hand, automated. The quality of what comes out rests on that cycle. The flip side is that the cycle's only success criterion is what the compiler and linker return.
Which means that once it goes green, the loop has done its job. The four checks above can only live outside it. More iterations and better prompts will not surface something the loop cannot observe.
The arrangement I settled on is deliberately plain:
Let the generate-and-build cycle run untouched — intervening to add iterations has rarely been worth it in my experience
Run the acceptance check exactly once, the moment an artifact exists
Send only passing artifacts into staged rollout, raising the percentage only while Crash-free users holds above the target I set for myself
Running the check when you receive the artifact rather than the night before submission matters because a finding is still actionable then — it folds back into the regeneration prompt. Discovered late, your options narrow to shipping it or delaying.
Green is the loop's word; shipping is the artifact's call. I still feel the urge to meddle with the generation loop now and then, but this is the line I don't move.
To make "right after the build" automatic, I fold fetching and checking into one script. eas build with --json and --wait returns machine-readable output, so the artifact URL can go straight into the check.
#!/usr/bin/env bash# build -> download artifact -> acceptance check, in one passset -euo pipefailMIN_SDK=23 # keep in step with minSdkVersion (android/app/build.gradle or expo-build-properties)URL=$(eas build --platform android --profile production --non-interactive --wait --json \ | python3 -c 'import json,sys; print(json.load(sys.stdin)[0]["artifacts"]["buildUrl"])')curl -sSL -o app-release.aab "$URL"python3 preflight_artifact.py app-release.aab --min-sdk "$MIN_SDK"
Because of set -e, the script stops the moment the check exits with 1. If you chain a submit command after it, a failing artifact never gets that far.
Where staged rollout trips you up next
Passing the acceptance check does not cover the variety of real devices and real people. That is staged rollout's job, and the next question is what percentage to hold at and what to watch before moving on.
Android vitals in Play Console defines a bad behavior threshold for user-perceived crash rate: 1.09% overall and 8% on any single device model, beyond which Google says your app's visibility on Play can be affected (as of November 2026, per Android vitals: crashes). I don't treat those numbers as my target; my own stop line sits well before them. In the first few percent, though, the sample is small and a good-looking number means little. How many users it takes before you can trust it is worked through in reading Crash-free in the first 5% of a staged rollout.
The acceptance check owns what you can know before shipping; staged rollout owns what you can only learn by shipping. Keeping those two jobs apart has been the most useful distinction in my own release routine.
What to try on your next release
Take the most recent artifact you have and run it through the script. An already-published one works too. Which of the four fires tells you which failure class your project is structurally prone to.
Maintaining several apps in parallel, I found the answer differed per app. Image-heavy ones tripped the density check; dependency-heavy ones tripped the forbidden-files check. Rather than fixing everything at once, work down the list of checks that actually fired on your own artifacts. That is the version of this habit that survives contact with a real release schedule.
Share
Thank You for Reading
Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.