How I AI

The power user’s guide to Codex | Alexander Embiricos (product lead)

Alexander Embiricos, the product lead for Codex at OpenAI, shares practical workflows for getting the most out of this AI coding agent. In this episode, he demonstrates how both non-technical users and experienced engineers can leverage Codex to accelerate development, from making simple code changes to building production-ready applications. Alex walks through real examples of using Codex in VS Code and terminal environments, implementing parallel workflows with Git worktrees, and creating detailed implementation plans for complex projects. He also reveals how OpenAI uses Codex internally, including how they built the Sora Android app in just 28 days, and offers insights on automated code review and the future of AI-assisted development. *What you’ll learn:* 1. How to set up and use Codex in VS Code and terminal environments for both simple and complex coding tasks 2. A practical workflow for running multiple Codex instances in parallel using Git worktrees to avoid conflicts 3. How to create detailed implementation plans using the Plans.md technique for complex engineering projects 4. Why context is critical when prompting Codex—and how to provide the right information for better results 5. How OpenAI uses automated code review to accelerate development while maintaining high quality standards 6. The key differences between vibe coding for prototypes versus building production-ready applications with AI 7. How the new GPT-5.2 model improves Codex’s capabilities with faster reasoning and better problem-solving *Brought to you by:* Brex—The intelligent finance platform built for founders: https://brex.com/howiai Graphite—Your AI code review platform: https://graphitedev.link/howiai *Detailed workflow walkthroughs from this episode:* • 3 Advanced Codex Workflows for Faster, Smarter Development with OpenAI’s Alex Embiricos: https://www.chatprd.ai/how-i-ai/advanced-codex-workflows-with-openai-alex-embiricos • How to Use OpenAI Codex to Understand and Modify a New Codebase: https://www.chatprd.ai/how-i-ai/workflows/how-to-use-openai-codex-to-understand-and-modify-a-new-codebase • How to Architect Complex Software Projects with OpenAI’s Plans.md Technique: https://www.chatprd.ai/how-i-ai/workflows/how-to-architect-complex-software-projects-with-openai-s-plans-md-technique • How to Manage Parallel Development with AI using Git Worktrees and Codex: https://www.chatprd.ai/how-i-ai/workflows/how-to-manage-parallel-development-with-ai-using-git-worktrees-and-codex *In this episode, we cover:* (00:00) Introduction to Alex and Codex (02:06) Getting started with Codex (04:54) Using Codex for parallel tasks (07:34) Understanding Git worktrees (09:51) Terminal shortcuts and command-line efficiency (12:16) How OpenAI built the Sora Android app with Codex (15:37) Using PLANS.md for problem solving (20:23) Using Codex for prototyping (22:22) Deciding between what needs a plan and what doesn’t (26:42) How to multiply the impact of Codex (28:08) Implementing automated code review with GitHub (30:01) Codex adoption at OpenAI (32:08) Challenges and innovations in AI integration (36:38) Recap and the Codex harness (43:49) Atlas and personalized AI interactions (49:09) Conclusion and final thoughts *Tools referenced:* • Codex: https://openai.com/blog/openai-codex • VS Code: https://code.visualstudio.com/ • Cursor: https://cursor.com/ • Git: https://git-scm.com/ • GitHub: https://github.com/ • Atlas: https://openai.com/atlas • ChatGPT: https://chat.openai.com/ • Slack: https://slack.com/ • Linear: https://linear.app/ *Other references:* • Sora app: https://openai.com/blog/sora • GPT-5.2 model: https://openai.com/index/introducing-gpt-5-2/ • SWE-bench: https://openai.com/index/introducing-swe-bench-verified/ *Where to find Alexander Embiricos:* LinkedIn: https://www.linkedin.com/in/embirico X: https://x.com/embirico *Where to find Claire Vo:* ChatPRD: https://www.chatprd.ai/ Website: https://clairevo.com/ LinkedIn: https://www.linkedin.com/in/clairevo/ X: https://x.com/clairevo _Production and marketing by https://penname.co/._ _For inquiries about sponsoring the podcast, email jordan@penname.co._

AEAlexander EmbiricosguestCVClaire Vohost

Jan 12, 2026·53m·Watch on YouTube ↗

📖 CHAPTERS

1. 1

   Codex as a thorough “software engineering teammate” (setup + what it’s good at)

   Claire introduces Alexander Embiricos (Codex product lead) and frames Codex as a coding agent optimized for diligence and complex tasks rather than raw speed. The episode’s goal is a practical, zero-to-one walkthrough from install to advanced workflows.

2. 2

   Installing the Codex VS Code extension and running a repo locally

   Alex demonstrates the true beginner flow: install the extension, log in, and ask basic questions about an unfamiliar repo. The emphasis is that Codex is useful even before you write code—simply to understand how to run and interact with a codebase.

3. 3

   First fixes in a toy project: adjust jump + implement missing feature

   With the game running locally, Alex uses plain-English prompts to fix a too-high jump and implement windmill planting. This showcases the basic “tell the agent what you want” loop and how Codex proposes a plan before editing code.

4. 4

   Parallel tasks: when to run multiple Codex chats vs serial work

   Claire highlights parallelization as a key productivity lever, then asks how to decide between parallel and serial execution. Alex explains it depends on whether tasks are exploratory/questions (great in parallel) versus code changes that may conflict.

5. 5

   Git worktrees for safe parallel code changes (with Codex generating commands)

   Alex introduces Git worktrees as the practical solution to parallel changes that must remain isolated. He demonstrates asking Codex to create two worktrees (French/German) so multiple variants can be developed concurrently without conflicts.

6. 6

   Terminal productivity: one-line prompts + working in multiple tabs

   They zoom in on command-line efficiency: launching Codex with the first prompt inline and using multiple terminal tabs for parallel work. Claire notes many power users run many instances, but the key is structuring separation (e.g., via worktrees).

7. 7

   Case study: building the Sora Android app in 28 days with Codex

   Claire asks how Codex scales to real production work; Alex cites OpenAI’s Sora Android app built by four engineers in 28 days and reaching #1 in the App Store. The takeaway is that agents don’t remove hard engineering—they compress timelines when paired with strong architecture and process.

8. 8

   Planning workflow with PLANS.md: “plan the work, then implement”

   Alex demonstrates using a PLANS.md template (from an OpenAI blog post) to produce thorough, milestone-driven plans for large tasks (e.g., Python SDK mirroring a TypeScript SDK). He stresses iterating on the plan in the same chat to preserve context before execution.

9. 9

   Prototyping vs production engineering: vibe coding to learn, specs to ship

   They distinguish two acceleration modes: rapid learning via prototypes and rapid execution for defined work. Designers can prototype Codex surfaces quickly, then engineering either lands it directly or rebuilds cleanly using the learnings and a tighter spec.

10. 10

    What needs a plan? Time, task complexity, and ‘Best of N’ exploration

    Claire asks how to decide when to plan; Alex says it depends on task difficulty and personal time constraints. He describes “Best of N” (multiple attempts in parallel) as an alternative to up-front planning when speed matters or uncertainty is high.

11. 11

    Multiplying impact with code review: /review and GitHub automated reviews

    Alex calls GitHub/code review the highest-leverage integration. He shows manual review via a /review command and automated GitHub PR comments that surface only high-confidence issues—then a loop where a developer can ask Codex to fix the issue directly.

12. 12

    Codex adoption at OpenAI: ‘everywhere,’ productivity shifts, and failed automations

    Alex describes rapid internal adoption: moving from ~half the company to nearly all technical staff using Codex constantly. He shares that automated reviews are enabled across repos, while other proactive automations (e.g., auto-revising after human feedback) were less successful due to missing context and notification fatigue.

13. 13

    Harness matters: model-output quality + UX for latency, context, and iteration

    Claire asks why the interface (“harness”) differentiates amid rapid model releases. Alex explains harness work improves both outcomes (tool usage patterns, compaction, parallel tool calling) and usability (seeing edits in IDE, handling latency, proactive helpfulness).

14. 14

    Atlas and personalized AI workflows: Sidechat, memory, and ‘be polite’

    In a lightning-round segment, Alex shares how Atlas/ChatGPT becomes his default for non-code tasks due to personalization and memory. He highlights Sidechat for page-aware Q&A and rewriting, and argues for politeness to AI as a way to protect human habits and culture.

15. 15

    Getting agents back on track + closing: context, ambiguity, and session replay

    Alex advises giving richer context and being explicit about ambiguity rather than over-specifying outcomes. If the agent derails, he recommends starting a new chat—and notes an advanced trick: Codex stores sessions locally, so you can have it read prior logs and continue coherently.