AI Keeps Botching App Development? Three Repos Turn iOS Reverse Engineering Into Skill Packs

AI is getting better and better at writing code, but when it comes to UI, it's still pretty much a disaster zone. What it generates works, but it's ugly—or it always feels like it's missing something.

Recently I came across a few repos that all point in the same direction: breaking down “making a good app” into skill packs that AI can execute.

First: Appllama

AI learns from what the four highest-revenue apps look like.

Appllama is itself a design library that collects real screens, flows, and UI patterns from top apps, along with revenue and download data. Its companion skill pack turns this library into a working method for AI: first study every screen of those winning apps, extract the design language for that category, and then start building interfaces that can match them.

Two core skills:

appllama-usage: the research engine. It connects to Appllama's data via MCP and learns to use the tool like a design director. It includes three approaches: building an app from scratch, improving an existing interface, and researching flows and elements.
appllama-app-design-skill: the build standard. Native-feeling Expo / React Native interfaces, Apple HIG-level fidelity, semantic colors, native controls, and an anti-“faking it” discipline. Navigation must behave correctly (push vs. present, when there should be no back button), animations must be restrained (whether they should move at all, springs should carry the finger's velocity, and they must not run on the JS thread), and finally record the full flow in the simulator and inspect it frame by frame, rather than just calling it done with a screenshot.

Install with one command:

npx skills@latest add appllama/appllama-skills

MCP endpoint: https://mcp.appllama.io/mcp. Pro users' credits reset on the 1st of each month; get_credits is always free.

Second: Official Expo

The Expo team has also released its own official skill pack, covering the full lifecycle of an Expo app: building, deploying, upgrading, and debugging.

The repo contains 16 skills, split into three groups:

Framework (open source and free): project structure, Expo Router navigation, animations (Reanimated + Gesture Handler), native-feeling styles, design systems, data fetching, DOM components, web-to-native, native modules, Dev Client, etc.
EAS services (paid): app store builds and submissions, EAS Hosting deployment, Workflows CI/CD, Observe metrics, Update over-the-air updates, and cloud simulators.
Experimental: module API migrations and other not-yet-stable content.

Installation is a little different. Claude Code and Codex go through the official plugin marketplace; other tools use the skills CLI:

npx skills@latest add expo/skills --skill '*'

All skills share one principle: Expo docs and CLI are the single source of truth, and the skill pack teaches AI how to apply them correctly.

Third: emilkowalski's animation course

From a former Vercel and Linear employee. The core idea in one sentence: AI has no taste.

For the same entrance animation, where ease-out is appropriate, AI picks ease-in; where a semi-transparent shadow is appropriate, AI gives you a solid border. Individually, these are small things; stacked together, they turn into an interface where “you can't quite say what's wrong.”

Two skills stand out in the list: review-animations rigorously reviews existing animations, and improve-animations audits animations across the entire codebase and outputs a prioritized plan. animation-performance specifically targets dropped frames, and apple-design translates Apple WWDC design principles for the web.

Also worth mentioning is break-ui—it attacks your own interface with extreme data: very long names, single letters, empty lists, long labels. Compared with pretty screenshots, these are the real users.

Install:

npx skills@latest add emilkowalski/skills

A Few Observations

All three repos point to the same thing: AI doesn't lack capability; it lacks standards. The value of a skill pack isn't in showing off technical tricks; it's in breaking the word “good” into executable rules and giving models without accumulated aesthetic sense a frame of reference.

One comment was spot on: rather than worrying about whether the screenshot looks right, increase Dynamic Type, turn on Reduce Motion, and walk through the entire flow with VoiceOver. Is the reading order correct? Are the main actions reachable? These are the failures screenshots won't reveal.

Another user's feedback was more direct: when you ask AI for reference apps, you always get the same few outdated familiar faces. The suggestion is to first find 3–5 apps that match your taste and feed them to the agent; the results will be much better.

Repo links: