You're not using GPT Pro nearly enough

GPT-5 Pro is the most powerful large language model available, and you're not using it nearly enough.

If you get a ChatGPT Pro subscription, OpenAI's highest tier, you get access to Pro thinking.

In OpenAI's own words, GPT-5 Pro uses "more compute to think harder and provide consistently better answers."

How good are these answers?

A 23-year-old with no formal advanced mathematics training has been solving decades-old open mathematics problems, often just with a single-shot prompt.

Ethan Mollick, an economics professor at Wharton studying AI, has said that if you're doing complicated academic work, there just isn't anything else that is a substitute right now.

Besides academic work, I use Pro all the time for mobile and web app development, and also for back-end infrastructure engineering. It helps me get much better results.

Now, it seems like you'd always want better results, right? So why would you ever not use GPT Pro?

GPT Pro gives you much better answers, but it comes at the cost of taking a ton of time to give you those answers.

Additionally, if you're working in Codex and look through your model picker, you're not going to see GPT Pro available.

That's a big problem because then it becomes very difficult to provide all the context of your business, your research, and your code to this very powerful GPT Pro model.

So how can you most effectively use GPT Pro from Codex? Are you limited to just copy and pasting inefficiently between the web UI and Codex?

In this article, I'm going to explain how to insert GPT Pro into your knowledge work, whether that's academic work, business or consulting, or software development, and how to do it in a way that eliminates the friction between GPT Pro and Codex.

The goal is simple: no manual copy and pasting, while still providing complete context about your codebase and your problem to GPT Pro.

Want to watch/listen instead?

I made a YouTube video corresponding to this article, where I additionally go through a live demo walking you step by step through how to use GPT Pro from within Codex.

How to Insert GPT Pro Into Your Workflow

The way I insert Pro into my work is to have it review my plans for my hardest problems, after first having taken a pass at planning and thinking through those problems with some combination of Codex and Claude Code.

Why is that?

For many types of software and research, Codex and Claude Code alone are sufficient to produce good or excellent results. If you don't need the more powerful Pro thinking model, then there's no need to include it in your process.

My usual process towards creating anything significant, whether software or some research project, is to first iterate on a plan in various cycles using some skills I've created and some skills I've borrowed from others, usually with both Codex and Claude Code, until I feel content with the plan I've produced.

Then I typically pass the plan to Codex to implement, because I find Codex much better at implementing and doing work than Claude Code.

However, there are two conditions under which my next step will not be to implement, but instead to have that plan reviewed by GPT Pro.

First, if I have significant doubts about some aspect of the plan, either from a technical perspective, an architectural perspective, or a product perspective, I'll pass the plan along with my contextual questions to GPT Pro for review.

Second, even if I don't have doubts, but I think the plan is on some topic of significant architectural, technical, or scientific complexity, I'll pass the plan or the piece of writing to GPT Pro for review. This includes research or writing projects where I'm making some difficult, nuanced argument.

The exact threshold for determining what counts as sufficiently architecturally, technically, or scientifically complex is going to vary a lot across fields, across projects within fields, and across people for a given project.

For example, if you're working in number theory, on the class of problems that are starting to get solved by others with ChatGPT Pro, it's likely that regardless of who you are, for any problem you're working on in this space, you're going to want to think about how to best structure it to be attacked by the GPT Pro model.

Let's consider additionally two fields I have experience with, where the use of Pro is much more ambiguous: economics research and consulting work.

GPT Pro in Economics Research

I’m an economist, and I’ve worked with over 100 economists across group and individual sessions helping them get up to speed with agentic coding tools.

Economics research can vary in complexity both across and within fields of economics. Additionally, within a particular project, there can be more or less complex tasks.

For example, I noticed when working with a renowned economist in the field of industrial organization (within applied microeconomics known to be a very technical field) that using GPT Pro on a plan before implementing some kind of structural estimation we were considering helped a lot.

GPT Pro was able to come up with many nuances and objections which this professor, who has several publications in top five economics journals, agreed upon reflection were worth addressing in our plan.

I mention this to calibrate you - if you’re unfamiliar with GPT Pro - to the quality of thought you can expect from GPT Pro.

Now, among applied microeconomics fields, industrial organization is known to be the most technical.

When working with applied microeconomists specializing in labor and political economy, we haven't found much of an advantage to using Pro, because the empirical methods typically used in those fields are, for coding agents now, pretty simple and rote.

Additionally, across all these fields, Pro is not helpful for tasks involved in actually implementing models, or for anything which requires interactive data analysis, because Pro has no ability to write code, query a dataset, and then update based on what it finds.

Finally, even when applying GPT Pro to more complex theoretical fields like microeconomic or econometric theory, there is skill and thought that needs to go into how to package a given prompt for GPT Pro.

Often, simply dumping a set of PDFs and asking a question to GPT Pro is not going to get you good answers.

Instead, what's better is to have pre-processed any input PDFs you want to give as context to GPT Pro, and to extract from those PDFs just the essential parts that are relevant to the problem you're facing.

My point in bringing up this example is that your pre-existing agentic coding skill and understanding of context management still matters, and could be pivotal for getting good results out of GPT Pro.

GPT Pro for Consulting Work

Consulting is another field in which the decision to use GPT Pro is more ambiguous.

My own consulting work is typically some sort of AI implementation or AI education, but the nuances I've experienced with finding the appropriate place to use GPT Pro apply to any kind of consulting.

In my consulting work, I do many tasks at varying levels of complexity. For example, I often have to write proposals.

These proposals can sometimes be fairly standardized, but typically they have to be individualized for a particular client's needs, whether for something I'm implementing for them or some kind of agentic coding training.

So I have a skill I've made to help me think through and automate the individuation of proposals, and to brainstorm requirements that are particular to each client.

What I'll often do, especially for fairly complex proposals, is ask Pro to review the proposal before sending it out and see if it finds any flaws.

This often turns out to be quite helpful for finding flaws at a structural level in a proposal. These are flaws I may not have thought of, but which are going to be important for an eventual implementation, and which lesser thinking models usually don't catch.

The types of things Pro often catches include clarifying questions I should ask, and which decision makers I should ask them to, in order to more tightly scope some deliverable.

Often, it'll also help find small and sometimes big inconsistencies between what a client has requested, usually based on call transcripts I've had with the client, and what I'm asking for in the proposal.

Especially when we have many calls to scope something out, little but important details can get lost. I find Pro often helps me find those details in the proposal.

In the context of teaching, Pro might give me ideas for how to better structure a curriculum and the order in which to introduce certain topics, given where my audience is likely to be coming into some agentic coding course. It can also help me think about creating a single course that can serve many audiences at varying levels of ability.

Claude Code and Codex can, of course, help you figure these things out too. I just find that Pro is really good at finding things neither of them will catch.

GPT Pro for Software Development

Besides proposals, the other place where I get a ton of alpha from GPT Pro is thinking through plans for architecturally complex software.

For me, and for a lot of developers now, the part of creating software that takes the most mental energy is planning what you're going to build.

The actual implementation, conditional on a good plan, is pretty easy. Models like Codex are now very good at long-running tasks and staying reliably on target.

Now, if you're making a simple CRUD app, meaning create, read, update, delete, then often you can just vibe these things without even making a plan ahead of time.

It might not match exactly what you had in your head, but if you don't care about it fulfilling very exact requirements, and it's a simple app, maybe you don't need a plan.

However, in my opinion, the ease of making good CRUD applications, even with agentic coding tools, is somewhat overstated.

On some level, something like Linear, the project management app, can be reduced to just thinking of it as a CRUD application. You're creating new issues, updating them, moving them along a Kanban board, and deleting them.

You might think, "This isn't really complex software. I could just make it myself."

Then you try to make the software and find that there are all sorts of fine edges, lots of incredible UI choices Linear has come up with, and lots of little conveniences that they have put a ton of thought into, which serve real project management needs.

But definitely, if I'm making more complex software, I'll take my plan and send it to GPT Pro.

For example, here's the architecture for PaySlice, a fintech product I've worked on.

PaySlice has six services in three different environments. There's a handful of external vendors: Plaid for banking, Finix for payments, and Supabase for auth.

There are two operational databases, plus a separate analytical warehouse, an orchestration layer with Dagster, a business intelligence app, and an operator tooling lane.

All of this has to stay coherent.

A single product change - say adjusting how the app displays paydate readiness - can ripple through nine of these boxes across all environments.

This is exactly the kind of system where I would refuse to implement a plan before first passing it through GPT Pro.

The seams a good plan needs to respect are bigger than what I can often reliably hold in my own head, and bigger than what I find Codex or Claude Code will reliably surface on their own.

When should you use GPT Pro?

So we've covered three pretty diverse use cases: economics research, consulting, and software development.

But for you, in your own situation, which may include some of these use cases or perhaps others, how do you figure out when it's worth the time to use GPT Pro?

My recommendation for figuring out this appropriate complexity threshold is to simply experiment yourself.

For different problems where you're considering receiving Pro's input, give the same prompt to Pro in one thread and Thinking in another thread, and see if there's a difference in the quality of the results you get.

Initially, you might want to send every problem you would consider giving to Pro to both Pro and Thinking.

Then you'll get a sense over time, and intuition for the particular domains you work in, of which tasks really need to be sent to Pro and which ones you can just push forward on with Thinking.

How to Use GPT Pro From Codex

Next, let's discuss the practicalities of how to actually use GPT Pro from Codex.

As I mentioned, GPT Pro doesn't show up in the Codex model picker.

You could connect to it by API using a coding agent like OpenCode, where you can pay for any model by API, but your bill will get ludicrously expensive fast.

So the practical question becomes: how can you get all the relevant context, your plan, surrounding code, important business or research ideas, and documents in front of Pro without manually copy and pasting a dozen files into the ChatGPT web UI?

The answer is to split the problem into two.

First, package the context. You have a coding agent assemble a single file as a bundle, taking all the relevant context in your repo and turning it into one file, including your prompt and what you want to ask ChatGPT Pro.

Second, ship this bundle to ChatGPT. Something, ideally something automated, opens ChatGPT in the browser, puts in the bundle you've created, selects the right model, presses enter, and then waits 5, 10, 20, or 30 minutes, however long it takes to get the ChatGPT Pro response back.

For step one, I use Oracle, a command line interface created by Pete Steinberger, the creator of OpenClaw.

Oracle's job is narrow and useful. You give it a prompt and a set of files or globs, and it expands them into one markdown file, respecting .gitignore, ignoring folders like node_modules, warning you when the package you're creating for Pro is going to blow past Pro's context budget, and then copying it to your clipboard.

Here's one command, for example, that you could use:

oracle --render --copy -p "<your task>" --file "src/**" --file "docs/**"

In practice, I don't use Oracle manually in the command line interface.

Instead, I've created a skill which I've made publicly available in my skills repository.

You can download the skill here: https://github.com/aniketpanjwani/skills/tree/main/skills/general/oracle . I invoke that whenever I want to get ChatGPT Pro's opinion on anything.

For step two, taking this package Oracle has made and getting it to the web UI, I use the Codex Chrome plugin.

Codex opens ChatGPT in Chrome, pastes in the Oracle bundle, waits for a response, and then brings the response back to Codex.

Once the answer comes back to the Codex session, I can review it, argue with it, or pass it forward to implementation.

I made a video last week on the Codex Chrome plugin:

It's great. I love it. But there are a few things to be aware of.

1. If you're in Europe, the Codex Chrome plugin simply isn't available yet.

2. Sometimes I even find on my computer that Codex is not able to access the Chrome plugin, even though I have it installed. There are little hiccups.

What I do instead, and what I've enforced in the skill, is roll back to Computer Use, which is available on Mac and allows Codex to control any application on your computer.

The benefit of using the Chrome plugin is that if it's working, it'll be able to work with your Chrome session in a background tab without taking over your entire Chrome window.

With Computer Use, you can't work simultaneously in Chrome while Codex is doing its thing with Oracle in the ChatGPT window. With the Chrome plugin, you can.

Finally, there is a third option: you could use Browser Use, which is Codex's in-built browser inside the Codex application.

I use Browser Use all the time, especially for debugging web applications, but I find it to be the buggiest of the three. It's the one that works least consistently.

You'll also have to authenticate separately in this Browser Use session in the Codex desktop app, whereas Computer Use or the Chrome plugin will use your already authenticated session in your Chrome browser.

So it's a little bit easier to use the Chrome plugin or Computer Use when they work.

Conclusion

That is the full loop: use Codex or Claude Code to create the plan, use Oracle to package the relevant context, send the bundle to GPT Pro through an automated browser flow, then bring Pro's answer back into Codex and decide whether to revise the plan or move into implementation.

I don't use Pro for everything.

But when the problem is complex enough that the cost of a missed nuance is high, GPT Pro is where I want the plan to go before I trust myself to build from it.