Codex App Mastery Tips

You have been using the Codex App for a week. You open one thread, type a prompt, wait for results, review the diff, and move on. Meanwhile, the developer next to you runs three worktree threads in parallel, has an automation triaging Sentry errors overnight, and reviews diffs with inline comments that Codex addresses automatically. The App is designed for this kind of parallel, multi-project workflow — you just need to know where the controls are.

What You’ll Walk Away With

• Keyboard shortcuts that save seconds on every interaction
• Worktree patterns for running parallel tasks without file conflicts
• Automation recipes for recurring background work
• IDE sync techniques that give the App context from your editor
• Visual diff review workflows that catch issues faster

Keyboard Shortcuts

Learn these and your fingers never leave the keyboard:

Shortcut	Action
Cmd + J	Toggle the integrated terminal
Cmd + K	Open the command palette
Ctrl + M (hold)	Start voice dictation
Ctrl + L	Clear the terminal
Esc (2x)	Edit your previous message
Enter (while running)	Inject instructions into the current turn
Tab (while running)	Queue a follow-up for the next turn

The last two are the most underused. When you see the agent heading in the wrong direction, press Enter to redirect it mid-turn instead of waiting for it to finish and start over.

Prompt: Redirect a running agent

Press Enter while the agent is working, then type:

“Stop what you’re doing with the database migration. Instead, focus on fixing the type error in src/services/auth.ts first, then come back to the migration.”

Thread Modes

Every thread runs in one of three modes. Choosing the right one saves time and prevents conflicts:

Local Mode

Work directly in your project directory. Use for:

• Quick questions about the codebase
• Small edits to files you are currently working on
• Tasks that need to see your uncommitted changes

Worktree Mode

Isolate changes in a Git worktree. Use for:

• Features that should not interfere with your current work
• Running multiple parallel tasks on the same project
• Experiments you might discard

Cloud Mode

Run remotely in a configured cloud environment. Use for:

• Heavy computation that would slow your machine
• Tasks that need a clean environment
• Best-of-N parallel attempts for critical fixes

The Three-Thread Pattern

For any substantial feature, open three threads simultaneously:

1. Implementation (Worktree) — The main code changes
2. Tests (Worktree, same base branch) — Test coverage for the new code
3. Documentation (Local) — Docs updates that do not conflict with code

Sync implementation and test worktrees to the same feature branch. Review docs in-place.

Worktree Tips

Start From the Right Branch

When creating a Worktree thread, select the base branch carefully. The worktree checks out from that branch, so any uncommitted changes on your current branch are not visible.

Apply Changes

After a worktree thread finishes, you have three options:

1. Create a PR directly from the App’s Git tools
2. Apply to local to merge the worktree changes into your working directory
3. Sync to branch to push the worktree to a specific remote branch

Use “Create a PR” for completed work. Use “Apply to local” when you want to review and iterate further before committing.

Clean Up Worktrees

Completed worktree threads leave Git worktrees on disk. The App cleans them up automatically after archiving, but you can also clean them manually by archiving completed threads.

Prompt: Parallel worktree workflow

Open two Worktree threads in the App:

Thread 1: “In the auth module, add rate limiting to the login endpoint. Use the existing RateLimiter class in src/lib/rate-limiter.ts. Add integration tests.”

Thread 2: “Add comprehensive unit tests for src/services/user.ts. Cover edge cases for the createUser, updateUser, and deleteUser methods. Mock the database layer.”

Both threads work independently. Sync both to the same feature branch when done.

Voice Dictation

Hold Ctrl + M while the composer is visible and start talking. Codex transcribes your speech and places the text in the composer. Edit it or send directly.

Voice dictation works best for:

• Conversational prompts that are faster to speak than type
• Describing visual issues (“The button in the top-right corner overlaps the navigation menu”)
• Long, detailed instructions where typing would take minutes

It works less well for:

• Code-specific terminology (variable names, function signatures)
• Short, precise commands

Edit the transcription before sending when precision matters.

Image Input

Drag and drop screenshots into the composer for visual context:

• Drop normally: Replace the current prompt with the image
• Shift + Drop: Add the image as context alongside your text prompt

This is invaluable for UI debugging. Drop a screenshot of the broken layout and describe what should change.

IDE Sync

When the Codex IDE Extension and App are both open in the same project, they sync automatically:

• Auto context: The App tracks which files you have open in your editor
• Thread visibility: Threads from the App appear in the IDE Extension and vice versa
• File references: Use @ in the App composer to reference files from your editor’s workspace

Enable “Auto context” in the App composer to give the agent awareness of your current editing context without explicitly mentioning files.

Auto context caveat

If you are unsure whether the App is using IDE context correctly, toggle “Auto context” off and re-ask the same question. Compare results to determine if the extra context is helping or adding noise.

Built-In Git Tools

The App has a full Git workflow built in:

Visual Diff Review

The diff pane shows changes made by the current thread. You can:

• Stage or revert individual chunks instead of accepting everything
• Add inline comments that Codex will address in the next turn
• Compare before and after for each modified file

Commit, Push, and PR

After reviewing the diff:

1. Write a commit message (or let Codex suggest one)
2. Push to a branch
3. Create a pull request directly from the App

This eliminates the terminal round-trip for Git operations on completed work.

Integrated Terminal

Toggle the terminal with Cmd + J. Each thread has its own terminal scoped to the project or worktree directory. Use it for:

# Verify agent changes
git diff
npm test

# Run commands without leaving the App
pnpm lint
docker compose logs api

The terminal shares the same working directory as the thread, so you see exactly what the agent sees.

Automation Tips

Create a Nightly Triage Automation

In the App, go to Automations and create a new automation:

• Schedule: Daily at 2:00 AM
• Prompt: “Check the Sentry error dashboard for new errors in the last 24 hours. For each error, identify the root cause in the codebase and submit a fix as a PR.”
• Branch: auto/sentry-triage

Automations run in dedicated background worktrees, so they never interfere with your work.

Keep Your Machine Awake

Enable “Prevent sleep while running” in App settings so long-running tasks and automations do not get interrupted when your machine tries to sleep.

Notifications

Configure notifications to know when to come back:

• Default: Notifications fire when a task completes or needs approval while the App is in the background
• Always: Get notifications even when the App is in focus (useful for long-running threads you are not watching)
• Never: Silence all notifications (useful during focused deep work)

Prompt: App efficiency audit

“Check my Codex App setup: are there any worktree threads I should archive to free disk space? Is ‘Prevent sleep while running’ enabled? Do I have any automations that haven’t run successfully? Report issues and suggest improvements.”

When This Breaks

• Worktree thread fails to create: The base branch may have uncommitted changes or the repository is in a dirty state. Commit or stash before creating worktree threads.
• IDE sync not working: Both the App and IDE Extension must be open in the same project root. Check that the project paths match exactly.
• Voice dictation inaccurate: Speak clearly at a moderate pace. Edit the transcription before sending. It handles natural language better than code terminology.
• Automation not running: Check that the App is running (automations require the App process). Verify the schedule and that the project is correctly configured.
• Terminal shows wrong directory: Each thread has its own terminal context. Make sure you are in the correct thread before running commands.

What’s Next

• CLI Commands — Terminal-first workflows that complement the App
• Cloud Workflows — Offload heavy tasks to cloud environments
• Advanced Techniques — Power user tips for multi-surface workflows