Back to database

Alex Embiricos, OpenAI's AI use case

Product / engineering leader at OpenAI

Uses advanced Codex workflows to run multiple engineering tasks in parallel, keep work organized with Plans.md, and route generated changes through GitHub review before merging.

The problem

What was broken before AI

AI coding can get messy when everything happens in one branch or one long chat. A model may make changes that overlap, lose the original plan, or mix experiments with real implementation work. For larger tasks, the human can also lose track of what is being tried, which branch matters, and why a particular change exists. The result is speed without enough structure.

What changed

What the use case made possible

Alex’s workflow adds engineering structure around Codex. Plans.md gives the model and human a shared written target. Git worktrees let multiple branches or experiments happen side by side without overwriting each other. GitHub review keeps generated work inside a familiar review process. The human can compare approaches, inspect diffs, and decide which path deserves to move forward.

Why this matters

Why this use case is worth studying

This use case is valuable because it treats AI coding as orchestration, not just generation. Once models can write useful code, the bottleneck becomes managing parallel work, preserving intent, and reviewing output. Alex’s workflow gives those pieces a shape: plan, isolate, run, compare, review, merge.

Use this when

When this pattern applies

Use this pattern when AI coding tasks are getting too large or too parallel for one branch and one chat. It works especially well when you want to test several approaches, split a feature into smaller pieces, or keep agent-generated work isolated until it has been reviewed.

Exponential Builder analysis

01

Structure beats chat length.

The workflow shows that AI coding improves when intent lives outside the conversation in a durable Plans.md file, where both the human and the model can keep returning to the same target.

02

Parallelism needs isolation.

Running multiple Codex tasks only stays useful if each attempt has its own branch or worktree; otherwise speed turns into review debt and tangled changes.

03

Review remains the control layer.

The value comes from letting Codex explore implementation paths while GitHub review decides what becomes real, preserving the engineering habits that already catch risk.

Who this is for

Best fit

Engineers using Codex

Developer productivity teams

Founders building with AI coding tools

Tech leads experimenting with parallel agents

Teams that want AI speed without messy branches

Anyone running multiple AI coding attempts on the same repo

What to avoid

Mistakes and warnings

Where this pattern can go wrong if you copy it too literally.

Do not let multiple agent runs modify the same branch at once.

Avoid vague plans that leave the model guessing about success.

Do not merge the fastest result without comparing alternatives.

Keep generated branches small enough to review.

Use GitHub review as a real gate, not a formality.

Public workflow preview

The shape of the workflow

A high-level look at how the use case works, with the reusable pattern made clear.

01

Write the plan down first

Plans.md gives Codex and the human a shared target, constraints, and implementation path.

02

Split work into isolated spaces

Git worktrees let multiple tasks or experiments run in parallel without colliding.

03

Let Codex work on bounded tasks

Each agent run gets a clear objective instead of a vague “build this whole thing” request.

04

Compare outputs like branches

The human can inspect diffs, test behavior, and decide which approach is worth keeping.

05

Use GitHub as the review layer

Generated changes still go through pull requests, comments, and human approval before becoming real code.

Copy the pattern

The reusable idea

Pattern in one sentence

Use plans, worktrees, and code review to turn AI coding from one long chat into controlled parallel engineering work.

Reusable idea

Alex’s workflow is a reminder that AI coding gets better when the work is organized like engineering work. If you want multiple agents or runs happening at once, give each one a plan, a boundary, and a review path. The leverage comes from parallel exploration without losing control of the codebase.

Steal this workflow

Use this mini-template for an AI-assisted coding task:

1

Create `Plans.md` with: goal, assumptions, likely files, constraints, acceptance criteria, test commands, and known risks.

2

Split the work into 2–3 bounded tasks or implementation approaches.

3

Create a separate branch or Git worktree for each task.

4

Run Codex in one worktree at a time with the relevant section of the plan.

5

Require each run to summarize its diff and call out anything it skipped.

6

Run the same checks or tests across each branch.

7

Compare diffs for simplicity, safety, maintainability, and fit with the plan.

8

Open the best candidate as a pull request.

9

Use GitHub comments to request revisions before merging.

10

Delete or archive the losing experiments so they do not linger as confusing repo state.

Suggested prompt

“Create a `Plans.md` for this coding task before writing code. Include the goal, assumptions, files likely to change, constraints, risks, test commands, and acceptance criteria. Then implement only the agreed plan in this branch/worktree, avoid unrelated changes, and summarize the final diff against the plan when finished.”

Field notes

Get new AI use cases in your inbox

A short weekly note on how real people are using AI to save time, make money, build tools, and run their lives.

No spam. Just useful AI use cases.

Related use cases

Keep exploring nearby systems.

Browse all