How to Auto-Generate App Demo Reels After Every Successful Build (Step-by-Step Tutorial)

Shipping a new iOS build is satisfying.

Shipping it with a clean demo reel attached to the same pipeline is leverage.

This step-by-step tutorial walks you through how to:

• Capture polished Mac screen footage from the iOS Simulator
• Record in short passes instead of one long take
• Trim, pace, and prep files for AI tools like Reely
• Wire this into a CI/CD flow so every successful build can produce a fresh app demo

The focus is practical: you can follow each step independently, or plug the whole thing into your existing workflow.

Related reading: for a deeper comparison of capture approaches, see our pillar guide “App Preview Generators Compared: Simulator-Based vs Screen Capture.”

Why Auto-Generate App Demo Reels After Every Build?

Before we dive into the how, it’s worth grounding the why.

The App Store is crowded and visual. In 2025 there were 2.42 million apps and games on the App Store, with 36.6 billion downloads and over 800,000 active publishers according to Business of Apps.

Apple’s own ecosystem study reported the App Store facilitated over $1.4 trillion in global billings and sales in 2025.

Amid that noise, your creatives carry outsized weight:

• AppTweak found the average US App Store conversion rate is just 8.56%.
• Apple lets you upload up to three 15–30 second App Previews per language that autoplay in search and on your product page.
• Those previews can also be reused in Apple Ads.

The takeaway: every build that improves your product is a chance to improve your listing.

If you can go from “build passed” → “launch-ready demo reel” in minutes, you can iterate on creative as fast as you iterate on code.

Prerequisites: What You Need Before You Start

You don’t need a full video team to do this.

You do need a minimal stack that respects developer workflows.

Tools and setup

• Mac with Xcode
  • To run the iOS Simulator and your app builds.
• Your app running in the iOS Simulator
  • Ideally the same build you ship via CI.
• Screen recording capability
  • Built-in macOS screen recording (Screenshot tool or QuickTime), or
  • A dedicated screen recording tool (e.g., Screen Studio, CleanShot X, etc.).
• Reely (recommended)
  • Native macOS app to turn simulator footage into launch-ready reels.
  • Optional MCP/agent integration if you want automation from your coding agent.
• Basic CI/CD
  • GitHub Actions, GitLab CI/CD, Bitrise, or similar.
  • A way to export build artifacts (IPA, screenshots, or recorded footage).

Optional, but powerful

• App Store Connect API access
  • To upload App Previews programmatically.
• AI coding agent with MCP/agent tools
  • So the same agent that ships your feature can orchestrate demo capture and Reely.

Once you have these in place, you can follow the steps below.

Step 1: Plan a Tight Story for Your Demo Reel

The fastest way to ship a clean demo is to plan a short, focused story.

Apple’s guidance for App Previews maps well to any demo reel:

• Tell one clear story per video.
• Keep everything inside the app — no over-the-shoulder or hand shots.
• Use on-screen copy because previews play muted by default.

Define your “one job” per video

For each reel, answer:

• What is the single outcome?
  • Example: “Show how fast it is to create a new workout plan.”
• What are the 3–5 key beats?
  • Open app → Navigate to feature → Complete task → See payoff.
• Where does the story end?
  • On a satisfying state (success screen, chart, confirmation, etc.).

Write this as a short flow spec your agent or Reely can reuse later:

“From home, tap ‘New Plan’, pick template, customize name, start timer, show success state.”

This spec becomes the source of truth for both your manual capture and any auto-generated reels via Reely.

Step 2: Record in Passes, Not One Long Take

Long, single-take recordings are hard to edit and easy to mess up.

Instead, capture your flow in short, clean passes.

2.1 Set up the iOS Simulator

• Launch the iOS Simulator from Xcode.
• Select the target device you want for your video (e.g., iPhone 16 Pro).
• Set zoom to 100% so the simulator matches native resolution.
• Disable notifications and distractions on your test environment.

2.2 Use macOS screen recording

You can use macOS’ built-in tools:

• Press Shift + Command + 5 to open the Screenshot toolbar.
• Select “Record Selected Portion”.
• Drag to frame just the simulator window.
• Click Options to set:
  • Save location (e.g., a "Build Demos" folder).
  • Microphone: typically None (you’ll add music/FX later).

Or use a dedicated recorder:

• Tools like Screen Studio can automate zooming and cursor smoothing.
• They’re helpful for generic screen demos, but for iOS App Previews, captured simulator footage is usually best.

2.3 Break the flow into clips

Record each beat as a separate pass:

1. App launch and initial state
   • Start recording, bring app to foreground, land on the home screen.
   • Stop recording once the screen is settled.
2. Navigation to feature
   • Start recording, perform the taps/gestures cleanly.
   • Stop once you reach the feature screen.
3. Core interaction
   • Start, perform the key action (create item, drag object, etc.).
   • Stop when the action is visually complete.
4. Payoff state
   • Start, show the success / summary / result.
   • Pause for 2–3 seconds on the final state, then stop.

Short passes make it easier for Reely (or any editor) to:

• Remove dead air.
• Reorder beats if needed.
• Apply motion presets per clip.

Name your clips clearly: build-1234_new-plan_01-launch.mov, ..._02-nav.mov, etc.

Step 3: Trim and Clean Clips Quickly

Your goal is a folder of tight, focused clips ready for tools like Reely.

3.1 Use QuickTime or your recorder to trim

For each clip:

1. Open the file in QuickTime Player.
2. Go to Edit → Trim.
3. Drag the start/end handles to:
   • Remove any cursor fumbling.
   • Cut the lead-in delay before any motion.
   • Leave 0.5–1 second of breathing room at the end.
4. Save.

If you used a tool like Screen Studio:

• Use its quick trim, speed up, and crop controls.
• Avoid heavy zooming that breaks native resolution — Apple recommends straightforward transitions and native UI framing for App Previews.

3.2 Keep cuts rhythmic

Clueso’s guidance on tasteful screen recordings applies here:

• Nothing on screen should be accidental.
• Each clip should support a single goal.
• Rhythm matters more than fancy transitions.

Aim for:

• 2–5 second clips for fast social teasers.
• 5–10 second clips for key moments in a 30–60s launch promo.

Once trimmed, move all your clips into a build-specific folder, e.g., reels/build-1234/footage.

Step 4: Prep Files for Reely and Other AI Video Tools

Now you have clean simulator footage.

Next, you’ll prep it so tools like Reely can auto-generate your demo reels.

4.1 Match Apple’s App Preview requirements (if applicable)

If you want these reels to double as App Previews, keep Apple’s specs in mind:

• Length: 15–30 seconds.
• Max file size: 500 MB.
• Frame rate: up to 30 fps.
• Codec: H.264 or ProRes 422 HQ.
• Device-specific resolutions: must match the target device.

You can combine your trimmed clips into a single 15–30s composite in Reely, then export a master that fits these constraints.

4.2 Structure your folders for automation

Consistency is friendlier to both AI tools and CI.

Use a structure like:

• reels/
  • build-1234/
    • footage/
      • 01-launch.mov
      • 02-nav.mov
      • 03-core.mov
      • 04-payoff.mov
    • spec/
      • flow.json (your written flow beats)

This makes it trivial for Reely’s agent or MCP tools to:

• Discover footage for a particular build.
• Map clips to story beats.
• Regenerate updated reels when flows change.

Step 5: Turn Footage into Launch-Ready Clips with Reely

This is where Reely comes in.

Reely is an AI-native app launch video generator built specifically for mobile developers.

It takes your code, screenshots, or simulator footage and turns them into:

• 10–20 second feature teasers
• 30–60 second full launch promos

5.1 Import footage into Reely

In the Reely macOS app:

1. Create a new project for your build (e.g., v1.3.0 – Smart Plans).
2. Drag your trimmed .mov files from footage/ into Reely.
3. Optionally, attach your flow.json or paste your flow spec so Reely understands the narrative order.

Because Reely is built around the iOS Simulator:

• It can recreate flows in the simulator if you want capture automated.
• It keeps every scene layer editable (device, UI, type, backgrounds).

5.2 Let Reely handle pacing and motion

Reely bundles a studio-level motion system into a developer-friendly wrapper:

• Kinetic typography systems for titles and callouts.
• Device choreography presets (slides, tilts, reveals).
• Auto-cut dead air and tune editorial pacing.
• Music and sound cue timing aligned with scene beats.

You can pick from:

• Feature teaser template (10–20s)
• Launch promo template (30–60s)

Then:

1. Select your primary flow.
2. Choose aspect ratios (e.g., 16:9 for YouTube, 9:16 for Shorts / Reels, 4:5 for feeds).
3. Let Reely generate a first pass.

Because Reely is local-first:

• Rendering happens on your Mac.
• No builds or footage are uploaded to the cloud.

5.3 Apply brand-theme-from-app

Reely can infer your visual identity directly from your app:

• Pulls colors and typography cues from your live UI.
• Applies them to titles, backgrounds, and device frames.
• Keeps everything cohesive across multiple reels.

This means you don’t need to maintain separate brand kits for each video — your app is the brand.

5.4 Export master files

Once you’re happy with the reel:

• Export 4K masters for long-term use.
• Export platform-specific versions:
  • App Store Previews (device-specific, 15–30s).
  • Product Hunt launch trailer (landscape).
  • X / LinkedIn / YouTube Shorts (vertical).

Save them alongside your build artifacts:

• reels/build-1234/output/app-store-preview-1.mov
• .../product-hunt-trailer.mov
• .../shorts-feature-teaser.mp4

These outputs are now ready for manual upload or automation.

Step 6: Wire It into CI: From Successful Build to Demo Reel

Now let’s close the loop.

A build-triggered demo-reel pipeline is technically feasible today.

GitLab CI/CD, GitHub Actions, and others already let you:

• Run build jobs.
• Trigger downstream pipelines.
• Pass artifacts between jobs.

Apple’s App Store Connect API lets you:

• Upload App Previews and screenshots programmatically.
• Reserve, upload, commit, and verify assets via the same flow used for screenshots.

The missing piece has been the creative composition layer — which is exactly what Reely fills.

6.1 High-level pipeline design

A simple downstream pipeline could look like:

1. Build job
   • Run tests and build your app.
   • If successful, export an IPA and any required config.
2. Demo capture job
   • Spin up a macOS runner.
   • Use the iOS Simulator + Reely agent to:
     • Launch the app.
     • Run through the predefined flow.
     • Capture footage to reels/build-1234/footage.
3. Reely render job
   • Invoke Reely’s MCP/agent tool.
   • Pass the flow spec and footage.
   • Generate feature teaser + launch promo.
4. Asset publish job (optional)
   • Use App Store Connect API to upload the new App Preview.
   • Or push files to a storage bucket / Slack channel / marketing repo.

This matches GitLab’s pattern of downstream pipelines and artifacts, and leverages Apple’s reserve → upload → commit → verify flow for App Previews.

6.2 Start manual, then automate

If full automation feels heavy, start with a semi-automated loop:

• CI posts a message (Slack or email) when a build passes with a link to the reels/build-1234 folder.
• You run Reely locally, generate the reel, and export.
• Over time, move steps into scripts and agent tasks.

The goal is to have every meaningful build come with:

• A fresh feature teaser.
• An updated launch promo you can post on X, Product Hunt, or your site.

Step 7: Reuse and Experiment on Your App Store Listing

Once you have a reliable pipeline, you can treat creative like code.

Apple’s Product Page Optimization supports up to three alternate treatments per product page, including alternate previews.

You can:

• Test different storylines (onboarding vs. core feature vs. social proof).
• Try different pacing or typography systems in Reely.
• Measure performance in App Analytics.

Because Reely can regenerate reels from the same flow spec:

• You don’t need to recapture everything for each experiment.
• You can iterate rapidly as your product evolves.

When you’re ready for an in-depth look at capture approaches, revisit the pillar article “App Preview Generators Compared: Simulator-Based vs Screen Capture” to see where simulator-based tools like Reely shine vs. generic screen recorders.

FAQ: Auto-Generating App Demo Reels

How long should an app demo reel be?

For App Store Previews, Apple requires 15–30 seconds.

For social and launch videos:

• Feature teaser: 10–20 seconds.
• Full launch promo: 30–60 seconds.

Shorter is usually better, as long as you complete the story.

Can I use the same reel for the App Store and social media?

Yes, with some adjustments.

A Reely project can generate multiple aspect ratios from the same flow:

• Use the 15–30s, device-specific export for the App Store.
• Use 16:9 or 9:16 variations for YouTube Shorts, X, Instagram, and Product Hunt.

Keep copy and visuals timeless to avoid frequent re-recording.

Do I need a dedicated screen recording tool, or is macOS enough?

macOS’s built-in screen recording is enough for most iOS demo workflows.

Dedicated tools like Screen Studio add conveniences (auto-zoom, cursor smoothing), but for simulator-based App Previews, capturing the simulator window at native resolution is typically preferred.

Reely is focused on turning that footage into motion, not on being the recorder.

Does Reely upload my app or footage to the cloud?

No.

Reely is a native macOS app that:

• Works with the iOS Simulator.
• Renders locally on your machine.
• Keeps your builds and footage on-device by default.

That means you can generate reels for unreleased or confidential builds without sending anything to external servers.

How much does it cost to run a pipeline like this?

Tooling in this space is priced for indie devs and small teams.

• Screen recording tools: often around $20/month or ~$9/month billed yearly.
• Reely: simple monthly/annual plans plus an honor-based offer where you can pay less in exchange for spreading the word.

Most teams treat this as a small subscription stack alongside their CI, analytics, and crash reporting tools.

Wrap-Up: Promo from Code in Minutes

If your agent can build the app, it should be able to build the demo reel too.

By:

• Planning a short, focused flow
• Recording in clean passes from the iOS Simulator
• Trimming quickly and structuring your footage
• Letting Reely handle motion, pacing, and branding
• Wiring it all into CI on your terms

…you turn every successful build into an opportunity to tell a better product story.

You don’t need to become a video editor.

You just need a pipeline where your code is the source and Reely turns it into motion.