How I AIThe power user’s guide to Codex | Alexander Embiricos (product lead)
CHAPTERS
- 0:00 – 0:51
Why Codex excels at complex engineering tasks (thoroughness over speed)
Alex opens by framing Codex as a coding agent optimized for diligence and hard problems rather than raw speed. He positions it as a “software engineering teammate” that can both answer questions and execute substantial work.
- •Codex is designed as an agent, not just autocomplete
- •Strength: thorough, careful work on complex tasks
- •Tradeoff: not always the fastest, but strong on correctness and depth
- •Using the same chat preserves context for iterative changes
- 0:51 – 2:21
Show setup context: what viewers will learn (IDE, terminal, and power workflows)
Claire introduces the episode’s goals: a practical, zero-to-one walkthrough and advanced tips. The focus is on using Codex across skill levels—from non-technical tweaks to terminal-centric power usage.
- •Episode aims for practical demonstrations, not theory
- •Target audience ranges from newcomers to experienced engineers
- •Topics previewed: IDE usage, CLI workflows, review, and scaling impact
- •Codex positioned as flexible across surfaces
- 2:21 – 3:07
Installing Codex in VS Code and understanding access/limits
They walk through installing the Codex extension and the initial login flow. Alex clarifies that Codex is included in paid ChatGPT plans and highlights generous usage limits.
- •Install via VS Code extension marketplace
- •Codex requires a paid ChatGPT plan (Plus/Pro/Business/Team/Edu)
- •Extension adds a Codex sidebar glyph/surface
- •Practical onboarding: treat as ‘zero to one’ even for new users
- 3:07 – 6:01
First wins on an existing codebase: run the repo, ask questions, fix a gameplay bug
Alex demonstrates the “day-one” value: asking basic repo questions, running the project locally, and making a simple change via natural language. The example centers on a game repo where the jump behavior is clearly wrong.
- •Use Codex to ask ‘how do I run/play this repo?’
- •Run local dev command (e.g., npm run dev) and validate behavior
- •Natural-language change request (“jump is too big—lower it”)
- •Codex proposes a plan before editing, reinforcing agent-style workflow
- 6:01 – 7:21
Parallelizing work: when to split tasks vs do them sequentially
Claire highlights how Alex spawns multiple chats for parallel fixes (e.g., jump + windmill feature). Alex explains the decision-making: parallelize questions freely, but be cautious when code changes can conflict.
- •Parallel chats are great for Q&A and lightweight exploration
- •For code changes, assess likelihood of conflicts
- •Real workflow example: internal feature toggles and string-search hints
- •Parallelism is a tool—use it selectively depending on coupling
- 7:21 – 9:01
Git worktrees in practice: safe parallel changes without branch conflicts
They dive into Git worktrees as the mechanism for running multiple independent changes simultaneously. Alex shows using Codex to create worktrees and then running separate agent sessions in each directory.
- •Worktrees = multiple working directories tracked by one git repo
- •Avoids manual copying/cloning while keeping changes separated
- •Use Codex to generate the exact worktree commands (no memorization)
- •Demo: French vs German UI placeholder translations in separate worktrees
- 9:01 – 13:00
Terminal productivity: one-line prompts, shortcuts, and ‘Codex all the way down’
Claire calls out a power-user pattern: launching Codex from the CLI with the initial prompt included inline. The segment emphasizes reducing friction and speeding up iterative command-line workflows.
- •CLI launch supports passing the first prompt directly (single-line flow)
- •Useful for repetitive tasks like git operations and repo automation
- •Meta workflow: running Codex within the Codex repo while discussing Codex
- •Takeaway: small UX shortcuts compound into large productivity gains
- 13:00 – 14:49
Case study: building the Sora Android app in 28 days (what actually worked)
Alex shares OpenAI’s story of building the Sora Android app quickly with a small team, clarifying that it wasn’t a one-prompt ‘vibe build.’ The key was pairing strong architecture thinking with agent execution and careful review.
- •Four engineers shipped a non-trivial app in 28 days
- •Attempting a single prompt to build the whole app didn’t work
- •Success relied on architecture decisions + structured execution
- •Core lesson: agents don’t remove difficulty—they compress time
- 14:49 – 19:21
PLANS.md workflow: turning a big change into an executable, reviewable plan
Alex introduces a structured planning approach using a PLANS.md template from an OpenAI blog post. He demonstrates generating a detailed plan (e.g., Python SDK based on a TypeScript SDK) and then using that plan as the execution contract.
- •Use a ‘plan for planning’ template (PLANS.md) to guide the agent
- •Plans should be self-contained, milestone-based, and updated as work progresses
- •Codex’s strength: thorough long plans for complex tasks
- •Best practice: iterate on the plan in the same chat to preserve context
- 19:21 – 22:27
Vibe coding vs vibe engineering: prototyping for learning vs production execution
They distinguish between fast prototyping (often designer-led) and production-grade engineering that requires specs and architecture. Codex helps in both modes: speeding learning loops and accelerating implementation once direction is clear.
- •Two accelerations: learning/prototyping and execution/shipping
- •Designers can build functional prototypes quickly with agent help
- •Production still needs careful architectural thinking and review
- •Sometimes prototypes are close enough to land; other times they inform a rebuild
- 22:27 – 26:56
When to plan (and when to skip it): time, complexity, and ‘Best of N’ exploration
Claire asks how to decide what warrants a plan. Alex gives a pragmatic rubric: harder tasks need plans, but time constraints may push you toward multiple parallel attempts instead of planning, including ‘Best of N’ runs in the cloud.
- •Complexity increases the payoff of planning
- •When time is scarce, run multiple attempts in parallel instead
- •Cloud Codex can do ‘Best of N’ (multiple tries) for exploration
- •Typical human bandwidth: two parallel threads is manageable; more becomes juggling
- 26:56 – 30:50
Multiplying impact with GitHub: /review, automated PR comments, and fix loops
Alex shows how Codex can act as an explicit reviewer (/review) and as an automated GitHub integration that comments only when highly confident. The system can even accept a ‘please fix’ reply and generate the patch, tightening the review-to-fix cycle.
- •Use /review to put Codex into reviewer mindset for stronger critique
- •Automated GitHub review posts only high-confidence issues to reduce noise
- •Human attention is treated as scarce—no issue means minimal interruption
- •Closed loop: teammate asks Codex to fix, Codex patches and updates PR
- 30:50 – 38:38
Codex adoption inside OpenAI: productivity signals and proactive vs reactive agents
Alex discusses broad internal adoption—moving from about half the company to nearly all technical staff using Codex regularly. They also reflect on product lessons: some proactive automations (like review) hit, while others (auto-revising PRs from feedback) were too noisy or context-dependent.
- •Codex became pervasive across OpenAI’s technical teams
- •Early signal: higher PR volume for users (imperfect but indicative)
- •Automated review enabled across most repos; generally well-liked
- •Proactive agent features require very high quality to avoid frustration
- 38:38 – 43:44
Harness matters: model-UX co-design, open-source learnings, and compaction
They shift into why the ‘interface’ (harness) is a differentiator, not just the model. Alex explains that Codex’s open-source harness lets users see how OpenAI adapts workflows per model release and adds features like compaction to preserve continuity across contexts.
- •Harness impacts both output quality and user experience
- •Models change frequently; harness updates help users keep pace
- •Open source allows builders to learn, reuse patterns, or delegate via SDK
- •Compaction: continuing work with refreshed context while preserving continuity
- 43:44 – 49:08
Atlas and Sidechat: personalized, in-context assistance across the web
Claire asks about Atlas, and Alex shares how personalization and memory change everyday workflows. Sidechat enables page-grounded conversations—summarize, analyze numbers, rewrite text—without leaving the current context.
- •Memory + feedback loops produce increasingly tailored answers
- •Use chat for ‘everything,’ then follow up conversationally
- •Sidechat grounds Q&A in the page you’re reading
- •In-context rewriting and interpretation (docs, numbers, concepts)
- 49:08 – 51:26
Getting agents back on track: context-first prompting, ambiguity, and session recovery
Alex explains his debugging approach when an agent misbehaves: provide more context, clarify intent, and avoid false precision. If needed, he restarts a session—and notes advanced users can point Codex to local session logs to recover context.
- •Give rich context and the ‘why,’ not just the ‘what’
- •Be explicit about ambiguity—don’t over-specify if you don’t care
- •If it’s stuck, restart a new chat rather than fighting the thread
- •Advanced: sessions stored locally (.codex/sessions); agent can read prior sessions
- 51:26 – 53:04
Where to find Alex + what’s next for Codex (hiring, configs, skills)
They close with ways the audience can engage: bug reports, feedback, and contributing ideas for new configuration/skills. Alex shares where to reach him and mentions hiring needs for the Codex team.
- •Open invitation for bug reports and product feedback
- •Codex expanding configuration: allowlists, commands, ‘skills’
- •Hiring PMs and broader roles for Codex
- •Contact: @Embirico and r/codex community
