How I Started Relying on AI
My previous post on this blog appeared in early December 2025, and barely half a year has gone by since then. In that short span, the way I approach my daily work has been turned upside down. Up until November 2025, I was convinced that AI had no place in my workflow on large enterprise Angular codebases, where mediocrity is simply not acceptable.
Everything changed when Opus 4.5 went public on November 24, 2025. My initial experiments were promising enough that I quickly started using it for substantive tasks: generating code, reviewing existing implementations, writing documentation, modernizing legacy modules, and performing large-scale refactorings.
The output quality was the first thing that caught me off guard. In many cases, the Angular code it produced was remarkably close to what I would have written myself. Then I noticed how fast it worked, and although I felt a twinge of obsolescence, the whole experience has been genuinely thrilling.
What has changed most, though, is not raw code quality. The models have become dramatically easier to work with. I no longer have to spend time crafting the perfect prompt in advance and hope the result actually lines up with what I had in mind. The interaction now feels like working alongside a senior dev: you explain the problem, throw in some constraints, respond to questions, refine the requirements as they come up, and let the model guide the process toward a better understanding of what the product needs to be.
For anyone who has been using AI daily for a long stretch, none of this will feel new. But if you are just starting to explore Agentic Engineering and you want to know which LLM actually suits Angular work best, this article is aimed squarely at you.
What My November 2025 Comparison Found (No Longer Current)
It is also worth noting that SWE-bench is not quite as relevant as it used to be; later in this article I will point to newer coding-agent benchmarks from Artificial Analysis instead.
I first encountered Opus 4.5 through WebStorm, the IDE I normally use. But this post is not about IDE plugins, harnesses, or tooling. That topic deserves a separate discussion, so here I will keep the focus narrow: which LLM is the strongest candidate for building Angular applications?
Because no public benchmark covers Angular specifically, the best we can do is look at two imperfect signals: the available coding benchmarks that do exist, plus direct hands-on experience from real Angular projects. I will start with the benchmark data, then move to my own conclusions.
My Current Ranking in One Minute
If you want the short version: Opus 4.7 is my top pick for Angular, GPT 5.5 is the best general-purpose choice, Composer 2.5 is the new name to watch, and Gemini 3.5 Flash remains a work in progress. The table below gives the full picture:
Which Frontier Models Matter for Angular in May 2026?
For my own work, I want access to the most capable LLMs that are realistically usable for Angular development, and that primarily means the latest frontier models available through common APIs, IDE integrations, and developer tools.
In my view, the frontier models most worth your attention for Angular work right now, sorted from earliest to latest release, are these:
- Opus 4.7 by Anthropic, April 16, 2026
- GPT 5.5 by OpenAI, April 23, 2026
- Composer 2.5 by Cursor, May 18, 2026
- Gemini 3.5 Flash by Google, May 19, 2026
The two newest entrants went public just days before I wrote this, so my direct experience with them is still limited. That said, I would say Opus 4.7, GPT 5.5, and Composer 2.5 are currently the real candidates for the title of best LLM for Angular development. Gemini 3.5 Flash makes the list because it is fresh and intriguing, but my initial reaction is that it does not really threaten the other three yet. Once Gemini 3.5 Pro ships, I expect that to be a different story.
Industry Benchmarks and Their Limits
The announcements from Google I/O in May 2026 included several updates to their AI lineup. Among them was the introduction of Gemini 3.5 Flash, and Google accompanied this launch with performance figures:
There are a couple of reasons to take those numbers with a grain of salt:
- The results come from Google, the vendor behind Gemini 3.5 Flash, so there is an inherent bias that makes it hard to treat them as impartial.
- Details are scarce: what tasks were run, how the evals were structured, and what relevance they carry for building Angular apps remain unclear.
For a more solid reference point, I turn to Artificial Analysis. Their evaluations are not tied to Angular either, but they do offer a more neutral ground for comparing model capability, speed, and token economy.
Artificial Analysis Data
I want to highlight a few specific views from Artificial Analysis: the overall "Coding Agent Index," which ranks agents on composite performance; "Execution Time," which measures how long agents actually run; and "Token Usage," which tracks the volume of input and output tokens consumed. The snapshots I reference here were pulled on May 26, 2026, so the live leaderboard should be your source for current numbers.
These metrics apply to coding agents as a whole, not to LLMs in isolation. Where a model runs matters a great deal — the same underlying model can produce very different outcomes depending on whether it powers Claude Code, Cursor, Codex, OpenCode, or a bespoke agent pipeline. Because of that, I address harnesses and integrations in their own dedicated posts, one focused on application and harness choices and another on practical configuration. In this space, I treat the numbers merely as a proxy for relative model strength.
That index is computed from a blend of SWE-Bench-Pro-Hard-AA, Terminal-Bench v2, and SWE-Atlas-QnA results. A more thorough explanation is available in their benchmark methodology write-up.
The composite is handy for a fast overview, but it is not the whole story. Models that land close together on the index can still diverge significantly when you dig into specific evaluator breakdowns for repo-level changes, terminal handling, or rubric-based scoring.
Wall-clock time per task, averaged across all runs. Values close to zero are preferable.
Average number of tokens read, cached, and written per completed task.
The DeepSWE Leaderboard
Update May 31st (including Opus 4.8): There is a newer assessment that maps to my hands-on experience far more directly: DeepSWE. Checking their standings as of May 31, 2026, GPT 5.5 sits at the top with 70%, trailing it are Opus 4.8 at 58%, GPT 5.4 at 56%, and Opus 4.7 at 54%. Opus 4.6 and Gemini 3.5 Flash both land at 28%. Since that date, DeepSWE has released v1.1 with revised scores, so the percentages I quote represent the May snapshot; the current leaderboard holds the freshest data. Looking at that picture matches my instinct: GPT 5.5 and Opus 4.8 are both dependable picks for heavy development tasks, whereas Gemini 3.5 Flash has yet to show it belongs in that league for Angular work.
My attraction to this specific benchmark lies in its format. The assignments are closer to what agentic workflows ask for in practice: hand the agent a concise behavioral spec, and see whether it can pinpoint the pertinent code sections and make the addition without staging every detail in advance. These are scenarios where classic SWE-Bench outcomes often feel disconnected from everyday reality.
The thing that stands out most, though, is not the order of the ranks but the distances between them. If a test compresses the difference between a small model and the top-tier ones, it does not give me much signal to work with. DeepSWE takes the opposite route; the separation between the best and the rest is pronounced, lining up with what I observe when models operate on complex repos. The frontier pair maintains its lead while the contenders drift back toward expected positions.
It should be noted that Composer 2.5 has no entry in this comparison; likely because it is offered predominantly via Cursor rather than as a publicly consumable standalone model endpoint.
Reading the Signals
Across these tables, Gemini 3.1 Pro fails to impress. That is still the flagship Pro tier today, as a successor under the Gemini 3.5 label has yet to appear. Gemini 3.5 Flash raises the bar a little, though current data is both sparse and unrelated to the frontend framework in question.
What I have experienced in my own Angular projects runs parallel but not perfectly: the speed of Gemini 3.5 Flash varies case by case, and on the whole, it does not yet enter the conversation with my go-to trio. A future Gemini 3.5 Pro may well change that dynamic, but the available evidence remains too thin to call.
From the numbers in this round, GPT 5.5 is the overall leader and the more effective spender of tokens. I want to acknowledge the paradox plainly: the evaluations I lean on push toward GPT 5.5, while the conclusion I draw for Angular still puts Opus in front. The mismatch between scoreboard and actual usage is precisely why I consider these data points part of a larger evaluation rather than the final verdict.
I am deliberately leaving cost out of this discussion. That topic warrants its own standalone write-up when we get to pricing considerations, especially since expenses shift so much with the access method. The core question occupies the rest of this piece: what model serves Angular developers best when balancing quality, velocity, and utility?
None of what follows is a formal study. My informed take derives from consistent hands-on use across migrations, restructuring, code examination, test authoring, and legacy system quirks. The specifics behind those choices surface in the examples I cover during the Agentic Engineering Workshop: a session built around the scenarios that demonstrated to me why these models emerged as my preferred options for professional Angular work.
Up to the verdict, I want to jump ahead to the four side questions that keep rising in model comparisons: the offering from China, the options from Europe, the feasibility of running locally, and the open-source status of the main players.
Should Chinese models be on your radar?
By May 2026, the Chinese contenders — DeepSeek V4, Qwen 3.6, and Kimi K2.6 — deserve attention for their aggressive focus on code, open availability of weights, and attractive pricing. However, for production-grade Angular projects, they have yet to prove themselves on the level of Opus 4.7, GPT 5.5, or Composer 2.5 in my experience. I keep an eye on their progress, but I wouldn’t build my enterprise stack around any of them at this point.
What about European entries?
Up to now, Europe’s most notable contribution in this sphere, as of May 2026, comes from Mistral, with Mistral Large 3 the current version to follow. It is improving steadily and certainly merits attention in contexts that stress data sovereignty, EU-based suppliers, or open-weight distribution. With regard to pure coding arithmetic in Angular tasks, the European offerings trail the frontier labs for the moment, earning the label of tactical selections rather than front-runners for best model.
Are local models practical?
The landscape for locally hosted models has evolved well beyond the novelty stage as of my May 2026 assessment, though we need to break down what "local" entails. A model running on a consumer laptop is not the same animal as a large, open-weight MoE (Mixture of Experts) system self-hosted on a substantial GPU cluster.
When looking at this category for coding assistance, Qwen 3.6 stands out, particularly as its development targets agentic use cases, whole-repository reasoning, and easy local operation via common frameworks like Transformers, llama.cpp, MLX, vLLM, and SGLang. DeepSeek V4 remains a valid entry in the open-weight arena, yet the bigger checkpoints fit naturally on backend hardware rather than a developer’s machine. From the EU region, Mistral 3 also warrants a look since both the Large 3 and smaller Ministral iterations expose their weights, especially as the compact variants target local and on-device execution.
For the kind of Angular work I take on professionally, these models remain a division below my current preferences. The shortfall goes beyond raw intelligence into areas like consistent tool invocation, steady performance over long agent batches, expansive context retention, and smooth integration with my dev loop. Even so, they are becoming a practical alternative for cases where privacy or regulation limits external connectivity, for certain CI tasks, and in organizations with strict code-control policies. They are no longer invisible to me, but a full endorsement for enterprise Angular is still a step or two away.
Is anyone truly open source?
That term needs precision, as it is frequently conflated with open weights. Claude, GPT, Gemini, and Composer 2.5 do not meet a reasonable threshold for open source in the conventional sense, even if Composer’s roots trace to Moonshot’s openly available Kimi baseline. Families such as DeepSeek, Qwen, Kimi, and selected Mistral models sit much nearer to that ideal, offering their weights under permissive or semi-restrictive licensing. Yet even those releases omit core components like training datasets, complete source for the training pipeline, and the full recipe, so identifying them as open-weight models remains the more accurate description.
My Personal Take
Now that we've covered the technical ground, I'd like to share how these LLMs have performed for me personally. The question I care about isn't just which model tops a leaderboard, but which one fits into a real Angular development workflow. This section is inherently subjective — your experience may vary, and if you see things differently, I'd welcome your thoughts in the comments over on X or Reddit.
Opus 4.7 by Anthropic: My Top Pick for Angular
For my money, Opus 4.7 takes the crown. It delivers the highest code quality, performs strongly across the board, and remains quick enough for serious agentic use cases.
What’s changed for me is that Opus 4.7 no longer behaves like a junior assistant that needs hand-holding with every step. Instead, it acts like a seasoned collaborator that thrives when I provide it with context, boundaries, and thoughtful questions.
In my view, it’s currently the strongest option for large-scale enterprise Angular codebases. It also carries the highest price tag, particularly with Extra and Max Mode, but I believe the outcomes justify the expense.
Agentic work with Opus 4.7 is a pleasure, especially when I want it to weigh options, push back on assumptions, then arrive at a concrete action plan. I'll demonstrate this practical usage in the upcoming post on tools and harnesses.
GPT 5.5 by OpenAI: The Best All-Around Choice
GPT 5.5 is a serious contender for Angular work, and OpenAI's own launch post lines up with what I've observed: it excels at focused implementation. It produces top-notch code and is impressively economical with tokens, provided you don’t crank up reasoning levels unnecessarily. What it lacks is the versatility of Opus 4.7, and it seems more dependent on context: if its initial assumptions are off, I've found it more effective to start a fresh prompt with crisper constraints rather than trying to correct course.
That token discipline matters because GPT 5.5 commands a high per-token price, yet it frequently needs significantly fewer tokens to get the job done compared to its peers. In daily use, I'd keep reasoning on low or medium by default and dial it up only when the situation demands it.
For general conversational assistance, I'm quite fond of this model. It's my go-to for thinking through problems with a series of targeted questions, after which I spin up a clean new thread for implementation. To give you an idea, if I needed help polishing the prose of this very article, GPT 5.5 would be my choice. It's also currently my preferred tool for modernizing and refactoring Angular applications. And have you ever tried to resolve a nasty merge conflict? It’s a lifesaver. It's almost too fast to trust, honestly. I'd characterize it as a solid senior dev, while Opus 4.7 is more like a distinguished architect. Of course, that's a subjective take.
Composer 2.5 by Cursor: The Intriguing Newcomer
Composer 2.5 offers a compelling mix of solid code generation and exceptional speed for Angular development. The buzz around it suggests that Cursor took Moonshot's Kimi K2.5 open-weight checkpoint and post-trained it, achieving results on Cursor's own benchmark that come surprisingly close to GPT 5.5 and Opus 4.7 for a fraction of the cost. A major caveat remains: independent verification is difficult since Composer isn't offered through a standard model API but is mostly confined to Cursor's own environment.
If budget is a primary concern and you lack the generous included usage that comes with plans like Claude Code or Codex, Composer 2.5 could be your ideal choice, but only if Cursor aligns with your preferred way of working. I'll touch on tools and harnesses in the next installment, and dive deeper into cost and access structures in a dedicated follow-up.
One to Watch: Gemini 3.5 Flash Today, 3.5 Pro Tomorrow
Gemini 3.5 Flash is noteworthy, but my early experiences are inconsistent: its speed fluctuates, and for Angular work, it doesn’t yet pose a serious threat to Opus 4.7, GPT 5.5, or Composer 2.5. I need substantially more time with it, along with trustworthy third-party benchmarks, before I'd feel comfortable endorsing it. Gemini 3.5 Pro, however, could emerge as the more formidable option, especially if it manages to pair stronger coding ability with reliable performance.
Hang on, isn't there a new model out?
The day after I published this (May 28, 2026), Anthropic went ahead and released Claude Opus 4.8. So, was this post already obsolete within 48 hours?
I don't think that's the case.
There's bound to be some progress between Opus 4.7 and 4.8, and Anthropic's published metrics look good. It’s likely that the new model, and whatever follows it, will outpace rivals like GPT 5.5 on certain tests. But that doesn't invalidate the core argument here: benchmarks are helpful indicators, not the verdict.
When it comes to real-world Angular development, the ideal model is the one that meshes with your own workflow. Give the new releases a try, but evaluate them in your own projects, with your specific tasks, your chosen tools, and your own quality bar.
Deep Dive: Agentic Engineering Workshop
This is exactly why I've stopped considering LLMs in a vacuum: the model is only one piece of a system that includes your application, my Angular Guardrails, the Angular Coding Style Guide, the Angular Skills, and the review process – they all function together.
If you're ready to pick the best model for your Angular projects and put it into practice on real modernization, refactoring, testing, and review tasks, consider joining our Agentic Engineering Workshop. It's offered in both English and German.
This workshop guides advanced Angular developers from "vibe coding" toward structured, traceable Agentic Engineering practices: setting up AI-ready projects, establishing guardrails, working spec-first and plan-first, prototyping UX and components, conducting code reviews, performing testing, and managing brownfield refactoring.
- 🤖 Agentic Engineering Workshop – 2 days, remote
Wrapping Up
The genuine transformation isn't that these models write code. It's that they can now engage with the entire engineering process: posing questions, defining requirements, examining alternatives, and bridging the chasm between a fuzzy idea and tested Angular code.
If you're looking for practical advice for serious Angular work, here it is: lean on Opus 4.7 when you need peak quality, robust architecture, and complex agentic interaction. Choose GPT 5.5 when you value a well-rounded, efficient companion that excels at writing tasks, modernizations, and direct implementation work.
Keep Composer 2.5 on your radar, particularly if you're already embedded in the Cursor ecosystem and prioritize speed and affordability. For Gemini 3.5 Flash, treat it as experimental for the time being, and reassess your options once Gemini 3.5 Pro is released.
As the Opus 4.8 situation shows, this field evolves at a breakneck pace, and no static ranking remains accurate for long. So, regardless of your choice, think beyond the benchmark scores: the ultimate metric is whether the model assists you in delivering superior Angular code within your own environment.
In the next article, I'll examine the other essential component: the apps, IDE plugins, and agentic coding harnesses that unlock these models' potential in your daily Angular life. Following that, I'll break down AI coding costs, discuss how these tools handle your data, and share my final personal take on agentic coding.
Thanks for reading 🙏 this post was authored by Alexander Thalhammer. For any feedback, thoughts, or questions, please don't hesitate to contact me ❤️