In November they launched the Sora app for Android and, within 24 hours, users generated more than one million videos. How do you go from an internal prototype to the number-one spot on the Play Store in less than a month? The main answer: a small team supported by Codex and a work discipline designed to leverage AI, not to let it run without guidance.
How they did it: team, pace and results
A team of four engineers worked alongside Codex between October 8 and November 5, 2025. They consumed around 5 billion tokens and delivered the production release in 28 days. In numbers: globally launched app, 0.1 percent crash rate (99.9% crash‑free) and more than one million videos created in the first 24 hours.
They didn’t use a “secret model”: they used an early version of GPT-5.1-Codex, the same one available to developers via CLI, IDE extensions, or web. The strategy was clear: few people, lots of amplified capacity from Codex, and careful architecture.
Why four engineers and not a huge team? Because adding people late usually worsens coordination. Here, instead of adding bureaucracy, they bet on boosting individual productivity with Codex while keeping high technical quality.
Where Codex contributes most and where it needs human direction
Codex showed clear advantages:
- It reads and understands large codebases quickly, and can translate logic between languages (for example, Swift to Kotlin) while keeping semantics.
- It’s enthusiastic about writing tests: it helps cover many cases and avoids trivial regressions.
- It responds well to feedback: pasting CI logs and asking for fixes produced useful results.
- It lets you try many ideas in parallel: disposable sessions to experiment without risk.
- It contributes design and optimization perspectives, like improvements in the video player’s memory usage.
But it’s not perfect. These are the limitations to keep in mind:
- It doesn’t infer what you don’t give it: preferred architecture, internal standards, or how you want the app to feel.
- It can’t see or feel the experience: it won’t open the app on a device to notice a weird scroll.
- It requires onboarding per session: each instance needs clear context, rules, and goals.
- It tends to prioritize solutions that work fast over long-term architectural decisions.
In short: Codex is a very fast engineer, but it needs you to tell it how your team does things.
Good practices that worked in Sora
It wasn’t a matter of telling Codex 'do it and that’s it'. They implemented rituals and context files that made the difference:
- Document rules in
AGENTS.mdand in~/.codex/AGENTS.mdso every session knows the repos and conventions. - Build a solid architectural base first: key modules, dependency injection, navigation, authentication and networking.
- Write a few representative end‑to‑end features to show the agent the “right style.”
- Ask Codex to read related files and summarize how data flows before assigning work. Then correct that understanding and create a plan.
- Break work into small plans and save them to files to get around context limits and allow long runs without constant supervision.
That flow let Codex work “unsupervised” for long stretches, because humans reviewed plans rather than diffs without context.
Shift in work dynamics: from writing to directing
With Codex the speed of code generation exploded. The bottleneck stopped being typing and became deciding: reviewing PRs, giving feedback and consolidating integrations. It felt like conducting an orchestra with many fast assistants; each new virtual "pair" required coordination.
They also discovered that using the iOS code as a concrete example —instead of only describing functionality in natural language— was decisive. Two clear principles emerged:
- Logic is portable: models, validations and business rules translate across platforms.
- Concrete examples are powerful: showing how something works on iOS and how Android is structured allowed Codex to generate coherent implementations.
The team estimates Codex wrote about 85% of the code, while humans made the architecture, UX and long‑term quality decisions.
What this means for developers and teams
If you’re wondering whether AI replaces engineers: no. What changes is the focus. Codex can take care of repetitive tasks, boilerplate and rapid exploration; you can concentrate on the creative and systemic parts of the product.
Practical tips to get started:
- Give context: don’t expect Codex to guess your design patterns.
- Document 'how we do things' and make it accessible to the agent.
- Plan before asking for big changes: a small plan is worth more than a thousand incoherent lines.
- Review and direct: human oversight remains the quality guarantee.
Final reflection
Sora for Android is an example of how AI can multiply capabilities when integrated with human discipline. It’s not instant magic: it’s a change in how you work. Codex speeds up development time, but it demands rigor, clear architecture and well-informed human decisions.
Ready to experiment with your own “Codex team”? Start by giving context and building a base that anyone —human or agent— can understand.
Original source
https://openai.com/index/shipping-sora-for-android-with-codex