DEV Community: Joske Vermeulen

claude-opus-4-vs-gpt-5

Joske Vermeulen — Sun, 05 Apr 2026 09:45:05 +0000

Both Claude Opus 4 and GPT-5 are top-tier AI models, but they excel in different areas. Here's how they compare.

At a glance

	Claude Opus 4	GPT-5
Provider	Anthropic	OpenAI
Context window	200K tokens	128K tokens
Input price	$15 / 1M tokens	$10 / 1M tokens
Output price	$75 / 1M tokens	$30 / 1M tokens
Coding (SWE-bench)	~76.8%	~71.8%
Multimodal	Text + images	Text + images + audio
Subscription	$20/mo (Claude Pro)	$20/mo (ChatGPT Plus)

Coding

Claude Opus 4 has the edge here. It scores higher on SWE-bench and tends to produce cleaner, more complete code on the first try. Developers working on complex multi-file refactors or architecture decisions generally prefer Opus.

GPT-5 is no slouch — it's significantly better than GPT-4o and handles most coding tasks well. But for advanced coding work, Opus is the current leader.

Winner: Claude Opus 4 🏆

Reasoning

GPT-5 excels at multi-step reasoning and math. It scored perfectly on AIME benchmarks and handles complex logical chains well. Opus 4 is strong too, but GPT-5 has a slight edge on pure reasoning tasks.

Winner: GPT-5 🏆

Context & long documents

Opus 4 supports 200K tokens vs GPT-5's 128K. If you're working with large codebases, long documents, or need to process a lot of context at once, Opus gives you more room.

Winner: Claude Opus 4 🏆

Price

GPT-5 is cheaper on both input and output. If you're making heavy API use, the cost difference adds up — especially on output tokens where Opus is 2.5x more expensive.

Winner: GPT-5 🏆

Which should you pick?

Use case	Pick
Complex coding projects	Claude Opus 4
Math & reasoning tasks	GPT-5
Large codebase analysis	Claude Opus 4 (bigger context)
Budget-conscious API use	GPT-5
General assistant	Either — both excellent
Multimodal (audio)	GPT-5

Bottom line

For coding and long-context work, Claude Opus 4 is the better choice. For reasoning, math, and cost efficiency, GPT-5 wins. Both are excellent — you can't go wrong with either at the $20/mo subscription tier.

The real answer: try both. Both offer free tiers or trials.

See our full AI Model Comparison for all models side by side.

Originally published at https://www.aimadetools.com

I Used Cursor AI for a Week — Here's What Actually Happened

Joske Vermeulen — Fri, 03 Apr 2026 09:56:44 +0000

I've been hearing about Cursor for months. Every dev subreddit, every Twitter thread, every "10x your productivity" post — Cursor was always in the conversation. So I decided to actually use it as my only editor for a full week and see what the hype is about.

Here's the unfiltered version.

Day 1: The Switch

Switching from VS Code to Cursor took about five minutes. It's literally a fork of VS Code, so all my extensions, keybindings, and themes carried over. My muscle memory worked from the first second. That alone puts it ahead of every other "AI editor" I've tried — there's no learning curve for the basics.

I opened a project, and the first thing Cursor did was index my entire codebase. For my medium-sized project (~2,000 files), this took maybe 30 seconds. I've heard horror stories about large monorepos taking hours, but for a typical project, it was fast.

What Blew Me Away

Tab completion that reads your mind

This is the feature that sold me within the first hour. Cursor's Tab doesn't just autocomplete the current line — it predicts your next edit. You accept a suggestion, press Tab again, and it jumps to the next logical place you'd want to change something.

It's hard to explain until you experience it. You start writing a function, Tab completes it, then Tab jumps you to where you need to add the import, then Tab takes you to the test file. It feels like pair programming with someone who's already read your code.

Their custom Tab model was trained with reinforcement learning to show 21% fewer suggestions but with a 28% higher accept rate. In practice, that means less noise and more "yes, that's exactly what I wanted."

Agent mode is the real deal

Cmd+I opens the agent, and this is where Cursor separates itself from Copilot. You can say "refactor this component to use React hooks instead of class components" and it will:

Read the relevant files
Plan the changes
Edit multiple files
Run your linter to check for errors
Fix any issues it finds

It doesn't just suggest code — it executes. With version 2.4's subagents, it can even spin up parallel tasks. Need to update the component AND its tests AND the documentation? It handles all three simultaneously.

Codebase awareness

The @ symbol is incredibly powerful. Type @filename to reference a specific file, @codebase to search semantically across your project, or @docs to pull in documentation. This context management is what makes Cursor's suggestions actually relevant instead of generic.

I found myself using @codebase constantly — "find everywhere we handle authentication" or "show me how we format dates across the project." It's like having a senior dev who's memorized every line of your code.

.cursorrules changed everything

On day 2, I created a .cursorrules file in my project root. This is basically a system prompt that tells Cursor how you want it to behave. I added things like:

"Use TypeScript strict mode, never use any"
"Prefer functional components with hooks"
"Always add error handling"
"Follow the existing naming conventions in this project"

The difference was night and day. Before the rules file, suggestions were generic. After, they matched my project's style perfectly. This is the single biggest tip I can give any new Cursor user: write your rules file on day one.

What Frustrated Me

Performance on larger projects

By day 3, I opened a bigger project at work — around 8,000 files. Cursor started struggling. The indexing took several minutes, and I noticed lag when typing. GPU usage spiked to 90% during code application. Some developers report memory consumption hitting 7GB+ with hourly crashes on large codebases.

I had to tune things: added folders to .cursorignore, disabled some extensions, and increased Node.js memory limits. After that it was usable, but it shouldn't require manual tuning to handle a normal enterprise project.

The constant updates

Cursor pushes updates almost daily, and each one requires a restart. If you're running dev servers in the integrated terminal — which I always am — that means restarting your servers too. It's a small thing, but by day 5 it was genuinely annoying.

Some updates also moved UI elements around or changed how features worked. The Cursor forum has threads from frustrated users saying the interface changes too frequently. I get that they're iterating fast, but stability matters when this is your daily tool.

AI quality is inconsistent

When Cursor is good, it's incredible. But it has bad days. Sometimes the agent would confidently make changes that broke things in subtle ways — passing tests but introducing logic errors. One afternoon, the suggestions felt noticeably worse than the morning, which makes me think it depends on which model is handling your request and how loaded the servers are.

The Cursor forum has posts from power users calling the Composer feature "an absolute garbage producing slop machine" during bad periods. That's harsh, but I understand the frustration when you're paying $20/month and the quality fluctuates.

It can make you lazy

This is the sneaky one. By day 4, I caught myself accepting suggestions without fully reading them. The Tab completion is so good that you start trusting it blindly. I had to consciously slow down and review what it was generating, especially for business logic.

One user on Reddit put it perfectly: "It helps a lot if you change how you work. It feels useless if you treat it like a fancy autocomplete." You need to think of it as a junior developer who's very fast but needs code review.

The Pricing Reality

Free: 2,000 completions (enough to try it, not enough to use it)
Pro: $20/month — unlimited completions, 500 fast requests
Pro+: $60/month — more agent usage
Ultra: $200/month — heavy agent users
Business: $40/user/month — team features, admin controls

For most solo developers, Pro at $20/month is the sweet spot. You'll only feel limited during intense multi-file refactoring sessions. But be aware — heavy agent usage can burn through your allowance fast.

Cursor vs GitHub Copilot

I used Copilot for over a year before this, so here's the honest comparison:

	Cursor	GitHub Copilot
Inline completions	Excellent (+ next-edit prediction)	Excellent
Multi-file editing	✅ Native, powerful	⚠️ Limited
Codebase understanding	Deep (indexes everything)	Surface-level
Agent mode	Full autonomous agent	Basic
IDE support	Cursor only (VS Code fork)	VS Code, JetBrains, Neovim, etc.
Price	$20/month	$10-19/month
Model choice	GPT-5, Claude, Gemini	Primarily OpenAI

Copilot wins if you need IDE flexibility, want the cheapest option, or work in JetBrains. Cursor wins if you do complex multi-file work and don't mind being locked to one editor.

My Verdict After 7 Days

Cursor made me mass faster at the boring parts of coding — boilerplate, refactoring, test writing, documentation. I'd estimate it saved me 1-2 hours per day on a typical workday. For $20/month, that's absurd ROI.

But it didn't make me a better programmer. The hard parts — architecture decisions, debugging subtle logic errors, understanding business requirements — are still 100% on me. Cursor is a productivity multiplier, not a replacement for knowing what you're doing.

Would I keep paying? Yes. Going back to vanilla VS Code after a week of Cursor feels like coding with one hand tied behind your back. That's not marketing — that's what it actually feels like.

Who should try it:

Any developer writing code daily (the free tier is enough to decide)
Teams doing lots of refactoring or working across large codebases
Solo developers who want to ship faster

Who should skip it:

Developers who primarily work in JetBrains IDEs
Teams with strict security policies that don't allow code to be sent to external APIs
People who expect AI to write entire applications without guidance

Tips If You're Starting

Write a .cursorrules file immediately — this is the single biggest quality improvement
Learn the @ references — @file, @codebase, @docs make the AI actually useful
Don't accept suggestions blindly — review everything, especially business logic
Use agent mode for refactoring, Tab for writing — each has its sweet spot
Add large folders to .cursorignore — node_modules, build artifacts, vendor deps
Treat it like a junior dev — fast and eager, but needs supervision

Related: Claude Code vs Cursor — Which One Wins in 2026?

Originally published at https://www.aimadetools.com

AI Dev Weekly #4: Anthropic Leaks Everything, OpenAI Raises $122B, and Qwen 3.6 Drops Free

Joske Vermeulen — Thu, 02 Apr 2026 07:01:53 +0000

AI Dev Weekly is a Thursday series where I cover the week's most important AI developer news — with my take as someone who actually uses these tools daily.

Anthropic had a rough week. Two separate leaks, a $122 billion competitor, and a Chinese model that just went free. Let's get into it.

Anthropic leaks Claude Code's entire source code to npm

On Monday, security researcher Chaofan Shou discovered that Claude Code's npm package contained a 60MB source map file that mapped the minified production code back to its original TypeScript source. All 512,000 lines of it. Across 1,906 internal files.

This wasn't a hack. The Bun runtime that Claude Code uses generates source maps by default, and someone forgot to strip them before publishing version 2.1.88 to the public npm registry. By the time Anthropic pulled the package, developers had already mirrored the code to GitHub and started picking it apart.

What they found: internal APIs, telemetry systems, encryption logic, unreleased agent features, and system prompts. The code revealed how Claude Code handles tool execution, permission management, and the auto mode safety classifier that shipped just last week.

This is the second time Anthropic has leaked source code in under a year. The first was the Cowork data exfiltration vulnerability in January.

My take: The irony is thick. The company that positions itself as the safety-first AI lab keeps shipping code with basic packaging errors. A .npmignore file or a build step that strips source maps would have prevented this entirely. The leaked code itself is well-written TypeScript — there's nothing embarrassing about the engineering. The embarrassment is that it happened at all, and that it happened twice.

For developers using Claude Code: nothing changes practically. No customer data was exposed, and the tool still works the same way. But if you're evaluating AI coding tools for enterprise use, "accidentally published our entire codebase to npm" is a hard thing to explain to your security team.

Also leaked: Claude "Mythos" — Anthropic's unreleased tier above Opus

The source code leak came days after a separate incident. On March 26, security researchers found nearly 3,000 unpublished files — including draft blog posts and internal memos — publicly accessible due to a misconfigured content management system.

The files revealed a model internally called "Claude Mythos" (also codenamed "Capybara"). According to the leaked draft blog post, Mythos is "larger and more intelligent than our Opus models — which were, until now, our most powerful." It's currently in early access testing with cybersecurity partners.

Anthropic confirmed Mythos is real and called it a "step change" in capability. No public release date has been set.

My take: Two leaks in one week from the safety-focused AI company. The Mythos leak is actually more significant than the source code one — it confirms Anthropic has a model tier beyond Opus that they haven't announced. For developers planning around Claude's model lineup (Haiku → Sonnet → Opus), knowing there's a "Mythos" tier coming changes the calculus. Especially if you're budgeting API costs — a model above Opus won't be cheap.

OpenAI closes $122 billion round at $852 billion valuation

OpenAI announced on Monday that it closed the largest private funding round in history: $122 billion in committed capital, pushing its post-money valuation to $852 billion. The round was led by Amazon, NVIDIA, and SoftBank, with Microsoft continuing its participation.

The company now has 900 million weekly active users and 50 million paid subscribers. Revenue has crossed $2 billion per month. In the same announcement, OpenAI confirmed it shut down Sora, its video generation tool, citing unsustainable inference costs — reportedly $15 million per day against $2.1 million in lifetime revenue.

OpenAI described its strategy as building an "AI Super App" that combines ChatGPT, Codex, and other products into a unified platform.

My take: The Sora shutdown is the real story here. OpenAI killed a product that was burning $15M/day because it couldn't monetize it. That's a company making hard commercial decisions, not a research lab chasing cool demos. The "AI Super App" framing signals that OpenAI sees its future as a platform, not a model provider.

For developers: Codex keeps getting better. GPT-5.4 became the new core model in March, GPT-5.4 Mini changed cheaper task routing, and the CLI got parallel agents, worktrees, and skills. If you're on ChatGPT Plus, Codex is included and it's genuinely competitive with Claude Code now. I've been running both headless on a VPS and the output quality is closer than you'd expect.

Qwen 3.6 Plus drops for free on OpenRouter

Alibaba released Qwen 3.6 Plus Preview on March 30, and it's available for free on OpenRouter. Zero cost for input and output tokens. The model features a 1 million token context window and what Alibaba calls "improved efficiency, stronger reasoning, and more reliable agentic behavior" compared to the 3.5 series.

This comes alongside Qwen 3.5 Omni, a multimodal model that processes text, images, audio, and video natively. Researchers noted it learned to write code from spoken instructions and video input without being explicitly trained to do so.

My take: The Chinese open-source models keep getting more aggressive on pricing. Qwen 3.6 Plus for free is a direct challenge to every paid API. I've been testing the Qwen 3.5 series this week for a project, and the Flash model at $0.065/$0.26 per million tokens is absurdly cheap — we ran 20 minutes of agentic coding for $0.018. The Plus model at $0.26/$1.56 is still cheaper than Claude Sonnet by a wide margin.

The 1M context window on the free model is the real hook. If you're building RAG pipelines or processing large codebases, there's no reason not to try it. The quality won't match Claude or GPT on complex reasoning, but for many tasks it's good enough — and free is hard to argue with.

Quick hits

Gemini 3.1 Pro is rolling out in Gemini CLI. Google's latest model ties GPT-5.4 on the Artificial Analysis Intelligence Index at roughly one-third the API cost. It features dynamic thinking with a new thinking_level parameter (low/medium/high/max) and a 1M token context window. GitHub Copilot also added Gemini 3.1 Pro support across major IDEs.

Google launched Gemini API Docs MCP and Agent Skills — two tools that give AI coding agents real-time access to current API documentation, fixing the "generates outdated code" problem caused by training data cutoffs.

GitHub Copilot added Gemini 3.1 Pro across VS Code, JetBrains, and Xcode. You can now choose between GPT, Claude, and Gemini models within Copilot.

Originally published at https://www.aimadetools.com

Vite vs Webpack — Which Build Tool Should You Use?

Joske Vermeulen — Tue, 31 Mar 2026 10:09:15 +0000

Quick Comparison

	Vite	Webpack
Dev server	Instant (native ESM)	Slower (bundling)
HMR	Near-instant	Slower
Config	Minimal	Verbose
Production build	Rollup	Webpack
Plugin ecosystem	Growing	Massive
Learning curve	Low	High

When to Use Vite

New projects (it's the default for React, Vue, Svelte)
You want fast dev server startup
You don't need complex Webpack-specific plugins
You value simplicity

When to Use Webpack

Legacy projects already using Webpack
You need Module Federation (micro-frontends)
You need a specific Webpack plugin with no Vite equivalent
Complex custom build pipelines

Key Differences

Dev Server: Vite serves files over native ESM — no bundling during development. This means instant server start regardless of app size. Webpack bundles everything before serving, which gets slower as your app grows.

Configuration: A Vite config is typically 10-20 lines. A Webpack config can be hundreds of lines with loaders, plugins, and optimization settings.

Production: Vite uses Rollup for production builds, which produces smaller bundles. Webpack uses its own bundler.

Verdict

Use Vite for new projects. Migrate from Webpack to Vite when you can. There's very little reason to start a new project with Webpack in 2026.

Related: What Is Vite? A Simple Explanation

Originally published at https://www.aimadetools.com

Stop Using Redux in 2026. Seriously.

Joske Vermeulen — Sun, 29 Mar 2026 09:43:35 +0000

I spent two years putting everything in Redux. Global loading states, form inputs, toast notifications — all in the store. Then I ripped it all out in a weekend and my codebase got 40% smaller. Here's why you should too.

Redux was the right answer in 2018. It's the wrong answer in 2026 for 90% of projects. Let me explain.

The problem isn't Redux itself

Redux is well-built, well-documented, and battle-tested. The problem is that developers reach for it by default, like it's a required dependency for React apps. It's not.

What Redux actually costs you

Boilerplate tax. Even with Redux Toolkit (which is genuinely good), you're still writing slices, selectors, thunks, and connecting everything. For a todo app? That's absurd. For a dashboard with 5 API calls? Still overkill.

Bundle size. Redux + Redux Toolkit + React-Redux = ~40KB minified. Zustand is 1.1KB. That's not a typo.

Mental overhead. New developers on your team need to understand actions, reducers, dispatch, selectors, middleware, thunks, and the store. With Zustand, they need to understand... a hook.

// Redux way
const dispatch = useDispatch();
const count = useSelector((state: RootState) => state.counter.value);
dispatch(increment());

// Zustand way
const { count, increment } = useCounterStore();

Same result. One requires 4 files and 3 concepts. The other requires 1 file and 0 new concepts.

"But Redux DevTools!"

Zustand has devtools middleware. So does Jotai. This isn't a differentiator anymore.

"But Redux handles complex state!"

Define complex. If you have deeply nested state with dozens of interdependent slices, sure, Redux's structure helps. But how many apps actually have that? Most apps have:

User auth state
A few API caches
Some UI state (modals, sidebars)

For API caching, you should be using TanStack Query or SWR anyway — not putting API responses in Redux. That alone eliminates 60% of what most Redux stores contain.

When Redux is still the right choice

You have 50+ developers and need enforced patterns
Your state is genuinely complex with many interdependent slices
You're already using it and it's working fine (don't rewrite for fun)
You need time-travel debugging for complex state transitions

What to use instead

Zustand — For most apps. Simple, tiny, just works. No providers, no boilerplate.

Jotai — For atomic state. Great when you have lots of independent pieces of state.

TanStack Query — For server state. If half your Redux store is API responses, replace that half with TanStack Query and you might not need Redux at all.

React Context — For truly simple shared state (theme, locale, auth). Don't use it for frequently updating state though — it re-renders everything.

The real question

Before adding Redux to your next project, ask: "What specific problem does Redux solve here that Zustand doesn't?"

If you can't answer that clearly, you don't need Redux. You need a smaller tool for a smaller problem.

Related resources

- React complete guide

Originally published at https://www.aimadetools.com

AI Dev Weekly #3: Claude Code Goes Auto, Cursor's Chinese Secret, and GitHub Wants Your Data

Joske Vermeulen — Thu, 26 Mar 2026 10:14:12 +0000

AI Dev Weekly is a Thursday series where I cover the week's most important AI developer news — with my take as someone who actually uses these tools daily.

Three stories this week, and they all share a theme: the companies building your coding tools are making big decisions about trust — and not all of them are being upfront about it.

Claude Code gets auto mode, Channels, and $2.5B in revenue

Anthropic dropped three features on Monday. The headline is auto mode — a middle ground between the default "approve every file write" and the dangerously-skip-permissions flag that lets Claude do whatever it wants.

Auto mode uses an AI safety classifier that evaluates every tool call in real time. Routine actions like writing files and running tests get auto-approved. Destructive operations — mass file deletion, data exfiltration, malicious code execution — get blocked. If Claude keeps trying blocked actions, it escalates to a human prompt. It also screens for prompt injection attacks, which is relevant given that Cowork had a data exfiltration vulnerability two days after launch in January.

The second feature is Claude Code Channels — you can now control Claude Code through Discord and Telegram. This is Anthropic's direct response to OpenClaw, the open-source project that hit 100K+ GitHub stars by letting people run AI agents through chat apps. Anthropic sent OpenClaw's creator a cease-and-desist over the original name "Clawd," and he ended up joining OpenAI. Now Anthropic is building the managed alternative. Channels currently only supports Discord and Telegram, while OpenClaw covers five platforms including iMessage, Slack, and WhatsApp.

The third feature: computer use for Cowork, giving Claude direct keyboard-and-mouse control of macOS desktops. It prioritizes API connectors when available and falls back to screen interaction when they're not.

The revenue number is the quiet bombshell: Claude Code hit $2.5 billion in annualized revenue, up from $1 billion in early January. That's 2.5x growth in under three months.

My take: Auto mode is what Claude Code should have shipped with. The binary choice between "interrupt me for everything" and "YOLO mode" was the biggest friction point for long-running tasks. The AI classifier approach is smart — but it's also a black box. Anthropic hasn't published what the classifier allows or blocks, which means you're trusting an undisclosed ML model to decide what's safe to run on your machine. For side projects, fine. For production codebases, I'd want to see the rules. For a deeper look at how Claude Code compares to the competition, see my Claude Code vs Cursor comparison.

Channels is interesting strategically. OpenClaw proved developers want chat-based agent control. Anthropic's response is "we'll build it ourselves, with better security." Whether developers choose the managed option over the open-source one will depend on how fast Anthropic adds platform support.

Cursor launches Composer 2 — then gets caught hiding its origins

Cursor shipped Composer 2 this week with impressive benchmarks on SWE-bench Multilingual and Terminal-Bench. The pitch: frontier-level coding intelligence with 200K token context, optimized for multi-file editing and long multi-step tasks.

What Cursor didn't mention in the announcement: Composer 2 is built on Moonshot AI's Kimi K2.5, a Chinese open-source model.

A developer named Fynn intercepted Cursor's API traffic and found the model identifier kimi-k2p5-rl-0317-s515-fast. The internet did the rest. Elon Musk commented. Then Cursor co-founder Aman Sanger confirmed it — Kimi K2.5 was selected after an evaluation, followed by additional pre-training and heavy reinforcement learning. He called the omission from the blog post "an error."

Kimi K2.5 is a 1 trillion parameter Mixture-of-Experts model with 32 billion active parameters per token, released under a modified MIT license by Moonshot AI (backed by Alibaba and HongShan). The commercial use was authorized through Fireworks AI.

My take: The technical choice is defensible. Fine-tuning an open-source model and adding your own RL on top is exactly how you build a competitive coding model without training from scratch. DeepSeek proved that open-source base models can compete with closed ones. Cursor picking the best available foundation is smart engineering.

The transparency failure is the problem. When you're a $29 billion company and developers trust you with their codebases, you don't "forget" to mention the base model. Especially when it's from a Chinese company — not because that's inherently bad, but because developers deserve to make informed decisions about their toolchain. If you're weighing your options, my GitHub Copilot vs Cursor comparison covers the broader tradeoffs.

GitHub will train on your Copilot data by default

GitHub announced that starting April 24, 2026, interactions with Copilot Free, Pro, and Pro+ will be used to train AI models. This is opt-out, not opt-in. If you do nothing, your prompts and code interactions become training data.

To opt out: go to GitHub Settings → Copilot → Features → disable "Allow GitHub to use my data for AI model training" under Privacy. Enterprise and Business plan users are not affected — their data was already excluded.

My take: This was inevitable. GitHub has been watching Claude Code and Cursor grow by training on real developer interactions while Copilot relied mainly on public code. The quality gap showed. Moving to opt-out instead of opt-in is the aggressive play — most developers won't change the default, which means GitHub gets a massive training dataset overnight.

If you're on Copilot Free or Pro, go change that setting now if you care. If you don't care, at least know it's happening. And if this is the push you needed to evaluate alternatives, my how to replace GitHub Copilot guide covers the options.

Quick hits

VS Code 1.113 shipped — Two features worth knowing about. First, a Thinking Effort selector that lets you dial AI reasoning intensity up or down per request — useful when you want a quick answer without burning tokens on deep reasoning. Second, nested subagents: subagents can now call other subagents, enabling multi-step AI workflows that chain together. Both features work with shared MCP server access.

Apple confirmed WWDC 2026 for June 8-12 — The big tease: Core AI, a new framework replacing Core ML, designed for running large language models and diffusion models directly on-device. Combined with the Claude Agent SDK for Xcode announced two weeks ago, iOS developers are about to get a lot more AI tooling. Also expect a major Siri revamp with iOS 27.

OpenClaw v2026.3.24 released — New version adds improved OpenAI API compatibility, sub-agents with OpenWebUI, and native Slack and Teams integration. The open-source agent framework keeps shipping faster than the commercial alternatives can copy it.

The pattern this week

Trust is the new battleground. Anthropic is asking you to trust a black-box classifier with your file system. Cursor asked you to trust a model without telling you where it came from. GitHub is asking you to trust that opt-out is good enough.

The developers who'll navigate this well aren't the ones who blindly trust or blindly reject. They're the ones who read the settings pages, check the API traffic, and make informed choices. This week proved that even the tools you pay for aren't always transparent about what's happening under the hood.

AI Dev Weekly drops every Thursday.

Related: AI Dev Weekly #2: Garry Tan's 'God Mode', Cursor Composer 1.5, and Anthropic Finds Firefox Bugs | AI Dev Weekly #1: Claude Code Takes the Crown, Musk Raids Cursor

Originally published at https://www.aimadetools.com

Bun vs Node.js — Should You Switch in 2026?

Joske Vermeulen — Wed, 25 Mar 2026 09:59:12 +0000

Quick Comparison

	Bun	Node.js
Speed	Faster (Zig + JavaScriptCore)	Standard (V8)
Package manager	Built-in (fast)	npm/pnpm/yarn
TypeScript	Native (no build step)	Needs tsc/tsx
Test runner	Built-in	External (Jest, Vitest)
Compatibility	Most npm packages work	100% ecosystem
Maturity	Young	Battle-tested

When to Use Bun

New projects where speed matters
You want TypeScript without a build step
You want an all-in-one tool (runtime + bundler + test runner + package manager)
Scripts and tooling

When to Use Node.js

Production apps that need maximum stability
You need 100% npm compatibility
Enterprise environments
You depend on Node-specific APIs

Key Differences

Speed: Bun is genuinely faster — 3-5x for many operations. Package installs, test runs, and server startup are noticeably quicker.

Compatibility: Most npm packages work with Bun, but some native modules and Node-specific APIs don't. This gap is shrinking but still exists.

All-in-One: Bun replaces Node + npm + tsc + Jest in a single binary. That's compelling for developer experience.

Verdict

Bun for new projects and tooling. Node.js for production apps where stability is critical. In 2026, Bun is mature enough for most use cases, but Node.js isn't going anywhere.

Related resources

🛠️ Free tools related to this article:

package.json Analyzer

Originally published at https://aimadetools.com

The Complete MiMo-V2 Family Guide — Pro, Flash, Omni, and TTS (2026)

Joske Vermeulen — Mon, 23 Mar 2026 09:39:13 +0000

Xiaomi released four AI models in the MiMo-V2 family between December 2025 and March 2026. Together, they form a complete AI agent stack — reasoning, perception, and speech. Here's everything you need to know about each one.

The family at a glance

Model	Role	Params (total/active)	Context	Pricing (in/out)	Open source
MiMo-V2-Pro	Brain	1T / 42B	1M tokens	$1.00/$3.00	❌
MiMo-V2-Flash	Fast worker	309B / 15B	56K tokens	$0.10/$0.30	✅
MiMo-V2-Omni	Eyes & ears	—	—	TBD	❌
MiMo-V2-TTS	Voice	—	—	TBD	❌

MiMo-V2-Pro — The flagship

Released: March 18, 2026 (previously known as "Hunter Alpha")

Pro is Xiaomi's frontier model, designed for complex reasoning, coding, and autonomous agent workflows. It spent a week on OpenRouter as an anonymous stealth model before Xiaomi revealed it — and the AI community mistook it for DeepSeek V4.

Key specs:

1 trillion total parameters, 42B active (MoE)
1 million token context window
Hybrid attention mechanism
Multi-Token Prediction for speed
#3 globally on PinchBench and ClawEval agent benchmarks

Benchmark highlights:

Approaches Claude Opus 4.6 on coding and agent tasks
Surpasses Claude Sonnet 4.6 on most benchmarks
5-8x cheaper than Opus for comparable quality

Best for: AI agents, complex coding, long-context processing, multi-step workflows.

Deep dive: What Is MiMo-V2-Pro? | How to Use the MiMo-V2-Pro API

MiMo-V2-Flash — The open-source workhorse

Released: December 17, 2025

Flash is the model that put Xiaomi on the AI map. Open-source, blazing fast, and absurdly cheap — it became one of the most popular models on OpenRouter within weeks of launch.

Key specs:

309B total parameters, 15B active (MoE)
56K token context window
150 tokens/sec inference speed
Hybrid sliding-window attention (128-token window, 5:1 ratio)
Weights available on HuggingFace

Benchmark highlights:

73.4% on SWE-Bench Verified (#1 open-source)
Comparable to Claude Sonnet 4.5 at 3.5% of the cost
Top 2 among open-source models on agent benchmarks

Best for: High-volume coding tasks, self-hosting, prototyping, cost-sensitive production workloads.

Deep dive: What Is MiMo-V2-Flash? | MiMo-V2-Flash vs DeepSeek V3

MiMo-V2-Omni — The multimodal perceiver

Released: March 18, 2026

Omni is Xiaomi's multimodal model — it natively processes text, images, video, and audio within a unified architecture. While Pro thinks and Flash codes, Omni sees and hears.

Key capabilities:

Text, image, video, and audio input in one model
10+ hours of continuous audio processing
GUI interaction — can navigate and operate browser interfaces
Cross-modal reasoning (processes visual and textual information together)

Designed for: Browser automation, video analysis, document understanding, voice-controlled agents.

Xiaomi positions Omni as the "executor" in their agent stack — it perceives the environment and carries out actions that Pro plans.

Deep dive: What Is MiMo-V2-Omni?

MiMo-V2-TTS — The voice

Released: March 18, 2026

MiMo-V2-TTS is Xiaomi's text-to-speech model, designed to give AI agents a human-like voice. It's not a general-purpose TTS system — it's specifically built for agent interaction.

Key capabilities:

Emotional nuance in speech output
Real-time adaptability (adjusts tone based on context)
Designed for conversational AI, not just reading text aloud
Integrates with Pro and Omni for end-to-end agent communication

TTS completes the agent loop: Pro reasons, Omni perceives, and TTS communicates. For Xiaomi's smart home and automotive products, this means AI assistants that sound natural rather than robotic.

How they work together

Xiaomi designed these models as a system, not as standalone products:

User request
    ↓
MiMo-V2-Pro (plans the task, breaks it into steps)
    ↓
MiMo-V2-Omni (perceives environment, executes GUI actions)
    ↓
MiMo-V2-TTS (communicates results to user)
    ↓
MiMo-V2-Flash (handles high-volume subtasks cheaply)

This is Xiaomi's play for their "person-vehicle-home" ecosystem. The AI in your Xiaomi phone, car, and smart home devices all run on this stack.

Which model should you use?

For coding and development: Start with Flash. It's open source, fast, and cheap. Upgrade to Pro when you need better quality or longer context.

For AI agents: Pro for planning and reasoning. Consider Omni if your agent needs to interact with visual interfaces.

For cost optimization: Use Flash for 80% of tasks, Pro for the remaining 20%. See MiMo-V2-Pro vs Flash for the detailed comparison.

For self-hosting: Flash is your only option — it's the only open-source model in the family.

The bigger picture

A year ago, Xiaomi was known for phones and rice cookers. Now they have a four-model AI family that competes with Anthropic and OpenAI on specific benchmarks. The lead researcher behind MiMo came from DeepSeek, and the architectural DNA shows.

What makes the MiMo family interesting isn't any single model — it's the system. Xiaomi is building an integrated AI stack for their hardware ecosystem, and they're making the individual models available to developers along the way. Whether that strategy succeeds depends on execution, but the technical foundation is impressive.

Related: MiMo-V2-Pro vs Claude Opus 4.6

Related: MiMo-V2-Pro vs Claude vs GPT

weekly)

Originally published at https://aimadetools.com

HTMX vs React — Do You Really Need a JavaScript Framework?

Joske Vermeulen — Sun, 22 Mar 2026 09:38:37 +0000

Quick Comparison

	HTMX	React
Approach	HTML attributes	JavaScript components
Bundle size	~14KB	~40KB + your code
Server	Returns HTML fragments	Returns JSON (usually)
Complexity	Very low	Higher
Interactivity	Good for most apps	Unlimited
Learning curve	Very low	Moderate

When to Use HTMX

Server-rendered apps (Django, Rails, Laravel, Go)
CRUD apps, admin panels, dashboards
You want simplicity over complexity
Your team is stronger in backend than frontend

When to Use React

Highly interactive UIs (real-time collaboration, complex forms)
You need a mobile app too (React Native)
Rich client-side state management
Complex component composition

Key Differences

Mental Model: HTMX extends HTML — you add attributes like hx-get, hx-post, hx-swap to make elements dynamic. React replaces HTML with a JavaScript component tree.

Server: HTMX servers return HTML fragments. React servers typically return JSON that the client renders. HTMX is simpler but means your server does more rendering work.

When HTMX Falls Short: Real-time collaborative editing, complex drag-and-drop, offline-first apps, anything that needs heavy client-side state.

Verdict

HTMX is perfect for the 90% of web apps that don't need React's complexity. If you're building a content site, admin panel, or CRUD app, HTMX with a server framework is simpler and faster to build. React for genuinely complex interactive UIs.

Related resources

React complete guide

Related: [shadcn/ui vs Material UI — Which React Component Library?](https://aimadetools.com/blog/shadcn-vs-material-ui/?utm_source=devto&utm_medium=crosspost&utm_campaign=

weekly)

Originally published at https://aimadetools.com

What Is MiMo-V2-Pro? Xiaomi's Trillion-Parameter AI Model Explained

Joske Vermeulen — Fri, 20 Mar 2026 19:59:50 +0000

MiMo-V2-Pro is a large language model built by Xiaomi — yes, the phone company. It has over 1 trillion total parameters, a 1 million token context window, and it's specifically designed for autonomous AI agent tasks. It launched on March 18, 2026, after a week of anonymous stealth testing on OpenRouter under the codename "Hunter Alpha."

If you've been following AI news, you probably heard about the mystery model that everyone thought was DeepSeek V4. It wasn't. It was Xiaomi.

The basics

MiMo-V2-Pro is a mixture-of-experts (MoE) model. That means it has 1 trillion total parameters split across many "expert" sub-networks, but only activates 42 billion parameters for any given request. This is the same architectural approach used by DeepSeek V3 and Mixtral — it delivers near-frontier performance at a fraction of the compute cost.

Spec	Value
Total parameters	~1 trillion
Active parameters	42 billion (MoE)
Context window	1 million tokens
Max output	32,000 tokens
Architecture	Hybrid attention MoE
Built by	Xiaomi (MiMo AI division)
Led by	Luo Fuli (ex-DeepSeek)
Released	March 18, 2026

How it works

Like all large language models, MiMo-V2-Pro predicts the next token in a sequence. What makes it different is the MoE architecture and its focus on agentic tasks.

Mixture of Experts: Instead of running every parameter for every request (like GPT-5.4 or Claude Opus), MiMo-V2-Pro routes each token through a subset of specialized "expert" networks. Only 42 billion of the 1 trillion parameters activate per inference. This means you get the knowledge capacity of a trillion-parameter model at the inference cost of a ~40B model.

Hybrid attention: The model uses a mixed attention mechanism optimized for long-context reasoning and tool use. This is what enables the 1 million token context window without the quality degradation that some models show at extreme context lengths.

Agent-first design: MiMo-V2-Pro was built from the ground up for multi-step autonomous tasks — not chat. It's designed to plan, use tools, execute sequences, and recover from errors. Think: coding agents, research pipelines, automated workflows.

The Hunter Alpha story

On March 11, 2026, a model called "Hunter Alpha" appeared on OpenRouter with no attribution. It was free, had a 1M context window, and performed surprisingly well. The AI community immediately assumed it was DeepSeek V4 doing a stealth test.

The speculation made sense — the model had a similar "feel" to DeepSeek's architecture, and it was clearly Chinese-built. It processed over 1 trillion tokens during its anonymous run, topping OpenRouter's usage charts.

On March 18, Xiaomi revealed the truth: Hunter Alpha was an early test build of MiMo-V2-Pro. The DeepSeek connection wasn't wrong — it was just indirect. Luo Fuli, who leads Xiaomi's MiMo AI division, was a core contributor to DeepSeek's R1 and V-series models before joining Xiaomi in late 2025.

Where it ranks

MiMo-V2-Pro has posted strong benchmark results across agent-focused evaluations:

Benchmark	Score	Global Rank
Artificial Analysis Intelligence Index	49	#8 worldwide, #2 Chinese
PinchBench	~81–84	#3 globally
ClawEval	61.5	#3 globally
GDPval-AA (agentic Elo)	1434	#1 Chinese model

For context, PinchBench and ClawEval are agent-focused benchmarks that test multi-step task completion — not just chat quality. MiMo-V2-Pro ranks right behind Claude Opus 4.6 variants on these tests, and ahead of several GPT-5.x iterations.

Pricing

This is where it gets interesting. MiMo-V2-Pro is aggressively priced:

Context length	Input (per 1M tokens)	Output (per 1M tokens)
≤ 256K tokens	$1.00	$3.00
256K – 1M tokens	$2.00	$6.00

For comparison, Claude Opus 4.6 costs $5/$25 and GPT-5.4 costs $2.50/$15. MiMo-V2-Pro is roughly 5–8x cheaper on output than Opus and 3–5x cheaper than GPT-5.4.

The MiMo-V2 family

MiMo-V2-Pro isn't alone. Xiaomi launched three models simultaneously:

MiMo-V2-Pro — The flagship text reasoning model (this article)
MiMo-V2-Omni — A multimodal model that processes text, images, video, and audio natively. Priced at $0.40/$2.00 per million tokens.
MiMo-V2-TTS — A text-to-speech model with emotion control, singing capability, and Chinese dialect support.

There's also MiMo-V2-Flash, an open-source smaller model (309B total, 15B active) that scores 73.4% on SWE-bench Verified — making it the top open-source coding model.

How to access it

MiMo-V2-Pro is available through:

Xiaomi's MiMo API platform at platform.xiaomimimo.com
OpenRouter (where it originally appeared as Hunter Alpha)
MiMo Studio (Xiaomi's web interface)

The API is OpenAI-compatible, so you can swap it into existing code that uses the OpenAI SDK with minimal changes.

Why it matters

Three reasons MiMo-V2-Pro is significant:

1. A phone company built a frontier model. Xiaomi isn't an AI lab. They're a consumer electronics company. The fact that they can build a model that competes with Anthropic and OpenAI on agent benchmarks — while pricing it at a fraction of the cost — says something about how accessible frontier AI development has become.

2. The agent era is real. MiMo-V2-Pro is explicitly not a chatbot. It's an agent model. Every major lab is now building for autonomous multi-step execution, not conversation. If you're still thinking of AI as "a thing I chat with," you're behind.

3. Price pressure is accelerating. At $1/$3 per million tokens, MiMo-V2-Pro puts serious pressure on Western pricing. Even if the quality is slightly below Opus 4.6, the 5–8x cost difference makes it viable for high-volume production workloads where "good enough" beats "best but expensive."

Should you use it?

If you're building AI agents, automated pipelines, or high-volume processing tasks — absolutely worth testing. The price-to-performance ratio is compelling, especially for tasks that don't require the absolute best model.

For critical coding tasks where accuracy matters most, Claude Opus 4.6 and GPT-5.4 still have the edge. But for everything else, MiMo-V2-Pro just made the conversation a lot more interesting.

For a detailed head-to-head, see MiMo-V2-Pro vs Claude vs GPT: Where Xiaomi's Model Actually Stands, MiMo-V2-Pro vs Claude Opus 4.6, or MiMo-V2-Pro vs DeepSeek V3.

Related: [AI Dev Weekly Extra: Xiaomi's Hunter Alpha Was Never DeepSeek V4](https://aimadetools.com/blog/ai-dev-weekly-extra-xiaomi-hunter-alpha-mimo-v2-pro/?utm_source=devto&utm_medium=crosspost&utm_campaign=

weekly)

Originally published at https://aimadetools.com

Build a Discord Bot That Roasts Your Code With AI

Joske Vermeulen — Fri, 20 Mar 2026 14:43:54 +0000

Every dev Discord server needs a code roast bot. Someone pastes a code snippet, the bot tears it apart with the energy of a senior developer who hasn't had coffee yet. It's educational, it's entertaining, and it's surprisingly easy to build.

In this tutorial, we'll build a Discord bot that watches for code blocks in messages, reviews them with AI in a roast-style tone, and replies with brutally honest feedback. Think code review meets comedy.

What we're building

User:
  !roast

javascript
function getUser(id) {
var user = null;
fetch('/api/users/' + id).then(res => {
user = res.json();
});
return user;
}


Bot:
  🔥 CODE ROAST 🔥

  Oh no. Oh no no no.

  1. You're returning `user` before the fetch completes.
     This function returns `null` every single time. You've
     built a function whose only job is to return null. Impressive.

  2. `var` in 2026? Did you find this code in a time capsule?

  3. `res.json()` returns a Promise too, which you're not
     awaiting. So even if the timing worked, `user` would
     be a Promise object, not actual data.

  Here's what you probably meant:

javascript
async function getUser(id) {
const res = await fetch(/api/users/${id});
return res.json();
}


  Rating: 2/10 — The indentation was nice though. 💀

Prerequisites

Node.js 20+
A Discord account
An Anthropic API key
A Discord server where you have admin permissions

Step 1: Create the Discord bot

Go to discord.com/developers/applications
Click "New Application" → name it "Code Roaster"
Go to "Bot" tab → click "Add Bot"
Copy the bot token
Under "Privileged Gateway Intents," enable Message Content Intent
Go to "OAuth2" → "URL Generator" → select bot scope and Send Messages + Read Message History permissions
Copy the generated URL and open it to invite the bot to your server

Step 2: Set up the project

mkdir roast-bot && cd roast-bot
npm init -y
npm install discord.js @anthropic-ai/sdk

Step 3: Build the bot

Create index.js:

import { Client, GatewayIntentBits } from 'discord.js';
import Anthropic from '@anthropic-ai/sdk';

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});

const anthropic = new Anthropic();

const ROAST_PROMPT = `You are a code review bot with the personality of a brutally honest senior developer who's seen too much bad code. Your job is to roast the code — point out every issue in a funny, sarcastic way. But always be educational: explain WHY something is wrong and show the fix.

Rules:
- Be funny and sarcastic, but never mean-spirited or personal
- Always explain the actual technical issue behind each roast
- End with a corrected version of the code if possible
- Give a rating out of 10
- Keep it under 300 words
- Use emojis sparingly for effect

Roast this code:`;

// Listen for !roast command
client.on('messageCreate', async (message) => {
  if (message.author.bot) return;
  if (!message.content.startsWith('!roast')) return;

  // Extract code block
  const codeMatch = message.content.match(/```
{% endraw %}
(\w*)\n?([\s\S]*?)
{% raw %}
```/);
  if (!codeMatch) {
    message.reply('Paste a code block with your message. Example:\n!roast\n\\`\\`\\`js\nyour code here\n\\`\\`\\`');
    return;
  }

  const language = codeMatch[1] || 'unknown';
  const code = codeMatch[2].trim();

  if (code.length < 10) {
    message.reply("That's barely code. Give me something to work with. 😤");
    return;
  }

  if (code.length > 3000) {
    message.reply("I'm not reading all that. Keep it under 100 lines. 📏");
    return;
  }

  // Show typing indicator
  message.channel.sendTyping();

  try {
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-4-20250514',
      max_tokens: 800,
      messages: [{
        role: 'user',
        content: `${ROAST_PROMPT}\n\nLanguage: ${language}\n\`\`\`${language}\n${code}\n\`\`\``
      }],
    });

    const roast = response.content[0].text;

    // Discord has a 2000 char limit
    if (roast.length > 1900) {
      const parts = roast.match(/[\s\S]{1,1900}/g) || [];
      for (const part of parts) {
        await message.reply(part);
      }
    } else {
      message.reply(`🔥 **CODE ROAST** 🔥\n\n${roast}`);
    }
  } catch (err) {
    console.error(err);
    message.reply("My roasting circuits overheated. Try again. 🫠");
  }
});

// Also support !review for a nicer tone
client.on('messageCreate', async (message) => {
  if (message.author.bot) return;
  if (!message.content.startsWith('!review')) return;

  const codeMatch = message.content.match(/```
{% endraw %}
(\w*)\n?([\s\S]*?)
{% raw %}
```/);
  if (!codeMatch) {
    message.reply('Paste a code block with your message.');
    return;
  }

  message.channel.sendTyping();

  try {
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-4-20250514',
      max_tokens: 800,
      messages: [{
        role: 'user',
        content: `Review this code constructively. Point out bugs, improvements, and best practices. Be helpful and professional. Keep it concise.\n\nLanguage: ${codeMatch[1] || 'unknown'}\n\`\`\`\n${codeMatch[2].trim()}\n\`\`\``
      }],
    });

    message.reply(`📝 **Code Review**\n\n${response.content[0].text}`);
  } catch (err) {
    message.reply("Something went wrong. Try again.");
  }
});

client.on('ready', () => {
  console.log(`🔥 Roast bot is online as ${client.user.tag}`);
});

client.login(process.env.DISCORD_TOKEN);

Step 4: Run it

export DISCORD_TOKEN=your-discord-bot-token
export ANTHROPIC_API_KEY=your-anthropic-key
node index.js

Go to your Discord server and try:

!roast

javascript
for (var i = 0; i < arr.length; i++) {
setTimeout(function() { console.log(arr[i]); }, 1000);
}

plaintext

The two modes

The bot has two commands:

!roast — brutal, funny, educational. For entertainment and learning.
!review — professional, constructive. For when you actually want help.

Same AI, different personality. The prompt controls everything.

Tuning the roast level

Adjust the prompt to control intensity:

Mild roast:

Be gently sarcastic, like a patient mentor who's slightly disappointed.

plaintext

Medium roast (default):

Be brutally honest and funny, like a senior dev who's seen too much.

plaintext

Nuclear roast:

Channel the energy of a developer who just found production code
written by an intern with no code review. Hold nothing back.

javascript

Rate limiting

Prevent spam by adding a cooldown:

const cooldowns = new Map();
const COOLDOWN_MS = 30000; // 30 seconds

client.on('messageCreate', async (message) => {
  if (!message.content.startsWith('!roast')) return;

  const lastUsed = cooldowns.get(message.author.id) || 0;
  if (Date.now() - lastUsed < COOLDOWN_MS) {
    const remaining = Math.ceil((COOLDOWN_MS - (Date.now() - lastUsed)) / 1000);
    message.reply(`Cooldown: ${remaining}s. Your code isn't going anywhere. 😏`);
    return;
  }
  cooldowns.set(message.author.id, Date.now());

  // ... rest of the handler
});

Deploying

Same as any Node.js bot — a VPS with pm2, a Docker container, or Railway/Fly.io:

# pm2
pm2 start index.js --name roast-bot

# Docker
docker build -t roast-bot .
docker run -d --env-file .env roast-bot

What you learned

How to create a Discord bot with discord.js
How to extract code blocks from Discord messages with regex
How to use different AI prompts to control tone and personality
How to handle Discord's message length limits
How to add rate limiting to prevent abuse

The bot is about 80 lines of core logic. It's the kind of thing that makes a dev Discord server 10x more fun — and people actually learn from the roasts because every joke comes with a real explanation.

Related resources

JavaScript complete guide — the language behind the bot
npm complete guide — managing dependencies
Docker complete guide — deploying the bot

🛠️ Free tools related to this article:

package.json Analyzer

Originally published at https://aimadetools.com

React vs Angular — Which Should You Learn in 2026?

Joske Vermeulen — Wed, 18 Mar 2026 10:43:19 +0000

Quick Comparison

	React	Angular
Type	Library	Full framework
Language	JavaScript/TypeScript	TypeScript (required)
Created by	Meta (Facebook)	Google
State management	External (Redux, Zustand, etc.)	Built-in (Signals, RxJS)
Bundle size	Smaller (pick what you need)	Larger (batteries included)
Learning curve	Lower entry, higher ceiling	Steeper initial curve

When to Use React

You want flexibility to choose your own tools
You're building a startup or small-to-medium app
You want the largest job market and ecosystem
You prefer a gradual learning curve

When to Use Angular

You're building a large enterprise application
You want everything included out of the box (routing, forms, HTTP, testing)
Your team prefers opinionated structure
You're already in a TypeScript-heavy environment

Key Differences

Philosophy: React gives you a view layer and lets you pick everything else. Angular gives you the whole kitchen — routing, forms, HTTP client, dependency injection, testing utilities.

State: React uses hooks (useState, useReducer) plus external libraries. Angular has Signals (new), RxJS observables, and services with dependency injection.

Templates: React uses JSX (JavaScript + HTML). Angular uses HTML templates with its own syntax (ngIf, ngFor, @if, @for).

Verdict

React for flexibility and ecosystem size. Angular for large teams that want convention over configuration. In 2026, React still has the larger market share, but Angular is solid for enterprise work.

Related resources

React complete guide ---

Originally published at https://aimadetools.com