OpenAI: GPT-5 Codex

Refactor this React component to use server actions instead of client-side fetch. Keep the error handling but simplify the loading states.

The model would produce a clean refactor moving data fetching to a server action with proper TypeScript types, eliminating useState for loading while preserving error boundaries. It typically structures the response with inline comments explaining the architectural shift, uses modern Next.js 14+ patterns, and suggests file organization (separating the action into actions/user.ts). The code maintains the original component's UI contract while reducing client bundle size.

This showcases GPT-5 Codex's strength in architectural refactoring across framework boundaries. With a 400k token context window, it can hold entire codebases in memory to ensure the refactor doesn't break distant imports. The trade-off: at $10/Mtok output, generating large refactors costs more than specialized code models, so it's best for complex migrations rather than routine edits.

Analyze this PostgreSQL query plan and explain why the nested loop is causing the timeout. Suggest an index strategy that works with our existing schema constraints.

The model would identify that the nested loop scans 2.3M rows because the join condition lacks a covering index on the timestamp column, then explain how the planner chose nested loop over hash join due to outdated statistics. It would propose a partial index on active records with the timestamp included, show the expected plan change with EXPLAIN output, and note that the index won't help the monthly report query that needs full table scans anyway.

This demonstrates deep reasoning about database internals and schema trade-offs — GPT-5 Codex connects query plans to real-world constraints rather than suggesting generic 'add an index' advice. The multimodal capability means you can paste screenshots of pgAdmin explain visualizations. The limitation: no access to your actual table statistics, so recommendations assume typical data distributions.

I have a flowchart image showing our deployment pipeline. Write Terraform modules that implement this architecture, including the approval gates and rollback logic shown in the diagram.

The model would parse the flowchart's boxes and arrows to generate modular Terraform with separate files for each stage (build.tf, staging.tf, prod.tf). It would implement the manual approval gates using null_resource with local-exec calling a webhook, add lifecycle rules matching the rollback arrows, and include a README explaining how the generated code maps back to each flowchart element. Variable defaults would match the environment labels visible in the image.

This highlights the image understanding capability — GPT-5 Codex can translate visual architecture diagrams into working infrastructure code, saving the translation step. The 400k context window means it can reference both the image and your existing Terraform state in one prompt. Trade-off: it can't verify the generated Terraform against your actual AWS account, so you'll need to run plan before applying.

When 400k context justifies the $10/Mtok output cost on refactors

A 12-person product team needs to refactor a legacy monorepo spanning 80+ files without losing type safety or breaking API contracts. GPT-5 Codex's 400k context window means you can load the entire module graph—controllers, models, tests, and config—into a single session and ask for cross-file rewrites that preserve call signatures. The $10/Mtok output price stings on exploratory work, but when you're generating 50k tokens of production-ready diff in one pass, the time saved on manual reconciliation pays back the cost. If your refactor touches fewer than 20 files or you're prototyping rather than shipping, drop to a cheaper model with 128k context and do the stitching yourself.

Why the image modality matters for auto-generating API docs from screenshots

A 4-person SaaS startup ships a new dashboard every two weeks and needs to keep Notion docs in sync with the UI. GPT-5 Codex's image input lets you paste a screenshot of the settings panel alongside the React component source, then generate the user-facing explanation in one prompt. The model cross-references what it sees in the image with the prop definitions in code, so the output matches both the visual hierarchy and the actual behavior. At $1.25/Mtok input, processing 10 screenshots per sprint costs under a dollar. If you're only documenting APIs without a UI layer, the image modality is wasted—use a text-only model at half the input cost.

When GPT-5 Codex is too expensive for PR comment automation

A 30-person engineering org wants to auto-comment on every pull request with style fixes and logic suggestions. At 200 PRs/week averaging 8k tokens of diff each, you're generating 1.6M tokens of output per week—$16 at GPT-5 Codex's $10/Mtok rate. The model's 400k context is overkill for single-PR review, and the lack of public benchmarks means you're paying premium pricing without proof it outperforms cheaper alternatives on linting or bug-spotting tasks. For this volume, switch to a model priced under $2/Mtok output and reserve GPT-5 Codex for the 5% of PRs that touch architectural boundaries where the extra context actually matters.