Recently, Anthropic announced introducing a new weekly limit that will cap usage of Claude Code, in addition to the already in place 5 hour rate limit, Anthropic is.

They said it will affect less than 5% of their users. While I know I'm definitely not in the 5%, I wanted to see what other options were available on the market. It would also allow me to stay on top of new developments, and also in case the rate limiting does hit me in the future.

But then, in the middle of me exploring those options, GPT-5 dropped, so I also included it in the rundown.

Methodology and Use Cases

But first, let's agree on what we're evaluating here.

I mainly do native app development using Swift for Apple platforms.

For my new apps, one productivity booster I've found is making a prototype, sometimes literally in less than an hour. Then I would use the app to refine my vision, before deciding if I want to build a real fully fledged app or not.

So I just give a prompt to the assistant and expect a fully functional app afterward.

Here's the prompt by the way:

	You are in the project for an iOS app.
	This app must do the following:
	- Allow users to enter what they ate
	- Allow snapping pictures of a dish
	    - Send those pictures to an LLM for detailed description
	- Based on the detailed description done by an LLM or by the user, send that to an LLM to compute: total calories, proteins, carbs, and fats in grams
	- The user can enter the daily intake of calories, proteins, carbs, and fats
	- Each computed entry based on description or description from picture subtracts from the daily total, showing how much is left for each
	- Additionally, each entry is saved along with pictures and or description for that entry (use SwiftData for persistence)
	- The app also allows intermittent fasting insights, it shows how much time elapsed since last ingestion
	- There is already @FastAndTrack/AIProxyService.swift file with many methods to call LLMs
	- Implement the rest, such as image upload + description using the docs here: https://github.com/lzell/AIProxySwift
	Ultrathink and plan and present me with 3 plans to implement this that I can choose

Let's unpack what we're expecting from the model with this single prompt:

• Implement a full app (which means also handle the architecture aspect)

• Respect a set of features, moderately complex

• These features imply talking to an LLM, so we expect prompt generation as well

• Intertwine two features that are related (calorie tracking by registering a meal and computing fasting time since last registered meal)

• Integration with an already existing piece of code (AIProxy service)

• Extension of the already existing code using online documentation

• A moderate amount of reasoning for architecture and planning

This means that this method is a good test for prototyping, but not necessarily representative for complex bug fixing and large codebase handling.

Still, for day to day development, I would say it's a rather representative task.

Assistants and Models Evaluated

Here's what I ended up evaluating:

• Cline + o3

• Cline + Kimi-K2

• Cline + Qwen3-coder

• Cline + GPT-5

• Copilot + Sonnet 4

• Copilot + GPT 4.1

• Copilot + o4-mini

• Copilot + Gemini 2.5 Pro

• Copilot + GPT-5

• Cursor with GPT-5

• Cursor CLI with GPT-5

• Claude Code + Sonnet 4

• Claude Code + Opus 4 (my daily driver until now)

A Word on Assistants

Let's begin with the assistants themselves, as they shape so much of the development experience.

Cline

The power of openness cannot be overstated. Cline's transparency is refreshing, knowing exactly how many tokens you're using, what's cached, the cost, tool usage, and the current context window size makes you an LLM power user.

I particularly love that session management is fully transparent and well integrated. You can inspect sessions easily, revisit, and resume them even after weeks.

Furthermore, it can rely on a local installation of Claude Code, tied to your subscription, without burning API tokens. The VS Code integration feels natural and unobtrusive.

Finally, I liked the way it suggests by itself to spawn new tasks to avoid polluting the main context.

However, I find that it lacks consistency: oftentimes, it just breaks in the middle of a task, either because the request died, or some obscure error, and it's not always easy to recover.

Claude Code

Claude Code remains excellent in its simplicity. No fancy UI, just a bare terminal. The extension integration in VS Code makes it even more natural and well integrated in an IDE. The development team is incredibly active though, and you can expect regular improvements and new feature at a fast pace.

What Claude Code lacks in transparency, it makes up for in reliability. It just works, consistently. I'm now very used to it, but the initial learning curve might be a bit steep, but worth it.

Copilot

Microsoft is moving fast with Copilot, though it still feels too similar to Cursor for my taste. The UI/UX is nice. I noticed something interesting: Copilot seems to have its own auto-compact mechanism when context gets full, but the context windows feel much narrower. It summarizes conversation history more aggressively than other tools, and is quite slow at doing it.

Models Evaluation

Now for the meat of the comparison: how did each model perform on my prototyping task?

The Usual Suspected Winners

No need to hold the suspense longer: Claude Opus 4.1 and Sonnet 4 continue to reign supreme.

What sets Claude apart isn't just the code quality, it's the nuanced understanding of developer needs.

While other models give you difficulty variations (MVP, modular project, over-engineered solution), Claude provides architectural choices that actually matter: For instance, MVVM vs Service-Oriented Architecture vs Clean Architecture.

It's the difference between talking to someone who knows a thing or two about development and an experienced fellow developer.

Claude consistently surprises me by thinking of things I haven't mentioned. It's like pair programming with someone who actually gets it, on a very broad set of skills, not just technical.

Even when working with Swift, where the models aren't usually up to date, Claude manages to produce clean, functional code. And you can cover the rest with a well-crafted CLAUDE.md.

When I ran my calorie tracking app prompt through Claude Code, I managed to get a fully functional app, while in the meantime, Copilot with Sonnet was still trying to fix another round of errors.

Some Disappointments

o3 left me conflicted. It seems to want to engineer well, sometimes even over-engineer, but then produces something surprisingly simple that doesn't align with its own elaborate plan.

I encountered consistent breaking issues, though I couldn't determine if the fault came from o3, Cline, or their interaction. Twice, when trying to create simple one-shot prototypes, I ended up with non-functional apps even after fixing compiler errors. o3 lacks the consistency that makes Claude so reliable.

GPT 4.1 immediately tripped over basic requirements. It's surprising how quickly it falls apart compared to its counterparts.

Honorable Mentions

o4-mini performed better than expected, oddly even surpassing o3 in some cases (though this might have been a fluke). It often just stops before completing tasks and needs constant encouragement, and error fixing is painfully slow, but when it works, the results are decent, just not at Sonnet 4's level.

Gemini 2.5 Pro remains very, very good, just a step behind Claude. It's an excellent second choice. I'm very excited about Gemini 3 in that regard.

Promising Models (and budget options)

Kimi-K2 impressed me despite its tiny context window (32-64k max). The planning capabilities are solid, it's blazingly fast on OpenRouter's free tier, and produces remarkably clean code. The prompts it generates are elaborate and thoughtful, unlike most others except Claude. The app outputs are simpler, I can't expect it to "innovate and surprise me" like Claude does, but for a free and open-source option, it's remarkable.

Qwen3-coder brings something unique to the table: it asks clarifying questions, similar to what o3's deep research mode does. I appreciate the control and insight this offers, though it's not for everyone. The generated prompts are advanced and sophisticated, getting really close to Claude's quality. It's quite good at figuring out when it needs to build, in fact, it was the only model that truly one-shot the build process correctly. However, it's painfully slow and tends toward oversimplification.

The GPT-5 Experiments

I couldn't resist trying GPT-5 with various assistants, and the results were, let's say... educational.

GPT-5 + Codex CLI

This combination is fast, but error-prone. It generated decent prompts and fair code quality, but then it did something I've never seen before: it literally hallucinated errors because it wouldn't, or couldn't, build! After failing to build the project, the model wrote: "Given these constraints, I might end up simulating compile errors by scanning for common mistakes in the code instead."

After a few tries, it finally figured out xcodebuild, but the experience felt raw. Codex CLI is far from Claude Code's polish. The ideas were good but simplistic, missing that wow factor that makes Claude special.

GPT-5 + Cursor / Cursor CLI

I really wanted this combination to succeed, but it just isn't there yet. Fewer errors on the first try, though oddly some non-matching braces slipped through.

GPT-5 + Cline

This combination consistently hit "request too large" errors. Not much to evaluate when you can't even get started.

GPT-5 + VS Code Copilot

It hit the context window almost immediately, and then proceeded at a snail's pace with minimal effectiveness.

Bonus task

Since I was in the middle of implementing an iOS UI for Summiqo, I took a small detour to try it with Claude Code and GPT-5.

Claude Code (with Opus 4.1) surprised me again, it reviewed the macOS UI code, generated an iOS version and made a fair UI, well adapted for iOS.

I won't ship that, as I have some pretty personal UI taste, but it was good to have a solid basis and some ideas to iterate against.

The real disappointment came with GPT-5: instead of creating a proper iOS interface, it basically took the macOS implementation and made minimal adaptations to make it compile on iOS. The resulting UI looked completely broken and unusable.

Insights and Patterns

After this exhaustive testing, some clear patterns emerged:

The quality of architectural planning is key to achieving a good result. Claude understands that different architectures serve different developer preferences, not just project complexity levels. Other models seem to think architecture is just about how many files you create and how convoluted your data flow will be.

Transparency matters. Cline's openness about token usage and context was really appreciable.

And Cline does have a point when they say their incentive is aligned with developers: they don't try to optimize token reduction, whereas tools provided by Anthropic, OpenAI, Google, and even Microsoft explicitly want to reduce token use since they are essentially subsidizing token cost with their subscription, to win over the largest user base.

Speed isn't everything. o3's blazing speed meant nothing when I spent three times as long fixing errors. Claude's measured pace with consistent quality wins every time.

The integration between assistant and model matters immensely. Sonnet 4 performs far better with Claude Code than with Copilot, probably because Anthropic knows their model well enough to make tools that work well with it.

Conclusion

If you're on a tight budget, the Kimi-K2 and Qwen3-coder combination with Cline and OpenRouter's free tier is genuinely viable. It won't blow your mind, but it'll get the job done.

For serious development work, Claude (Opus 4 or Sonnet 4) with Claude Code remains unmatched. The rate-limiting and token optimization concerns are real, but the quality gap is equally real. It's the difference between having an assistant and having a pair programmer.

The landscape is evolving rapidly. Six months ago, this comparison would have looked entirely different, and six months from now, it might be unrecognizable. But for now, in August 2025, Anthropic continues to understand not just code, but coders.

What strikes me most is how personal the choice of AI coding assistant has become. For me, it's not just about which model produces fewer errors or generates code faster, it's about which combination fits my workflow, understands my intent, and surprises me in the right ways.

For now, I'll have to keep my Claude Code Max subscription and hope those rate limits don't bite too hard. But it's comforting to know that viable alternatives are emerging, each with their own strengths and quirks. The future of AI-assisted development isn't about one perfect tool, it's about a rich ecosystem of options, open and transparent if possible, each pushing the others to be better.