# Case study: orchestrating AI agents to rebuild a streaming platform on web, iOS and Android

**Role:** lead engineer (sole engineer), contract · **Context:** a Southeast Asian video streaming service (movies, series, live TV and sports) · **Period:** Aug 2026 – Present · **Status:** in testing

## The problem

The service needed its whole platform rebuilt: a viewer website, a staff back office for the catalog, live channels and advertising, the APIs behind both, and native iOS and Android apps. That is normally the work of a team with web, back-end and two mobile specialists. I was the sole engineer, so the real job was to design an agent team that could do the work and a system that could prove the work was right.

## The agent setup

### I plan, agents build

I set the architecture, split the work into small items and decide what counts as done. Agents from two providers (Claude and Codex) build the items. Each agent works in its own branch and worktree, so agents never edit the same files at the same time. Agents wrote nearly two-thirds of the web monorepo's commits.

### One quality gate, the same for everyone

Every change to the web monorepo must pass one check before it lands: a frozen dependency install, lint, type check, tests, builds, unused-code detection, import-boundary rules and a secret scan. My changes and the agents' changes go through the same gate.

### A second agent checks before tests run

The native apps are tested in rounds against the real staging back end. Before a round runs, a second agent checks its plan. Each round records the commit hash of the exact code under test, takes a fresh snapshot of the test account's data, and cleans up every simulator and process it used. A result that cannot be traced to the exact code does not count.

### Agents share devices by handoff

iOS and Android test runs share one test machine. An agent must be handed a device and must hand it back before another agent can use it, so two agents never fight over one simulator.

## What the agents delivered

- **Web platform:** a viewer website, a viewer API, a staff back office and its API in one TypeScript monorepo (React, Fastify, PostgreSQL, AWS). The back office covers live operations, catalog curation and publishing, artwork uploads, captions and subtitles, advertising (VAST ad tags), customers, access groups and roles, account security, the TV guide, analytics and an audit trail.
- **iOS (Swift, SwiftUI):** the website's main viewer features, including on-demand and live playback, native ads, caption and subtitle choice, My List and Continue Watching, and calendar reminders. 272 unit tests and 76 UI tests.
- **Android (Kotlin, Jetpack Compose):** playback with Widevine DRM, WebVTT subtitles, a 7-day TV guide, IMA ads with consent, picture-in-picture, and session data encrypted with an Android Keystore key. About 330 test functions.

## Results

- One engineer and an agent team have rebuilt a streaming platform across **web, back end, iOS and Android** in about ten weeks. It is now in testing.
- **600+ automated tests** written for the native apps, plus the monorepo's test suites, and one quality gate on every monorepo change.
- The staging test rounds found real defects before users could, and each one went into the fix queue, not to users.
- An unsigned iOS release archive builds, and an Android release build has been run. Store release, physical-device testing and full ad-completion testing are still ahead.

## Lessons learned

- **Parallel agents need fully separate state.** Separate branches are not enough if agents share any tool state, so builders also avoid shared scratch areas like git's stash.
- **Heavy test tooling belongs on its own machine.** Simulators compete with agents for disk and CPU, so all simulator work runs on a dedicated test Mac and shuts down after each check.
- **A test result must prove what it tested.** Commit hashes, fresh test-account snapshots and explicit device handoffs were part of the design from the start.

## What I bring to your team

I design agent teams and the checks around them, so a very small team can build a product across web, back end, iOS and Android with the checks a larger team would use, without lowering the bar for what counts as done.

The client's code stays in the client's own repositories.