OpenAI: GPT-5.1-Codex

Refactor this Python function to use async/await and add type hints. The function fetches user data from three different APIs and merges the results.

The model would produce a complete refactored function with proper async syntax, including `asyncio.gather()` for concurrent API calls, comprehensive type hints using `TypedDict` for the merged result structure, and error handling with try-except blocks around each fetch operation. The code would include docstrings explaining the async behavior and return type, with variable names clarified for readability. The refactor would maintain the original logic while reducing execution time through parallelization.

This example highlights Codex's strength in architectural improvements and modern Python idioms. With a 400k token context window, it can hold the entire codebase structure in memory while refactoring. However, at $10/Mtok output, generating extensive refactors across large codebases becomes expensive compared to smaller context models that cost $0.60-2.00/Mtok.

Find the bug causing intermittent race conditions in this TypeScript React component. Here's the component code, the Redux store slice, and the test that fails 30% of the time.

The model would identify that the `useEffect` hook is missing `dispatch` in its dependency array, causing stale closures when the component re-renders during async operations. It would explain how the race condition occurs when rapid user interactions trigger multiple dispatches before the previous async action completes, leading to state updates being applied out of order. The response would include a corrected version using `useCallback` to memoize the dispatch function and `useRef` to track in-flight requests, plus a suggestion to add request cancellation tokens.

Codex excels at cross-file reasoning — correlating the component, store, and test to pinpoint timing issues. The 400k context window allows it to analyze the full interaction chain without truncation. The trade-off: multimodal input means you can paste screenshots of browser DevTools, but the model sometimes over-indexes on visual layout rather than the underlying state management logic.

Explain how this Rust borrow checker error relates to the lifetime annotations in my custom iterator implementation. Include a diagram showing the lifetime relationships.

The model would provide a detailed explanation of how the iterator's `Item` associated type borrows from `self`, creating a lifetime dependency that conflicts with the mutable borrow in the `next()` method. It would generate an ASCII diagram showing the three lifetimes involved: the struct lifetime `'a`, the method call lifetime `'b`, and the returned item lifetime `'c`, with arrows indicating borrow relationships. The explanation would include a corrected implementation using `PhantomData` and variance annotations, plus a note on why `StreamingIterator` from the streaming-iterator crate might be a better fit for this use case.

This showcases Codex's ability to teach complex language-specific concepts with visual aids. The multimodal output (text + diagram) helps clarify abstract lifetime relationships. At $1.25/Mtok input, analyzing large Rust projects with macro expansions and trait hierarchies is cost-effective. The limitation: diagrams are ASCII-based, not rendered graphics, which can be harder to parse for deeply nested lifetime scenarios.

When 400k context makes cross-repo refactoring actually work

A 12-person product team needs to rename a core API across 80 files in three repos. GPT-5.1-Codex fits the entire codebase—tests, configs, documentation—into a single 400k-token context window, so it sees every reference and dependency in one pass. The model returns consistent renames across TypeScript, Python, and YAML without the context-window truncation errors that break smaller models at file 30. At $1.25/Mtok input, loading 300k tokens costs $0.38 per session; the alternative is manual grep-and-pray across repos or chaining multiple smaller-context calls that miss edge cases. If your refactor spans fewer than 40 files, a 128k model saves money. Above that threshold, the 400k window pays for itself in accuracy.

Why legal teams pick this for multi-document contract review

A 4-person legal ops team at a SaaS company fields 20 contract questions daily, each requiring cross-reference across MSA, DPA, and SLA documents totaling 180k tokens. GPT-5.1-Codex loads all three agreements into context simultaneously, so answers cite exact clauses from the right document without hallucinating cross-doc conflicts. The image modality handles scanned signature pages and redlined PDFs that text-only models skip. At $10/Mtok output, a 1,200-token answer costs $0.012—cheap enough to run every question through the model instead of escalating to senior counsel. The trade-off: if your contracts average under 50k tokens, a smaller model at $0.60/Mtok output cuts costs by 94%. Above 100k tokens per question, this model is the only one that doesn't lose critical clauses mid-context.

When to use this for API reference builds from source

A 3-person DevRel team at an infrastructure startup generates API docs for 60 endpoints weekly, pulling from OpenAPI specs, inline comments, and example repos. GPT-5.1-Codex ingests the full 220k-token source tree—including test fixtures and error-handling branches—then writes reference pages that match actual behavior instead of guessing from partial context. The image input parses architecture diagrams into alt-text and cross-references without manual annotation. Output cost is the constraint: at $10/Mtok, generating 80k tokens of docs costs $0.80 per build. If you're publishing once a month, that's $9.60/year and worth the accuracy. If you're iterating docs daily in CI, the $240/year output bill pushes you toward a cheaper model unless correctness failures cost more than the delta.