OpenAI: GPT-4o (2024-11-20)

Review this Python function for potential bugs. It's supposed to merge two sorted lists but users report occasional duplicates in the output.

The function has a subtle off-by-one error in the merge logic. When both lists have identical values at the current indices, the code appends from list A and increments both pointers — but then the while loop condition allows the same element from list B to be appended again on the next iteration. The fix is to increment only one pointer when values match, or add a deduplication check. Also worth noting: the function assumes pre-sorted input but doesn't validate that assumption, so garbage-in-garbage-out applies if callers violate the contract.

This example highlights GPT-4o's strong code reasoning across the 128k context window — it can hold the entire function, surrounding module context, and test cases in memory simultaneously. The model correctly identifies both the primary bug and a secondary contract issue. Trade-off: without access to runtime state or logs, it can't confirm whether the bug manifests in production; the diagnosis relies on static analysis.

Summarise this 40-page technical specification for database migration. Focus on breaking changes that will affect our API clients.

Three breaking changes require client updates. First, the `user_metadata` field moves from a JSON string to a structured JSONB column — clients parsing it as raw text will break. Second, timestamp fields now return ISO 8601 with timezone offsets instead of Unix epochs; this affects any client doing date arithmetic on raw values. Third, the deprecated `legacy_id` field is removed entirely in v3 — clients still referencing it must migrate to `canonical_id` before the cutover window in Q2. Non-breaking: pagination defaults change from 50 to 100 items, but the `limit` parameter still overrides this.

The 128k token context window makes GPT-4o well-suited for document summarisation tasks where the entire spec fits in a single prompt. The model extracts action-oriented insights rather than regurgitating structure. Trade-off: at $2.50/Mtok input, a 40-page PDF (≈30k tokens) costs about $0.08 per query — economical for one-off analysis, but repeated runs on large corpora add up quickly compared to smaller models.

Generate a professional email declining a vendor proposal. Tone: polite but firm. Reason: their pricing is 3x our budget and the feature set overlaps with our existing tooling.

Subject: Re: Proposal for [Vendor Product] Hi [Name], Thank you for the detailed proposal and for taking the time to walk us through [Product]. We appreciate the thoroughness of your team's approach. After internal review, we've decided not to move forward at this time. The pricing structure significantly exceeds our current budget allocation for this category, and we've identified substantial overlap with tooling we already have in production. While we recognise the additional capabilities [Product] offers, the incremental value doesn't justify the investment delta for our use case right now. We'll keep your contact information on file should our needs evolve. Thanks again for your time. Best, [Your Name]

This example demonstrates GPT-4o's ability to match professional tone and structure without over-explaining or under-delivering. The output balances politeness with clarity — no ambiguity about the decision, but no unnecessary harshness either. Trade-off: the model defaults to safe, corporate phrasing; users wanting a more direct or casual voice need to specify that explicitly in the prompt, as the base tuning leans formal.

When GPT-4o handles large refactors without context loss

A 12-person product team needs to refactor a legacy Python service spread across 40+ files before migrating to microservices. GPT-4o's 128k token context window fits the entire codebase in a single prompt, letting the model trace dependencies and suggest consistent changes across modules without losing track of imports or shared utilities. At $2.50/Mtok input, analyzing the full codebase costs under $0.50 per pass—cheap enough to run multiple iterations as the team debates architectural choices. The output cost ($10/Mtok) stays reasonable because refactor suggestions are concise diffs, not full rewrites. If your codebase exceeds 100k tokens or you need sub-second responses for live pair programming, consider a smaller model with retrieval. Otherwise, GPT-4o's context depth makes it the right call for one-shot refactors where seeing the whole system matters more than raw speed.

Why GPT-4o works for image-based customer support triage

A 20-person DTC brand processes 200+ return requests daily, each with 2-4 photos of damaged goods. Support agents waste 15 minutes per ticket deciding if the damage qualifies under warranty terms. GPT-4o's native image understanding lets you pipe the photos and a 300-word policy doc into a single API call, getting a structured yes/no decision with reasoning in 3-5 seconds. At current pricing, each ticket costs roughly $0.03 in tokens (images + text input, short JSON output). The model handles edge cases like lighting variations and partial occlusion better than rules-based CV, and the 128k context means you can include the full return policy without truncation. If you're under 50 tickets/day, the setup overhead isn't worth it—stick with manual review. Above that threshold, GPT-4o pays for itself in saved agent hours within the first week.

When GPT-4o's context window justifies the output cost for legal work

A 4-person legal ops team at a Series B startup reviews 30 vendor contracts per quarter, each 15-25 pages. They need to flag non-standard clauses against a 60-page playbook of approved language and past redlines. GPT-4o's 128k token window fits the contract, playbook, and 10-15 precedent examples in one prompt, letting the model cross-reference clauses without multi-step retrieval. Input cost is negligible ($2.50/Mtok means a full contract run costs $0.40), but output cost adds up: a detailed redline memo runs 3k-5k tokens at $10/Mtok, so $0.03-$0.05 per contract. That's still 10x cheaper than an associate's billable hour, and the model catches inconsistencies humans miss when toggling between documents. If you're only reviewing 5-10 contracts/year, the setup tax isn't worth it. At 20+ contracts annually, GPT-4o becomes the cheapest way to maintain institutional memory without a dedicated paralegal.