HW10: Building Mobile Apps

CMU 15-114: Effective Coding with AI

⚠️ Heads-up for iPhone users: If you own an iPhone, we do NOT expect or want you to buy a subscription to the Apple Developer Program. You shouldn't need to, but some documentation (including Expo's own documentation) will try to steer you in that direction. Don't pay for anything for this assignment.

Some additional context: Expo Go is free on both the App Store and the Play Store, and the free version works fine for what we're doing. However, when Expo ships a new version, the iOS app store sometimes lags behind by a few weeks. During those gaps, the only way to get a matching Expo Go is to build your own and side-load it through TestFlight, and that is what needs the paid account. Expo's setup page is misleading and doesn't mention the free download at all. Right now there is no gap: the store apps are current, so just install Expo Go from your phone's app store like any other app. Step 1 keeps you on a matching version automatically.

We recommend a physical phone, Android or iPhone, since that's the whole fun of this assignment. An iPhone needs iOS 16.4 or later. If you'd rather not use your phone, the iOS Simulator (on a Mac) or an Android emulator both work.

If you do end up needing the harder paths, last semester we put together a repo with some Claude-generated instructions for local development builds and Android emulators, plus the Expo-related Claude skills: here in this repo. It was written last semester and we haven't retested it, so I'd recommend just treating this as a rough outline for what might work.
Due Date: Sun. 11/22 at 8:00 PM
Time Estimate: 3–4 hours (up to 6 if you go ambitious)
Deliverables: Code + SPEC.md + REVIEW.md + README + prompt log on GitHub, short video, Google form submission, portfolio entry
You will need a free Expo account and Node.js 22.13 or newer. Both are covered in Step 1.

Assignment Overview

Goal: Build a mobile app capable of running on an actual phone or simulator. You'll use React Native with Expo, a framework that lets you build real iOS and Android apps using JavaScript. To do this assignment successfully in a reasonable amount of time, you must leverage AI thoughtfully. By the end of this assignment, you'll be able to show off a real app that you created.


Why This Matters: Mobile development has traditionally had a very steep learning curve, including specialized languages and complex build tools that differ between Android and iOS. After setting up your environment, using AI tools and React Native with Expo will allow you to build a working app on your phone in as little as an hour. This is still a challenging project, however, and you will be unlikely to succeed unless you practice attention to detail and use the strategies you have learned in class so far.

Examples of what you might build:

You're welcome to come up with your own idea! The key is that it should be something you'd actually want on your phone as more than just a webpage or webapp, and something you'd be excited to show other people. Start simple for this assignment! If you have a bigger idea, save it for your capstone project (since the capstone cannot be an extension of this assignment).

Hardware challenges: Part of the barrier to app development is that certain phones (specifically iPhones) require a paid developer account in order to install your app on your phone. We think we've found a workaround with Expo Go, but if you cannot get your app on your phone for free, it's ok to use a simulator instead.
Learning with AI: This assignment is as much about learning a new framework with AI as it is about the final product. React Native and the Expo framework will almost certainly be completely new to you. When AI generates code using unfamiliar patterns (components, hooks, state, navigation), ask it to explain what unfamiliar parts do and why. Your prompt log should show thoughtful engagement with the code and the AI.
What's new here, and what isn't: You wrote a SPEC.md for HW7, so that part should feel familiar. What's new is the full cycle: you'll hand the spec to an agent, let it build the whole app, then open a second agent to review the result against your own spec and write up what it found. Since you're doing this on a framework you've never seen, your agentic review process matters a lot here, since you can't easily tell good code from bad.

Requirements & Scoring

Core Requirements

Optional Enhancements (for extra ambition, not required)

Scope advice: A simple, polished 2-screen app is better than a buggy 5-screen app. Get the basics working first, then add features if you have time. Students often underestimate how satisfying a clean, simple app can be when it actually runs on your phone. Be aware that using external APIs, phone sensors, and other sophisticated features may make it very hard to achieve a working app without a reasonable understanding of the code and how the Expo framework works.

What You Must Submit

Grading

Grade (Roughly) What We're Looking For
A (90-100) App can be demoed and has at least 2 screens with navigation, meaningful user input, and data persistence. Looks intentional and polished. A specific SPEC.md committed before any code, and a REVIEW.md you clearly read and acted on. Clean README and prompt log that meet the assignment specifications and show learning (asking AI to explain, not just generate). Evidence of 3-4 hours of effort and some creativity in the concept. Video clearly demonstrates the app.
B (80-89) App runs and has most core features working (screens, input, persistence). Functional but may look rough around the edges. Spec and review are present but thin, or the review's findings were left unaddressed without explanation. README and prompt log present but less detailed. Video might be a little unclear.
C (70-79) App runs but may be missing one core feature (e.g., no persistence, or only one screen). Basic README, prompt log, and video. Spec or review missing. Limited evidence of the learning process.
Below C App does not run, or submission is incomplete.

Step-by-Step Instructions

Follow these steps in order, and read carefully. Each one builds on the last, and this sequence is designed to minimize the time you spend stuck. If any step takes significantly longer than the time listed, please ask on Ed or come to office hours!

Step 1: Set Up Your Environment (25 minutes)

Read this entire step before you start typing. Everything you need is written out below, and all of it was verified in November 2026. Expo released a new version in October, so several of the commands you'll find in older tutorials and blog posts no longer do what they say. Expo's own documentation is linked throughout if you want more detail, but parts of it are out of date and parts of it are aimed at production apps rather than a one-week assignment. Where this page and Expo's docs disagree, follow this page.

For iPhone:

Install Expo Go from the App Store like any other app. You don't need a Mac and you don't need XCode. (XCode is only required if you'd rather use the iOS Simulator than a real phone. If that's your plan, start the App Store download right now, since it takes about an hour.)

For Android:

Search for "Expo Go" in the Google Play Store and install it. Alternatively you can download a beta version of the Expo Go app if you wish to use the very latest version, but we don't recommend this since you'll probably have to unlock dev options on your phone.

For Everyone:

You need Node.js on your computer, an AI-enabled code editor (you probably already have VS Code or Cursor), and a free Expo account.

You will be running commands in your computer's terminal. For Windows this is the Command Prompt, and for macs this will be the Terminal. We don't recommend trying to run these in VS Code. These are not Python commands!

  1. Install Node.js (if you don't already have it): Download the LTS version from nodejs.org. After installing, verify it works by running node --version in your terminal. Expo now requires Node 22.13 or newer, and the current LTS is Node 26. If you already have Node 18 or 20 installed from an earlier assignment, you will need to upgrade for this one.
  2. Make a free Expo account at expo.dev. This is new and it is not optional: Expo Go only opens your project when the Expo CLI on your computer and the Expo Go app on your device are signed into the same Expo account. Open Expo Go on your device and sign in now. You'll sign in on your computer in step 4.
  3. Create your project. In your terminal, go to wherever you keep your coursework and run exactly this:
    npx create-expo-app@latest
    It will ask you for a project name. Don't add a --template flag, even though Expo's "Create a Project" tutorial shows one and your AI will probably suggest one. Without the flag, the tool asks Expo which version the current Expo Go supports and builds your project to match. It then prints the template it used, naming the SDK, like default@sdk-58. Write down that number, because your README has to report it.
  4. Sign in on your computer. Move into your new project folder (cd your-project-name) and run npx expo login, using the same account you just signed into Expo Go with. If the two don't match, the QR code will scan and then nothing will happen.
  5. Start the development server by running npx expo start. It will take a moment to load, and then it will show a QR code in your terminal. On a phone: make sure you're on the same wifi network as your computer, then scan the code. iPhone users scan it with the built-in Camera app, and Android users scan it from inside the Expo Go app. You should see a default welcome screen appear on your phone. On a simulator: press a for an Android emulator or i for the iOS simulator, and Expo will install Expo Go into it for you.
  6. Don't delete the starter code. Expo's "Start developing" page is worth skimming for the developer tools, but it walks you through clearing out the example app. Skip that part, since you'll want the starter code in Step 2.
If you do end up in Expo's environment setup pages: they'll ask whether you want to develop with Expo Go or a development build. Choose Expo Go. Development builds are right for a production app but not for a one-week assignment. Those pages will also steer iPhone users toward the paid Apple Developer Program, eas go, and TestFlight. Ignore all of that, for the reasons in the red box at the top of this page.
Important: Your phone and computer must be on the same Wi-Fi network for Expo Go to connect. If you're on campus, CMU-SECURE should work. If the QR code doesn't connect, restart the server with tunnel mode instead: npx expo start --tunnel. Tunnel mode routes through Expo's servers, so it reloads noticeably more slowly, but it gets through network setups that block the direct connection. Ask on Ed if you're stuck—this is a common setup hiccup.
We very very strongly recommend using AI within your IDE, like Copilot, Claude Code, Cursor, etc. You'll have an extremely bad time if you have to constantly copy things into and out of your browser.

Optional but extremely useful: Install the Expo AI skills. This was a hassle when we last ran this assignment, and it is now one command:
claude plugin install expo@claude-plugins-official for Claude Code, codex plugin add expo@openai-curated for Codex, or npx skills add expo/skills for anything else.
That installs roughly 35 skills covering Expo Router, navigation, native UI, SDK upgrades and more, and for Claude Code and Codex it also registers Expo's own MCP server. This should look familiar: it is exactly the kind of toolkit you built by hand in HW8, except maintained by the people who wrote the framework. These aren't required, but they give your agent real documentation to work from instead of whatever it remembers about an older version of Expo.

Step 2: Understand the Basics with AI (10 minutes)

Before you start building, spend a few minutes getting oriented. The default project uses Expo Router, which means your screens live in a src/app/ folder and each file in it becomes a screen. Open src/app/index.tsx, which draws the first screen you saw, and ask AI some questions:

Try making a small change to the app, like changing the text or a color, and watch it update on your phone in real time. (If it does not update immediately, you can go to your terminal and press 'r' to reload the app.)

Also check for AI-related settings or agent instructions: projects may include files such as AGENTS.md or .claude/settings.json that explain how AI tools should work with the project. Review any such files before Step 4, since your agent may follow them.

Step 3: Write Your App Specification (30 minutes)

Before you write any code, write a detailed specification for your app in a file called SPEC.md. This should feel familiar from HW7, where your spec had to be clear enough for a classmate to build from. This is the most important step. As before, write this spec yourself and be thorough. This will help ensure that the app matches your vision and works well.

Keep your app idea simple: two screens, one or two key interactions, and one type of data to persist is plenty.

The part that matters most for Steps 4 and 5 is your numbered acceptance criteria. Write each one so that someone could check it off by using the app, without needing to ask you what you meant. "The app should feel responsive" can't be checked. "Tapping Save returns to the home screen and the new entry appears at the top of the list" can.

Useful SPEC.md template: I created this blank SPEC.md template to help me with this step, and I found it very useful. You may not need all of these fields, but we recommend you start by copying this template and then modifying it to suit your needs.

Step 4: The Agentic Build (45 minutes)

Now you hand your spec to an agent and let it build the whole app. This may be different from how you've mostly worked so far: instead of asking for one piece at a time and steering as you go, you write everything down first and then get out of the way.

Setup

  1. Add your SPEC.md into the project folder, add the folder to Github (in Github Desktop, click the current repository, click add, and click "add existing repository", and select your project folder) and make your first commit and push. Verify that you can see the app on github.com before proceeding.
  2. If you're lost, make sure you've completed the environment setup from Steps 1 and 2.
  3. Open the project folder in VS Code or Cursor or another AI-enabled IDE, and make sure your assistant is in agent mode rather than ordinary chat. It needs to be able to create files and run terminal commands on its own.

The Prompt

You might want to set your Agent to its most powerful setting for this step (bearing your usage limits in mind). Give your agent a prompt like this (adapt it to your actual spec):

Read SPEC.md in this project. Implement the full mobile app exactly as specified.
This is an Expo project using Expo Router, so screens belong in src/app/.
Check package.json for the exact Expo SDK version and write code for that version.
Create all necessary files, components, and navigation. Make sure that appropriate data is persistent.
Avoid security risks for sensitive data.  Include proper error handling.
Make sure the app starts without errors and displays the home screen correctly.

Reminders

Step 5: The AI Review (45 minutes)

Now you check the build against your spec, using a second agent that hasn't seen the conversation that produced the code. (Recall that the agent that wrote the code will be a bad judge of it: it will tend to agree that it did what it was asked. A fresh agent reading only your spec and the code has no such investment.)

Review Setup

  1. Open a new chat session and make sure you're in Agent mode. Starting fresh is crucial, so resist the urge to continue the build conversation.

The Review Prompt

Give this new agent a prompt like:

Review the React Native/Expo code in this project against the spec in SPEC.md.
For each acceptance criterion in the spec, verify whether the code actually implements it correctly.
Also check for:
- Bugs or logic errors
- Missing error handling
- Code quality issues (unclear naming, repeated code, etc.)
- Best practices for React Native or other technologies

Format your review as a numbered list of findings, each marked as [PASS], [FAIL], or [WARN].
Be specific. Reference file names and line numbers.
Do not fix anything in this session. Report only.
Export the review as REVIEW.md at the root of the project.

Act on the Review

Step 6: Polish, Test, and Verify (30 minutes)

With the core features working, now polish your app:

Step 7: Document and Submit (30 minutes)

Write your README and prompt log, record your video, add the project to your portfolio, push to GitHub, and fill out the Google form.

For the video, the easiest approach is to screen-record your phone or simulator, or to simply record your phone screen with another device. Walk through each screen, show the user interactions, and demonstrate data persistence.

Important: Your prompt log should include actual prompts, verbatim. Some recommended examples include:

Key Concepts

Here's a reference for the new concepts in this assignment. AI will help you with all of these, but it's useful to know what you're working with.

Tips

Setup Resources

React Native Resources

Troubleshooting

Questions? Ask on Ed, attend office hours, or email the instructor. Consult the course AI usage and collaboration policies on the course homepage.