9 Codex Tips Straight From the Team That Built It

There's a certain irony in the fact that the people most likely to be using AI coding tools wrong are the people who already know how to code. They're pattern-matching to what they know—prompt in, output out, iterate—when the tools have quietly evolved into something that rewards a totally different kind of engagement.

That's the subtext of a post called Codex maxing, published on GitHub by Jason Lou, a member of the Codex team at OpenAI. The AI Daily Brief broke it down in a recent episode, and what struck me reading through it isn't any single tip—it's the gestalt shift underneath all nine of them. Using Codex like a ChatGPT window is like using a CRM as a notes app. You can do it. You're just leaving almost everything on the table.

Before we get into Jason's tips, though, there's something worth understanding about why this moment matters for Codex specifically.

The squeeze and the opportunity

Codex went from essentially zero users at the start of the year to mid-single-digit millions now. A big chunk of that growth traces back to a pricing decision by Anthropic—they've been pulling back subsidies on certain usage tiers, particularly outside their own harnesses. OpenAI moved quickly to capture those displaced power users, and Codex became a landing zone.

This context matters for how you read Codex's current trajectory. It's not purely organic growth built on product-market fit; it's partly opportunistic. Which doesn't make it unreal, but it does mean the retention question—whether those new users stay—is going to depend heavily on whether they can unlock enough value to not drift back. Jason's tips read, in part, as an answer to that challenge.

Meanwhile, the broader competitive landscape is doing something genuinely interesting. Cursor just launched Composer 2.5, which landed competitive benchmarks—79.8% on SWE-bench multilingual, compared to Opus 4.7 at 80.5% and GPT-5.5 at 77.8%—at roughly half the price of those frontier models. More striking is the token efficiency story: Cursor's SWE-bench run came in under $1 per task versus $5 for GPT-5.5 on high settings or $11 for Opus 4.7 on max. That's not a rounding error; that's a different cost curve entirely.

What makes Composer 2.5 technically interesting is that it shares the same base model as Composer 2—Moonshot AI's Kimi K2.5—which means the performance jump came entirely from post-training improvements, specifically better reinforcement learning techniques. The implication, as the AI Daily Brief notes, is that there's enormous runway in fine-tuning open-source base models for specific domains. You don't necessarily have to train from scratch to compete at the frontier on coding tasks.

Cursor is also training a model from scratch on XAI's Colossus 2 cluster—"With Colossus 2's million H100 equivalents and our combined data and training techniques, we expect this to be a major leap in model capability"—so the from-scratch play is coming, just not yet.

All of which sets a backdrop where OpenAI has strong reasons to make Codex stickier right now, and Jason's post lands at exactly that moment.

What actually changes when you use it right

Tip 1: Durable threads. The most foundational shift Jason advocates is the "mono thread pattern"—keeping key work streams in single, long-running threads rather than spinning up a new chat for each task. This only works because Codex's context compaction has gotten genuinely good: the system collapses long conversation histories into the essential signal, freeing up context window space without losing the thread's accumulated understanding.

The honest comparison here: most "memory" features in AI apps are retrieval systems—they pull from stored files when relevant, which isn't the same as a model that has lived through the conversation with you. Long-running threads get closer to the latter. Not perfect, but meaningfully different.

Tip 2: Voice as a different modality entirely. This one sounds obvious until you think about what changes when you're not editing yourself. Jason's framing is that Codex's internal speech-to-text is good enough that you can just... talk at it. Ramble. Include uncertainty. Name what you don't know.

As Jason puts it: "A lot of plans get better when the model has access to the messy version of what I think, not just the polished one."

There's something real here. When you type a prompt, you're already doing a kind of cognitive compression—translating from messy internal state to clean external request. Voice lets you skip that step and hand the model the mess directly. Whether the model handles that mess better than you'd handle your own compression is an empirical question, but the intuition isn't wrong.

Tip 3: The steer feature. If you've ever felt like you needed to write a perfect novel-length prompt before starting a task, the steer feature is your antidote. It lets you update or redirect the prompt while the agent is working—which means you and Codex can operate in parallel rather than sequentially. You don't have to sit and wait; you can observe the first outputs rolling in and start course-correcting in real time.

This is a subtle but real UX shift. The brittle "get the prompt exactly right upfront" pattern breaks down on complex tasks precisely because you often don't know what you want until you see a first pass. Steer is designed for that reality.

(Voice pairs particularly well here—you can just narrate your reactions as you watch Codex work, rather than stopping everything to type feedback.)

The bigger thing Jason is actually describing

Nine tips is a lot, and the AI Daily Brief only made it through three before wrapping the segment—but the first three are enough to reveal the underlying argument. Jason isn't really giving productivity hacks. He's describing a different relationship with an AI tool: one that's persistent over time, richer in context, and collaborative in cadence rather than transactional.

That's a meaningful shift in how we're supposed to think about these tools, and it has implications beyond Codex specifically. The "year of the harvest," as the AI Daily Brief framed it, is the moment when knowing how to use AI infrastructure starts to matter as much as which infrastructure you're using. The benchmark wars between models matter less at the margin when the productivity delta comes from workflow design.

Which also explains why Chamath Palihapitiya's argument about enterprise AI strategy is getting traction right now. He wrote: "Consulting businesses that understand this are adopting a control plan that allows them to arbitrate where tokens go and who generates tokens for them. Controlling the tokens is controlling the spice."

It's deliberately dramatic, but the underlying point isn't wrong. Enterprises that treat model selection as a permanent vendor commitment are exposed in ways that enterprises treating it as a routing decision are not. The harness-first companies—Cursor, Cognition, and others—are positioning themselves as that routing layer, model-agnostic on the bottom but opinionated on the workflow layer above.

Codex is OpenAI's answer to the same question from the other direction: if we're going to be the model layer, we'd better make sure people know how to actually use what we've built.

Jason Lou's post is, in that sense, as much a product document as a tips list. The tips that help you get more out of Codex are also the tips that make you less likely to leave Codex. Whether that's a reason to trust them or interrogate them more carefully is probably worth sitting with.

---

Yuki Okonkwo is Buzzrag's AI & Machine Learning Correspondent.