Thanks, Tobias — your explanation makes a lot of sense, especially the distinction between the $20 tier being suitable for smaller or limited-complexity projects and Pro becoming necessary once the application grows into something much larger.

My situation is slightly different because I have been deliberately comparing several systems in parallel rather than using only one provider.

Over the last few weeks, before GPT-5.6 appeared, I was working almost exclusively with the highest GPT-5.5 configuration available to me. At the same time, I also tested Fable 5 through OpenRouter, Antigravity, Google’s Pro models, and the latest Opus model.

In many cases, I gave them exactly the same task, based on the same repository, screenshots, requirements, and expected result. Even relatively small tasks turned out to be useful comparisons because they showed very different failure patterns.

One model might produce technically clean code but misunderstand the product intent. Another might understand the visual direction but damage existing behaviour. Another could complete the task quickly, but the result would require several rounds of corrections before it became usable.

So I am not comparing them only by benchmarks, response speed, or how impressive the first answer looks. I compare how much usable work I actually receive after the entire implementation and correction cycle.

Fortunately or unfortunately, GPT is still the system I keep returning to.

Compared with Gemini Pro, the latest Opus, Antigravity, and the other systems I tested, GPT-5.5 generally gave me the best combination of contextual understanding, implementation quality, and ability to connect an isolated task with the broader product.

I completely understand that my current subscription is not really designed for the kind of sustained development I am attempting. I am based in Ukraine, and at the moment I simply cannot pay for the highest subscription tier from every provider simultaneously. That is why I test them selectively and try to understand which system genuinely gives me the highest return on the money and time invested.

But what I managed to build with GPT-5.5 genuinely changed my understanding of what one developer can create with these tools.

I built a production PWA application around a concept for which I still have not found a direct equivalent in Google Play or the App Store. I was originally inspired by an existing application that was reportedly acquired for around $10 million and is said to be generating more than $5 million per month.

However, I did not simply reproduce that application.

I reconsidered the concept from the end user’s perspective, rebuilt the interaction model, created what I consider a significantly stronger interface, and connected functionality that the original product does not provide. The result is not just a clone with a different design. It has developed into a fundamentally different product.

And most of that was built with GPT-5.5.

That experience was honestly remarkable. GPT did not merely help me work somewhat faster. It allowed me to move the product several levels beyond what I initially believed one developer could realistically design and implement.

Now, using GPT-5.6 Sol and Terra, I am working on another version that is not simply a larger update. The entire concept is evolving in a direction that, as far as I can currently see, has not yet occurred to anyone else in this product category.

So despite the quota problem I described, and despite the fact that I clearly need to rethink how much documentation I preload into the context, GPT-5.6 currently remains the strongest result in my own practical comparisons.

Your point about context waste is especially useful here. My documentation was created as accumulated failure prevention, but I can see how seven specification files, screenshots, repository context, architectural constraints, and the immediate task may compete for the same limited context window.

For my next experiment, I will probably try something closer to your workflow: let the repository communicate more of its own conventions, provide only the task-specific context that is genuinely necessary, use a cleaner session boundary, and rely more heavily on browser-based verification.

I am also beginning to agree that Pro may not simply be “more usage.” For serious development, it may change the nature of the product completely — from something you can experiment with for a few hours into something you can actually use as a daily engineering environment.

At the moment, though, I have to test that conclusion from the Plus side.

Thanks again for sharing the details of your workflow. The fact that you are successfully working with approximately 150k lines of code, Sol Extra High, visual tooling, and long sessions gives me a much more useful reference point than any benchmark.