"It felt less like using a tool and more like managing a team." OpenAI's Sora Android account describes a shift I consider central to AI-assisted engineering. When several coding sessions are making progress at once, defining their work, guiding their decisions and combining their output becomes a leadership job.
Revision prepared September 28, 2026. OpenAI now states that Sora became unavailable on April 26, 2026. The engineering case discussed here concerns its 2025 Android development.
From individual assistance to parallel work
When you use AI to help write a function, debug an issue or refactor a module, you remain close to each implementation decision. Parallel delegation changes where you spend your attention. You define objectives, establish patterns, provide context, review results and integrate changes across workstreams.
The Sora engineers ran sessions of Codex, OpenAI’s coding agent, on playback, search, error handling, and sometimes tests or refactoring. They reported spending more time directing and reviewing code, with decisions, feedback and integration becoming a bottleneck. They also wrote the architectural foundations, authentication, base networking flows and representative features themselves. Delegation grew from that engineering work.
I see a direct connection to leading a distributed engineering team. Clear objectives, sufficient context for independent work, review without micromanagement, conflict resolution and technical coherence are already part of that craft. Those skills transfer to agent work. The leader remains responsible for deciding what belongs in the system and whether the combined result is good.
The conductor's work
The metaphor I keep returning to is the engineer as conductor. A conductor sets the tempo, cues the sections and brings the parts into a coherent performance. That is a useful way to think about maintaining architectural vision across parallel coding sessions.
It does not require giving up implementation. Writing a representative feature or investigating a difficult subsystem may be the best way to establish the direction. The leadership task is to know where that direct work will make the rest of the team more effective.
Fred Brooks's warning about adding people to a late software project is relevant here: coordination consumes capacity. OpenAI explicitly connected its parallel-session experience to that warning. Each additional session needs context and produces decisions, changes and questions for someone to assess. Adding sessions does not guarantee a proportional reduction in delivery time.
The practical question expands from “How fast can I write this code?” to “How quickly can we make sound decisions and integrate the work?” Implementation may be the constraint that prompts delegation. As output increases, review and integration can become the constraint. Track where the work is waiting.
Define the work before adding a session
Invest in context infrastructure. Keep architecture, conventions and decisions in project records, and make reading the relevant records part of the assignment. Instruction entry points such as CLAUDE.md or AGENTS.md can direct a session to the right material; a CONTEXT.md file is useful when the workflow actually loads it. This is onboarding: the upfront work helps each contributor act with a coherent view of the project.
I would use an existing feature as part of an assignment whenever it demonstrates a convention that prose can leave ambiguous. An example can show where network calls belong, how errors reach the interface, and which tests belong with a change. The assignment still needs to identify which parts of that example are relevant. Otherwise, an agent may reproduce incidental choices along with the intended design.
| Part of the assignment | What it should establish |
|---|---|
| Task boundary | The behavior to change and the files or interfaces likely to be involved. |
| Context | The existing implementation, conventions, and decisions the work depends on. |
| Acceptance evidence | The behavior to demonstrate, the checks to run, and any uncertainty that must be reported. |
| Integration owner | Who will review the change and combine it with the other work. |
Separate feature names don't guarantee independent work. Playback and search could both require a change to the same networking layer. If each session invents that change independently, the team may receive incompatible implementations even when the files merge without a conflict.
Resolve the shared interface first, or give its change to one workstream and make the others depend on it. Keep the decision where all the sessions can read it. A chat message in one session doesn't establish a shared convention for the rest. Project context that survives individual conversations is useful for exactly this reason.
An independent task can also be investigatory. One session might examine a performance problem and return measurements and alternatives while another implements an already agreed change. The investigative assignment should say whether the agent is authorized to edit code; otherwise a request for evidence can turn into another change waiting for review.
Maintain architectural authority. Evaluate the agent's suggestions, make the decision and record the reason. Confidence in a proposed implementation does not settle whether it fits the system.
Manage the queue through integration
Track work waiting for a decision, work waiting for review, and work waiting to be integrated. A growing queue in any one of those states tells you where the next unit of attention belongs.
Suppose a session finishes an isolated test improvement while another proposes a shared data-model change. The first may be ready for review immediately. The second can change the assumptions of every active feature. It deserves a design decision before more implementation accumulates around the old model. Counting both as two completed agent tasks hides that difference.
After combining changes, run the checks that cross their boundaries. An individual workstream's passing tests describe the version it tested. They do not establish that the combined version behaves correctly. Record the revision tested and any manual checks needed to assess the user experience.
Develop your review process as deliberately as your implementation process. You may be reading more code than you write. Check behavior, assumptions and architectural fit, and budget time for reconciliation even when Git reports a clean merge.
More sessions are useful when there is work ready to delegate and capacity to review the results. If the review queue keeps growing, direct effort into resolving it, dividing oversized changes, or clarifying decisions that are holding several tasks up. The appropriate number of sessions follows from the work and the team handling it.
The professional trade
For an engineer who takes pride in writing code, spending more time directing agents can feel like giving up part of the craft. I think the opportunity is worth pursuing. You still determine what gets built, make design tradeoffs and own the quality of the result. Delegating typing, syntax and boilerplate can create more room for that judgment.
Writing code is also a way of thinking. Keep direct implementation where it develops your understanding, tests a design or draws on expertise that would be harder to communicate than to apply. Leadership includes deciding which work to keep in your own hands.
Choose the mode that fits the work
Work directly with AI assistance when:
- You are learning a new technology and need the understanding that comes from implementation.
- The task is self-contained and does not benefit from coordination across sessions.
- You are exploring what to build.
- The work needs your specific expertise as it unfolds.
Delegate parallel workstreams when:
- The project contains work that can proceed independently.
- You have clear patterns for agents to follow.
- Additional implementation capacity would help, and review and integration capacity are available.
- The codebase has conventions that the assignments can make explicit.
An unfamiliar subsystem may need investigation before it offers a sensible boundary for delegation. A tightly coupled change may be easier to implement and review as one sequence. A representative feature may need to be written by a person who is establishing the design.
You can change modes during a project. Establish foundations through close implementation and design work, then use those foundations to support parallel development. The foundation-first pattern is partly a decision about when that transition makes sense.
Start with a bounded assignment and a named reviewer. Record the effort spent clarifying, reviewing and reworking it through integration, then use that experience to decide whether another session would help.
Invest in the leadership skills
Writing usable context, decomposing work, reviewing code, integrating changes and maintaining architectural vision deserve deliberate practice. They determine how much useful work a team can absorb from its agents. For engineers who already lead people, this is an opportunity to apply hard-earned management skills to a new kind of contributor. For those developing those skills, agent work offers another reason to learn them.
I expect this combination of technical depth and leadership to become increasingly valuable. Faster code generation gives engineering judgment more work to do.
This article is part of the synthesis engineering series. For related work on durable project records, see Synthesis Project Management.