OpenAI 自家工程师怎么用 Codex：七个用例与六条工作流实践

Codex is used daily by many of OpenAI's technical teams, including security, product engineering, frontend, API, infrastructure, and performance engineering. Teams rely on it to accelerate engineering work across the board—from understanding complex systems and refactoring large codebases to shipping new features and resolving incidents under tight deadlines.

Through interviews with OpenAI engineers and analysis of internal usage data, we've compiled a set of use cases and best practices that show how Codex helps teams work more efficiently, produce higher-quality work, and manage complexity at scale.

Codex helps our teams quickly get familiar with unfamiliar parts of the codebase when onboarding, debugging, or troubleshooting incidents.

They often use Codex to locate the core logic of a feature, map relationships between services or modules, and trace how data flows through the system. It also surfaces architecture patterns or documentation gaps that would otherwise require considerable manual effort to piece together.

During incident response, Codex helps engineers get up to speed on unfamiliar territory by showing how components interact and tracing how failure states propagate through the system.

What a team member says

Whenever I fix a bug, I use ask mode to check whether the same kind of issue exists elsewhere in the codebase.

— Performance engineer, Search

Example prompts for code understanding with Codex:

• Where is the authentication logic implemented in this repository?
• Walk through the complete flow of a request in this service, from entry to response.
• Which modules interact with [module name], and how are exceptions handled?

Codex is often used for changes that span multiple files or packages. When engineers update an API, change how a pattern is implemented, or migrate to new dependencies, Codex can perform the update cleanly and consistently.

The tool is especially useful when the same update needs to be made across dozens of files, or when the change requires recognizing structures and dependencies that regex or find-and-replace can't easily capture.

Teams also use it for code cleanup: splitting oversized modules, replacing legacy patterns with modern equivalents, or reworking code to make it more testable.

What a team member says

Codex replaced all the legacy getUserById() calls with our new service pattern and opened a PR. What used to take hours now takes minutes.

— Backend engineer, ChatGPT Web

Example prompts for refactoring and migration:

• Split this file into separate modules by business responsibility, and generate tests for each module.
• Convert all callback-based database access to async/await.

Codex is used to identify and resolve performance bottlenecks.

In tuning or reliability work, engineers prompt Codex to analyze slow, memory-intensive code paths—inefficient loops, redundant operations, high-cost queries—and suggest optimized alternatives, often delivering significant gains in efficiency and reliability.

Codex also helps keep code healthy by flagging high-risk or deprecated patterns that are still in use. Our teams use it to reduce long-term technical debt and proactively prevent regressions.

What a team member says

I use Codex to scan for repeated, expensive database calls. It pinpoints the hot paths and generates batched queries for me to tune further.

— Infrastructure engineer, API Reliability

Example prompts for performance optimization:

• Optimize this loop for memory efficiency and explain why your version is faster.
• Find repeated high-cost operations in this request handler and suggest caching optimizations.
• Suggest a more efficient way to batch database queries in this function.

Codex helps engineers write tests faster, especially where coverage is thin or missing entirely.

When fixing a bug or refactoring, engineers often ask Codex for test suggestions that cover edge cases and potential failure paths. For new code, it can generate unit or integration tests from function signatures and surrounding logic.

Codex is particularly good at identifying boundary conditions—empty inputs, maximum lengths, or unusual but valid states—that are easy to miss in initial tests.

What a team member says

I asked Codex to work on under-covered modules overnight, and by morning I had a PR with ready-to-run unit tests.

— Frontend engineer, ChatGPT Desktop

Example prompts for using Codex to improve test coverage:

• Write unit tests for this function, covering edge cases and failure paths.
• Generate property-based tests for this sorting utility.
• Extend the test file to cover missing scenarios like empty input and invalid states.

Codex helps teams increase development velocity by speeding up both the early and final phases of the development cycle.

When starting a new feature, engineers use it to scaffold boilerplate—generating folders, modules, and API stubs—so they can get runnable code quickly without wiring everything by hand.

As a project nears release, Codex handles the small but critical tasks that keep delivery on schedule: triaging bugs, filling in remaining implementation gaps, and generating release scripts, telemetry hooks, and config files.

It can also turn product feedback into initial code. Engineers often paste user requirements or specs, let Codex produce a first draft, and then refine it themselves.

ChatGPT Enterprise internal tooling

I was in meetings all day and still merged four PRs, thanks to Codex handling the work in the background.

— Product engineer, ChatGPT Enterprise

Example prompts for using Codex to move faster:

• Set up a new API route for POST /events, with basic validation and logging.
• Use this template [paste your telemetry code sample] to generate a telemetry hook that tracks success/failure for the new onboarding flow.
• Create a stub implementation based on this spec: [paste spec or product feedback].

Codex helps engineers stay productive even with fragmented schedules and constant interruptions.

It can capture unfinished work, turn notes into runnable prototypes, or break out exploratory tasks that can be revisited and continued later. This makes it easy to pause and resume work without losing context—especially useful for on-call shifts or meeting-heavy days.

ChatGPT API infrastructure observability

When there's a quick fix to make, I just send the task to Codex instead of switching branches myself, then review the PR it opens when I have time.

— Backend engineer, ChatGPT API

Codex also works well for open-ended tasks, like exploring alternative implementation approaches or validating design decisions. You can ask it for multiple solution angles, explore unfamiliar development patterns, or stress-test assumptions. That helps surface trade-offs, broaden design options, and settle on the right implementation.

It can also be used to hunt for related bugs. Given a known issue or deprecated method, Codex can find similar patterns elsewhere in the codebase, making it easier to catch regressions and clean things up.

ChatGPT Desktop / Search

Codex helped me get past the cold-start problem—I paste in a spec and docs, and it generates a code skeleton or points out what I missed.

— Product engineer, ChatGPT Desktop

Example prompts for exploration and ideation:

• How would this system work if it were event-driven instead of request/response?
• Find all modules that build SQL strings manually instead of using our query builder.
• Rewrite this code in a more standard functional style, avoiding mutation and side effects.

Codex performs best when it's given a clear framework, context, and room to iterate. These are the habits OpenAI teams have settled on to get consistent value from Codex in day-to-day work.

Start in ask mode for large changes: request an implementation plan, then switch to code mode and use that plan as the reference for subsequent prompts. This two-step flow makes Codex's output more grounded and reduces errors. Codex works best on well-scoped tasks—the kind you or a colleague would spend about an hour on, or that require writing a few hundred lines of code. As model performance improves, the size of tasks it can take on will grow.

Configuring startup scripts, environment variables, and network access can significantly reduce the chance of Codex making mistakes. While it's working, watch for build errors that can be fixed by adjusting Codex's environment. This may take several rounds of iteration and debugging, but the long-term efficiency gains are substantial.

Write prompts the way you'd describe a code change in a PR or issue, and Codex will respond better. That means including file paths, component names, code diffs, and documentation snippets when necessary. Phrasing like “implement this feature the same way [module X] does” improves the generated result.

Use the Codex task queue as a lightweight to-do list. Spin up tasks anytime to capture stray ideas, unfinished work, or quick fixes. Don't force every task to produce a complete PR. Treat Codex as a staging area where work waits until you can give it your full attention again.

Maintain an AGENTS.md file to help Codex work effectively across prompts in a codebase. The file typically captures naming conventions, business logic, special rules, and dependencies that Codex can't infer from code alone. Check the official docs for guidance on how to write AGENTS.md.

Use Best-of-N to improve outputs. The Best-of-N feature generates multiple results for the same task in one go, so you can quickly compare options and pick the best one. For more complex tasks, review multiple generations and combine the strongest parts of each into a better final result.

Codex is still in research preview, but it has already changed how we build software—speeding up development, helping us write better code, and taking on work that used to be hard to schedule.

We're excited about the potential ahead. As the model keeps improving and Codex becomes more deeply embedded in our workflows, we look forward to unlocking new and more powerful ways to build software. We'll keep sharing what we learn along the way.