Most important take away

GPT-5.5 has reset the frontier bar by raising the floor of the default pre-trained model rather than just stacking on inference-time compute, making it the strongest model today for complex, messy, multi-step, tool-heavy work. The right strategy is no longer picking one favorite model but routing tasks: 5.5 in Codex for execution and long workflows, Opus 4.7 for blank-canvas visual taste and planning, and Images 2.0 plus a reference image whenever visual direction matters.

Summary

Actionable insights for using AI at work

• Stop testing models on easy prompts (to-do apps, summaries, single emails). Frontier differences only show up on long, messy, multi-artifact, tool-using work. Build a private benchmark with hard tasks so you can detect regressions and generalization gaps that public benchmarks miss.
• Default to GPT-5.5 inside Codex for serious execution: file inspection, code edits, browser control, multi-step artifact generation, long writing, data migrations. The model “carries” tasks further before dropping the thread.
• Keep Claude Opus 4.7 in your toolkit for blank-canvas visual taste, beautiful front-end design, planning, and critique. Opus still wins on visual composition and authority when there is no reference image.
• For UI work, change the workflow: generate a strong mockup with Images 2.0 (or use a Claude design output, or a screenshot) and hand that reference to 5.5 in Codex to implement faithfully. Inventing taste is hard; implementing to a target is much easier.
• For engineering, run a two-model loop: Opus 4.7 for planning and shape-of-the-work, 5.5 in Codex for execution, testing, and iteration.
• For data migrations, use 5.5 aggressively but never let it declare a database canonical. Add validators, check raw counts, inspect enum maps, require service codes in the schema, and have a human approve canonical merges before anything leaves staging. 5.5 catches semantically obvious junk (Mickey Mouse customers, fake $25k payments) but still misses backend hygiene like enum normalization and orphan handling — and 5.4 was actually slightly stronger on that backend discipline.
• For writing, trust 5.5 with more of the structural first draft. The big improvement is shape — argument flow, transitions, building toward a thesis — not just sentence polish. Still edit before publishing.
• For research-heavy work, watch for overconfidence. 5.5 produces excellent output but can sound surer than it should — verify sources yourself.
• Treat reliability as part of model quality. Anthropic’s recent uptime has hovered around one-nine of availability while OpenAI has been showing two-to-three-nines, which matters when AI is part of daily work. Anthropic has signed deals for 10+ gigawatts of compute in 30 days, so the picture may flip again.
• Validate outputs whenever the work touches money, law, operations, or production data. Confidently wrong is expensive.

Career and side-business advice

• The people who get the most out of the frontier will be the ones who know how to route work between models, tools, and harnesses — not the ones loyal to a single model. Build that routing skill explicitly.
• Don’t assume frontier models only matter for big enterprises. Solo and side-gig opportunities are unlocking weekly. Two examples Nate floats:
  • A palm-reading mobile app: Images 2.0 generates the read and the UI, Codex builds the app.
  • A custom Lego-set business: Images 2.0 designs sets with accurate part numbers and powers the UI, Codex builds the storefront, you handle Lego supply chain.
• Raise your ambition with each release. The bar moves not when a model can finally answer something — it moves when you realize you can now ask something you wouldn’t have bothered asking last week. Audit your workflow regularly for tasks that were “too messy for AI” three months ago and re-test them.
• Build a private benchmark of your own real, hard, messy work. It both protects you from saturated public benchmarks and gives you a personal signal on which model deserves which task today.

Why the floor moved with 5.5

• Recent gains have come mostly from inference-time compute (more thinking, more tool calls). 5.5 feels like a bigger pre-trained model showing up in everyday use: sharper fast modes, stronger thinking modes, faster task-shape recognition, less handholding.
• Public numbers: 82% on Terminal Bench (software engineering), 84% on GDPval (knowledge work), and Artificial Analysis ranks it #1 on the Intelligence Index at extra-high reasoning effort while using fewer tokens than 5.4 — smarter and more efficient.
• The “best model doesn’t matter anymore” take is wrong for real work. It’s only true for clean, well-defined tasks. For messy, underspecified, contradictory, multi-artifact work, the best model still matters a lot.

What the three private tests showed

• Dingo & Co. (executive knowledge work, 23 deliverables): 5.5 won decisively (87.3 vs Opus 4.7 at 67.0, Sonnet 4.7 at 65.0, Gemini 3.1 Pro at 49.8). 5.5 produced real artifact types (working PowerPoint with 17 slides, real spreadsheet formulas, working dashboard, 34 sourced URLs) and correctly framed the legally and ethically sensitive posture. Other models either produced shaky regulatory positions, underdelivered on artifacts, or shipped HTML files masquerading as PowerPoints.
• Splash Brothers (messy 465-file car-wash data migration): 5.5 was the first model to reject planted fake customers (Mickey Mouse, “test customer”, ASDF) and a fake $25k payment, merge all seven duplicate pairs, and catch all 13 typo orders — but it missed service-code conflicts, didn’t normalize 29 raw payment-status values, mishandled an orphan order, and had dashboard counts disagreeing with database counts. Interestingly, 5.4 was a bit better at backend hygiene than 5.5.
• Artemis II (interactive 3D visualization): Both 5.5 and Opus 4.7 understood the mission shape (lunar flyby, not landing). 5.5 was strong on information density (clickable bubbles, dense labels) but visually cartoonish; Opus produced stronger lighting, composition, and visual authority. The right move is to start from Opus visuals and layer 5.5’s information density on top.

Why Codex matters so much for 5.5

• A model this strong is wasted in a chat window. Inside Codex, 5.5 inspects files, edits code, runs commands, drives a browser, tests interfaces, reads docs, generates artifacts, and iterates on its own output across many steps.
• Real work lives in messy folders, web apps, PDFs, spreadsheets, internal tools — not clean prompts. A model that can act across those surfaces reaches more of the world.
• Smarter model + better tools is multiplicative. That’s the loop 5.5 inside Codex closes.

Bottom line

• 5.5 is the new high-water mark for what a single model can carry through real work. It is not the best taste model, not safe to trust blindly, and not a replacement for human judgment. But high-water marks change ambition, and the question has shifted from “can the model answer this?” to “can the model carry this?” — and now to “what can I now ask it to do?”

Chapter Summaries

• The floor moved, not just the ceiling. 5.5 is a stronger pre-trained model, not just better inference-time compute. It needs less handholding, recognizes task shape sooner, and does it with fewer tokens than 5.4.
• The “best model doesn’t matter” take is wrong for real work. Easy prompts make all frontier models look interchangeable. Messy, underspecified, multi-artifact, tool-using work is where 5.5 separates from the pack.
• Test 1 — Dingo & Co. (executive knowledge work): 5.5 dominated 23-deliverable executive launch packet, scoring 87.3 vs Opus 4.7’s 67.0, with real artifact types and correct legal/ethical posture on a sensitive product launch.
• Test 2 — Splash Brothers (dirty data migration): 5.5 was the first model to reject planted fakes and merge all duplicates, but still missed backend hygiene (enum normalization, service codes, orphan handling). 5.4 was actually slightly better on the boring backend bits.
• Test 3 — Artemis II (interactive 3D): 5.5 wins on information density; Opus 4.7 wins on visual taste and composition. Both got the mission shape right. Best result: layer 5.5’s data density onto Opus’s visuals.
• Codex is where 5.5 unlocks. Inside Codex the model can inspect, edit, run, test, browse, and iterate. ChatGPT is the consumer surface; Codex is where work happens.
• Reliability is part of product quality. Anthropic’s recent uptime has slipped to roughly one-nine in places while OpenAI has shown two-to-three-nines. Anthropic has cut deals for 10+ GW of compute in 30 days to catch up.
• How to route work today: 5.5 in Codex for complex execution, data, long writing, and engineering execution. Opus 4.7 for blank-canvas visual taste, planning, and critique. Images 2.0 (or a Claude design / screenshot) as a reference whenever visuals matter, then hand to 5.5 in Codex to build.
• New small-business openings: With 5.5 + Codex + Images 2.0 stitched together, solo entrepreneurs can build things impossible a week ago — examples: a palm-reading app and a custom-Lego-set business.
• Final reminder: Stop benchmarking on easy tasks. The interesting question is no longer “can it answer better than 5.4?” but “what can I now ask it to do?”