GPT-6 Astra was recently released. I got access to it on Friday evening, European time, and have been using it extensively ever since. In this article, I’ll share my first impressions of the model and the techniques that I utilize to get as much as possible out of the model to maximize its effectiveness.
I’ll also share some of the downsides I’ve experienced with the model and how I’m attempting to deal with them in the coming weeks, when I’ll be using the model more and more, and we’ll be trying to maximize how productive I can be with the model.
This infographic highlights the main contents of this article. I’ll discuss how to get the most out of GPT-6 Astra and my first experiences with the model. Image by ChatGPT.
Why use GPT-6 Astra
Firstly, I always like to cover why you should care about the topic of an article. In this case, it’s because GPT-6 is the latest release from OpenAI, which is one of the frontier labs. This naturally makes it one of the LMs that you immediately want to try out to see how well it performs on my workflows. My workflows mostly consist of coding tasks, though I do have some other tasks such as using my computer, moving around in the browser, and doing research, so measuring how well it works for deep research and so on.
I use coding agents essentially every day, and thus I believe I have a very good baseline to compare new model releases against. GPT-6 is also a very hyped release, and it’s a new major release from a frontier lab, which is of course extremely exciting.
My first impressions of GPT-6 Astra
First of all, let’s cover my first impressions of the model. Immediately, once I started using the model, I started testing a few things:
-
Running it on tasks that I’ve done before
-
Running it on some new tasks (feature implementations and bug fixes)
-
Starting to look for refactoring opportunities and, in general, opportunities to improve my code repositories.
My first impressions will thus be based on my experience when running these three tasks. I would like to note, however, that first impressions might not give the best picture of how good the coding model is. The reason I say this is that I remember when GPT 5.6 Sol was released, I got extremely good first impressions of the model, and I still would say it’s a very good model. However, over time, I started to notice some quirks with the model where it didn’t work as well, and these quirks were something I didn’t discover for a week or two by actively using the model. Thus, I wouldn’t have discovered such quirks yet when it comes to GPT 6.
Nonetheless, I’ll give my review. So when it comes to running tasks that I’ve done before and verified, or that I verified that both Claude Code and GPT-5.6 Sol were able to do, I would say GPT-6 was, of course, able to do them all. But one thing I actually noticed in favor of GPT-6 is that it achieved it way faster, and I don’t think this has anything to do with inference speed. In my experience, this just seems like the model is more effective at utilizing its tokens and is more able to complete tasks quickly.
This impression was further verified once I started to run the model on new tasks as well, both finding bug fixes and feature implementations. It just seems like the model was able to complete tasks super quickly while also doing it correctly, at least when comparing it to both the previous generation of OpenAI models and when comparing it against Claude Fable 5, which is the other frontier model available on the market.
I found this very useful and thus immediately switched to GPT-6 as my main driver to perform coding tasks. Currently, I don’t see any area in which Fable 5 is superior, other than the fact that Fable is more effective at spinning up sub-agents. I do find that Fable is better at spinning up sub-agents. So if I wanna complete a bunch of smaller tasks, I do tend towards using Fable 5.1 still.
···
Now the last test that I also did was starting to look for refactoring opportunities with the model. This is overall a very fun exercise, and I do that with every new model release. For example, when Fable released, when Opus 5 released, when GPT 5.6 Sol released, and so on. And my general prompt is something like:
I then have the agent work for however long it takes, and it comes back to me with a full HTML report. If you run this with models such as Opus 4.8, Opus 5, or GPT 5.6 Sol, it will come up with some okay feedback, but it won’t be really particularly good feedback that will help your code repository a lot. Yes, you definitely have to do the refactoring on a regular basis, but I would say that I noticed a very stark difference when doing that with these previous generations of models versus doing it with either Fable 5 or GPT-6. And in my experience, GPT-6 is also superior to both Fable versions when it comes to detecting opportunities to enhance my code repository.
I simply found that GPT-6 was better able to find issues that I had in my code. Not only did it find some stuff in my CI-CD pipeline that I could prune to make it faster and some parallelization opportunities, but it also discovered some limitations I had throughout my codebase that I wasn’t aware of. For example, how I was using certain packages, some UI issues I wasn’t aware of, and in general, I just found it stronger at detecting such issues. Thus GPT-6 would definitely be my main driver to perform refactoring going forward.
I would like to note, however, that though I do find GPT-6 superior to Fable, it’s not far superior to Fable; it’s one step above, but I would say the difference between GPT-6 and Fable versus the previous generational models (Opus and GPT-5.6) is a bigger difference than the difference between Fable and GPT-6.
···
Lastly, I just want to mention one downside that I’ve noticed with GPT-6 when using it now, and that is that it does seem to ask a bit too often for permission to do stuff, when in reality I just want it to continue working until it’s completely done with the task. Now, I am aware that this could be an issue with the prompts that I’m using and the markdown files in my repository, so I am working to optimize this, but this is an issue that I’ve noticed with GPT-6, where it’s not as strong as I would have hoped for.
The best coding agent, in my opinion, is the one that simply takes the task you give it, immediately asks any clarifying questions or things that it needs to know before starting to implement, and then it only comes back to you once it’s completely finished with the implementation. Now, of course, I do realize that in some cases the coding agent has to ask you clarifying questions because of some things that come up during implementation. But I do think that GPT-6 tends to do this a bit too much, which could be an issue with the model not performing due diligence enough before starting an implementation or being too unsure about itself when actually performing the implementation. This is definitely something I’ll keep in mind going forward as I try to optimize, and I’ll come back at a later point with my updated opinion on this issue with GPT-6.
Overall, my first impressions are very good, and I’ve turned to GPT-6 for my main driver for coding, only returning to Fable when it comes to spinning up sub-agent-heavy sessions or, of course, when I want to review code with a separate coding agent where it is beneficial to run it with a different coding agent than the coding agent that was implementing the code.
How to get the most out of GPT-6 Astra
Now, let’s start talking about how to get the most out of GPT-6 Astra. The first thing I would immediately do if I were you is to start performing refactoring on your repository. There’s likely a bunch of things that you can do with your code to make it easier for coding agents to perform fixes there in the future, whether it’s GPT-6 Astra working in your repository or a previous generation of models. Thus, I urge you to start doing refactoring immediately, for example, using the prompt I listed above.
This will probably increase coding iteration speed, reduce the chance of bugs in your repository, and overall improve your coding productivity.
Next, I would probably move to starting to test GPT-6 for new coding implementations. In my experience, it’s very good at getting stuff done, though, of course, it does have the one downside I mentioned earlier, where it does ask for permissions a bit too much. I urge you to try to clarify as many questions as possible beforehand and make it as clear as possible to the agent what it has to implement, the things it has to consider during the implementation, and make it clear what permissions you’re giving to the agent so it just doesn’t have to ask for too many permissions.
One thing to consider when using GPT-6 Astra is that, of course, it has limited usage. Specifically, because they don’t have 5-hour usage, you could be spending a bunch of your weekly allowed usage in one day, and I’ve found that I’ve been able to spend at least 1.5 weekly usages in one day by utilizing resets.
That’s because Codex offers usage resets. They’ve been giving out a lot in the last week at least, so I had 3 available on one of my subscriptions.
However, I’m not necessarily sure that switching to GPT-5.6 Sol will make this issue any better. The reason is that I find that GPT-6 is more token-efficient, and the actual cost for implementing a task might not be that different for GPT-5.6 versus GPT-6, which is definitely worth keeping in mind if you want to try to save tokens. Instead, if you want to save tokens, I urge you to think about the input tokens you feed the model- for example, looking through your MD files, any MCP tools that you’re loading into memory, and so on- and try to limit those as much as possible so you don’t take up too many of the input tokens the model has available.
I also think it’s worth being aware that the model has around a 260,000-token window, which is smaller than the token window you’re allowed to use on Fable or Opus with Claude Code, where you’re allowed 1 million tokens. This has both pros and cons. The downside of a smaller configured context window is that the agent may need to compact more often during long-running tasks. The benefit of this approach, however, is that the model will likely be faster than if you allowed a 1 million-token context window because more input tokens mean the model is slower to respond. And in my opinion, quality goes up if you have fewer input tokens.
Codex offers a 1 million-token context window setting that you can enable, though I do not recommend using it because it’s not recommended by the people creating GPT-6, and thus you likely shouldn’t be using it yourself either. Both because of performance and because of how it will impact your usage limits.
Overall, when utilizing GPT-6, I urge you to think about the usage that you have with it. Start by refactoring some repositories; this will make the agent more effective when working in the repository, and it will make any other coding agent that you use in the future more efficient when performing implementations. I then urge you to just try it out on tasks, providing it with as much information beforehand as possible because the model does tend to ask you for permission a bit too much rather than a bit too little, based on my first experience.
Conclusion
In this article, I discussed my first experience with GPT-6 Astra, which is the latest model released from a frontier lab and the new model family basically of OpenAI. I was extremely impressed after my first experience with GPT-6 Astra, which I’ve been using throughout the whole weekend. The model is extremely effective at completing tasks, and it seems like it’s just more able to complete tasks correctly in a shorter amount of time than any previous coding agent that I’ve used, whether it be OpenAI’s code agents or the frontier models offered by Anthropic with Claude Code.
To get the most out of the model, you should start by reviewing your repository for any refactoring opportunities. And then, before you move on to start implementations such as bug fixing or new features, you should make sure the task and permissions the model is given are very clear beforehand to avoid any unnecessary interruptions by the model.
👉 My free eBook and Webinar:
🚀 10x Your Engineering with LLMs (Free 3-Day Email Course)
📚 Get my free Vision Language Models ebook
💻 My webinar on Vision Language Models
👉 Find me on socials:
💌 Substack