Update: This version incorporates OpenAI’s December 12, 2025 retrospective, current Codex guidance and OpenAI’s notice that Sora became unavailable on April 26, 2026.
OpenAI's Sora Android case study caught my attention: four engineers, 28 days, an estimated 85% Codex-written code, #1 on the Play Store, a reported 99.9% crash-free rate, and over a million videos in the first day. The effort used roughly five billion tokens.
What interests me more is how they worked. Reading their account felt like finding notes from a parallel universe where someone arrived at the same conclusions I've been documenting in this series — sometimes with different language, sometimes with the same framing.
Onboard a capable colleague
OpenAI's team treated Codex as a new senior engineer. Unwanted view models and misplaced UI logic needed correction. In that setup, Codex could not run the app to judge scrolling or confusing flows.
A new senior hire can write code and understand programming patterns without knowing how your team works. Your architecture decisions, product strategy, user expectations and local shortcuts need to become part of the conversation.
I've used CLAUDE.md files for this purpose in my own work. The practical aim is persistent guidance that travels with the codebase, so each task can start from the decisions the team has already made. The file's loading rules belong to the particular tool; the work of explaining your system belongs to you.
Establish what good implementation looks like
The team abandoned a whole-app generation attempt that produced unreliable code and a poor experience. Their prompt was: "Build the Sora Android app based on the iOS code. Go."
This matches what I've seen repeatedly: teams assume AI coding means describing what they want and getting what they need. That expectation leaves out the architectural and product decisions that turn working code into the right product.
Engineers established dependency injection, navigation, authentication, networking and representative features before scaling implementation. Their reasoning: "The idea was not to make 'something that works' as quickly as possible, rather to make 'something that gets how we want things to work.'"
A representative feature makes an architectural standard concrete. It shows where a dependency enters, which layer owns a decision, how a failure reaches the user, and what the tests need to establish. Once they had examples of well-built features, they could tell Codex: "Build this settings screen using the same architecture and patterns as this other screen you just saw." Foundation-first development gives the rest of the implementation a pattern worth repeating.
Plan changes against a shared understanding
The team corrected Codex's explanation of the system, planned changes together and saved long plans to files.
I've been doing something similar with CONTEXT.md files that capture project state. A durable plan can carry more than a list of edits: it can explain why a new state is needed, which interface must change, and which existing abstraction should remain intact. That makes the next review a comparison against the intended design instead of a search for the intent behind a diff.
A task to add a screen leaves architectural choices open: should it extend an existing component, and which layer owns the new logic? Those decisions affect the files each agent will touch and the changes a reviewer must reconcile.
Manage the work as a team
Parallel sessions covered playback, search, errors and tests. The team wrote: "It felt less like using a tool and more like managing a team."
You are directing agents while maintaining system coherence. The work shifts toward decisions, feedback and integration. Brooks's coordination problem does not disappear when the additional contributors are AI sessions: someone must reconcile their work and maintain the vision. Adding another active task can increase the review queue faster than it increases completed work.
The team described themselves as "the conductor of an orchestra versus simply faster solo players." You need to understand what each part is doing, how the parts fit together, and when one needs to wait for another. More code becomes useful only when the team can turn it into a coherent system.
Decide what the tasks must agree on
Suppose an app already searches a collection of articles. You want to add a toggle that shows only articles the user has saved. One task can implement the server filter while another adds the Android control. Both need the same answer to several questions.
Does filtering happen before pagination? What happens when there are no saved results? If the user switches the toggle during a request, may the older response replace the newer results? A server and a client can each pass their own tests while implementing different answers.
Write the shared decisions before starting the dependent work. For this exercise, I would choose:
| Shared decision | Required behavior in this example |
|---|---|
| Default | Searches without the filter keep their existing behavior. |
| Filtering | Apply the saved-only predicate before pagination. |
| Empty result | A successful search with no matches returns an empty collection. |
| Request order | A response for the previous toggle state cannot replace results for the current state. |
| Failure | Keep failure distinct from a successful empty result so the user can retry. |
Resolve each choice once and make both tasks answer to it.
The pagination decision exposes a useful review case. Imagine the first page contains no saved articles, but a saved article appears later in the unfiltered collection. Filtering only the first page would incorrectly show an empty result. Record that example before implementation; otherwise two locally plausible changes can combine into a visible defect.
Give each task a reviewable work unit
I would write one short task record for each side of the change. It should let a reviewer reconstruct the intended behavior without searching a conversation for the decision that explains it.
| Field | What to put in the record |
|---|---|
| Inputs | The exact source revision, relevant request and response types, and one existing search path to inspect. |
| Outcome | The user-visible behavior this task must add. |
| Shared decisions | The agreed filter, pagination, empty-result and request-order rules. |
| Intended changes | The files or components expected to change, plus any shared interface that needs another owner's agreement. |
| Acceptance | Named cases and expected results, including the pagination example above. |
| Review owner | The person who can judge this change and the decisions that require a second owner. |
| Return evidence | The diff, commands actually run, observed results and any unresolved decision. |
For Codex, the documented instruction filename is AGENTS.md. The current discovery documentation, checked September 28, 2026, describes global guidance and project guidance from the repository root to the working directory, with overrides and size limits. Put enduring conventions there and keep the specific feature plan alongside the work. Verify which instructions the session loaded; finding a file on disk does not demonstrate that its contents governed the implementation.
Fit concurrency to the review work
The server predicate and Android control can progress separately after their shared behavior is settled. Two tasks changing the same response type need a different arrangement. Assign that interface change to one owner, make the agreed version available, then let the dependent work proceed.
Before starting another task, inspect what is already waiting for decisions or review. If every pending change needs the same person's attention, adding more patches increases that person's queue. Resolve the blocked interface or review an existing change before starting another task that depends on it.
For the search example, I would review the server behavior first, then the Android state transitions, and finally the combined flow. The first two reviews can identify defects within each component. The final review checks whether the pieces implement the same contract when connected. Record which stage has passed; “tests passed” alone leaves that distinction hidden.
Check translated behavior on the target platform
Existing iOS and backend code informed a separate Android implementation. AI-assisted translation offers an alternative to a shared framework such as React Native or Flutter: carry the product logic across while keeping each platform’s implementation and design choices. For that project, they made the iOS, backend and Android repositories available together and described their locations and contents in ~/.codex/AGENTS.md.
An existing implementation can supply requirements, but a translation still needs its own checks. For the hypothetical filter, use the same saved and unsaved article data on both platforms and compare which results appear. Then exercise Android-specific state changes: rotate the device, leave and return to the screen, or switch the filter while a request is pending.
A matching response body would not by itself establish correct screen behavior. Conversely, a screen that looks right on one successful request would not establish correct pagination or failure handling. Choose the checks from the behavior you are preserving and the target platform's lifecycle.
For your next change, write the shared decisions and one acceptance case that crosses a component boundary. Give each task its inputs and a named reviewer. Add another concurrent task only when its dependencies are settled and someone can review what it returns.
What this means for synthesis coding
The Sora account reinforces the practices I've been writing about in synthesis coding and the synthesis engineering framework:
- The senior engineer mental model: give a capable agent the context a new colleague would need.
- Foundation-first development: establish architectural patterns before multiplying implementations.
- Persistent context: make the team's decisions available to later tasks and sessions.
- Planning before coding: agree on the intended behavior and design before changing it.
- Engineering leadership: direct the work, integrate the results and keep responsibility for quality.
I regard that convergence as validation of the direction.
The team wrote: "AI-assisted development does not reduce the need for rigor; it increases it."
When AI can produce code at scale, human direction becomes more consequential. Building a compelling product, designing a system that can grow, choosing an algorithm, and judging the experience remain work worth doing. Faster implementation gives engineers more room for that work; taking advantage of it requires understanding the system and leading its development.
The productivity gap between organizations that master human-AI collaboration and those that don't will widen. Access to a coding tool alone will not close it. The practices that make these tools effective require learning, organizational investment and skill development.
For engineering leaders, the question is how quickly you can help your teams develop those practices — and give them the time, context and review capacity to use them.