I use opencode as my primary development interface and agent harness. Specifically, I'm using the opencode extension within VS Code so that I can easily browse the directory structure, click around different files in the GUI to review changes, and manage multiple opencode windows at once in an integrated view. Maybe I'm somewhat stuck in my ways, but it still feels more comfortable to be within VS Code and have some of its familiar interfaces and shortcuts as opposed to being fully in the terminal exclusively.
However, up until recently, I had been using Claude Opus 4.7 as the model powering opencode. I have always really liked the experience with Opus + opencode and have been very satisfied with the quality of its output. The only problem is that it's not very economical. API costs can grow rapidly. So I decided to give the OpenAI ChatGPT Pro tier subscription a shot since you can configure opencode to use your subscription to power its responses, as opposed to using the OpenAI API directly and having to pay separately for API token consumption.
I had a couple of concerns about whether this change would be worth it long term: 1) Would I run into rate limits and have to fall back to using the API directly anyway? I'm using opencode for full-time development every day, so I hoped the request rate limit would be high enough. 2) Would the quality of the code changes be comparable to the output of Opus? Claude models are still generally considered to have an edge at software development over the corresponding GPT models. If the output quality was significantly different, then that would be a problem and could possibly justify the greater expense of using Opus. Regardless, it was worth testing out to see for myself.
After making the switch and using GPT 5.5 on the xHigh reasoning variant for a week, I have mixed feelings.
The rate limits, even at the highest reasoning setting, seem to be far more than adequate. Even after very long full days of coding non-stop, I never once hit the limits. That was very impressive to me. That meant that the subscription cost of $200/month would be the full fixed cost of completely agent-driven development. That's a fraction of what the total monthly cost of using Opus 4.7 in opencode on a daily basis was reaching. So economically, the win definitely goes to OpenAI.
Now, regarding output, the first thing I noticed is that the "vibe" of the responses felt different. That took a little bit of getting used to. I think, generally, the responses from GPT 5.5 are more concise and direct than those from Opus. Opus feels more verbose, but in a good way, providing more relevant context that wasn't explicitly asked for about the examined files or planned modifications. I feel like with GPT, I have to explicitly guide it and ask for more specific pieces of information than with Opus. Using Claude, I felt like I could give intuitive descriptions of what I was looking for and what I wanted to do, and would get back comprehensive, detailed responses containing everything I had meant and wished for but had not explicitly stated. I also noticed that Claude will prompt me with clarifying questions proactively and far more often than GPT does. GPT rarely asks me questions and instead jumps right into either making changes or planning its approach based on its own assumptions. This was very interesting. It also feels like Claude is better at fully utilizing the different tools in the agent harness provided by opencode, whereas GPT seems to use simpler and more direct interactions as opposed to utilizing the full scope of exposed tools.
As for the code quality of the changes made, that's where they felt much closer in performance. For most of my web development tasks, there wasn't a significantly noticeable difference in the perceived quality of code or the consistency and accuracy of successfully completing a given task. Claude would typically be able to fix the bugs I gave it, diagnose issues correctly, and make relatively simple UI changes correctly. I didn't notice a huge difference in that aspect when using the latest GPT model. It was also able to consistently provide satisfactory changes to address those same types of problems. That was pleasantly surprising, and definitely makes the significantly cheaper price tag more worthwhile. The vibe difference I can get used to for such a cheaper price tag.
There were still a few cases where GPT 5.5 struggled to correctly address more subtle bugs or more complex UI changes. When doing significantly large refactors, I did end up switching back to Opus since it has won my trust during similar tasks earlier this year, before testing this model switch. I was very happy with the results it produced while requiring less guidance and fewer iteration cycles compared to attempting that same work with GPT.
The main takeaway I got from this was that it's clearly most effective in terms of productivity and capital to use both models interchangeably depending on the complexity and scope of the task you're working on. For most regular day-to-day work like debugging, small to midsize clearly defined new features, and explicitly constrained refactors, I think GPT 5.5 is entirely adequate. For more complex tasks, or those where you require a higher degree of confidence in the correctness or quality of the work, Opus 4.7 provides a little extra peace of mind and satisfaction. Using GPT for the majority of tasks and then using Claude occasionally as needed is still far more economical than using solely Claude Opus, completely justifying the ChatGPT Pro tier subscription cost. This reaffirms the idea that we shouldn't get overly attached to any specific model provider. We should be willing to experimentally justify different use cases for different models, especially in the face of rapidly increasing usage and steadily rising costs.