MAI-Code-1-Flash Review: I Tested Microsoft's First Coding Model

Microsoft shipped its first fully in-house coding model at Build in June, and I've spent a few hours putting it through my standard test suite. This MAI-Code-1-Flash review is the result: four real coding tasks, the same ones I run against every model, no benchmark screenshots recycled from the press release.

Short version: it's fast, it's cheap, and I won't be using it. But the details are more interesting than the verdict, so let's go through it.

What Is MAI-Code-1-Flash?

MAI-Code-1-Flash is Microsoft's first coding model trained entirely in-house, announced on June 2, 2026 at Build as one of seven MAI models from Mustafa Suleyman's AI Superintelligence Team. It's a sparse Mixture-of-Experts model with 137B total parameters, only 5B active per token, and a 256K context window. It was trained directly inside the GitHub Copilot production harness, which is genuinely a different approach: instead of optimising for benchmarks and hoping it transfers, Microsoft trained it against the exact tools and workflows Copilot uses in VS Code.

The positioning is refreshingly honest. This is not a frontier model and Microsoft doesn't pretend it is. It's meant to be the cheap, fast, everyday workhorse. Completions, small refactors, boilerplate, repository Q&A. I actually like this strategy. Not every task needs a trillion-parameter model burning through your credits, and a vendor saying "this is our budget option" out loud is rarer than it should be.

The question is whether it's good enough at the everyday stuff to earn that slot. That's what I tested.

Why I Wanted to Try It

Two reasons. First, plain curiosity. Microsoft building its own models after the OpenAI contract renegotiation is one of the more interesting strategic shifts this year. Suleyman has been open about the ambition (and about the current gap, telling The Verge that only three labs matter right now and Microsoft isn't one of them). A first release from a team with that much money behind it is worth a look regardless of the benchmarks.

Second, I genuinely like the fast-and-affordable philosophy. My daily driver setup already routes easy tasks to cheaper models. If Microsoft delivered a great budget model, I'd use it. I have zero brand loyalty here.

I tested it through my existing GitHub Copilot subscription in VS Code, using the same four prompts I throw at every model I review. Same conditions, same expectations.

My Test Setup

The Four Standard Tests

Every model I review gets the identical suite:

A website for a fictional Sydney coffee roaster. Tests design taste, layout, typography.
A pop culture clothing store. Tests the same skills with a louder brief.
A poker simulation in Go. Tests actual logic: game rules, statistics, state management.
An audit of my own site, thomas-wiegold.com. Tests analysis and judgement on a real codebase.

Same prompts every time. It's not a scientific benchmark, but it's apples-to-apples across every model I've written about, and after enough reviews you develop a feel for where each model sits.

Hands-On Results

Website Builds: Rounded Corners Everywhere

The coffee roaster site was, and I'm choosing my words carefully here, incredibly ugly. It worked. Nothing was broken. But it was the worst-looking result I've had since I started running this test. Boring system-adjacent fonts, the most generic brown-and-cream coffee palette imaginable, a flat layout with no hierarchy, and rounded corners on absolutely everything. Buttons, cards, images, sections. If it had a corner, it got rounded.

The clothing store went slightly better. The animations were actually a bright spot, smooth and reasonably tasteful. But the same problems showed up: boring fonts, and again the rounded-corner obsession. It's such a specific quirk that I have to assume it's baked into the training data or the RL reward somewhere. Some evaluator at Microsoft apparently really likes border-radius.

To be fair, I retested both builds with my custom web-design skill that I developed based on Claude's frontend-design plugin, which usually rescues weaker models. Fonts and layout improved noticeably. The rounded corners survived. At this point I consider them a personality trait.

Go Poker Simulation: Fast but Broken

This one was an outright fail, and the numbers make it easy to show why.

Generation speed was genuinely impressive. The code appeared quickly, compiled, and ran. Then I looked at the output: after 1,000 simulated hands, individual players were showing 800 to 900+ wins each. In a game where most of the time one player wins per hand, that's not a rounding error, that's a simulation that doesn't understand what it's simulating. The betting logic was similarly broken. Players were behaving in ways that made no sense, and the game state was often inconsistent. The model produced code that looked superficially correct but failed to implement the rules of poker in any meaningful way.

It is not an easy task. Claude Fable was the only model to get it right on the first try, and created a perfect simulation. All other models I tested needed multiple iterations, and some never got there. But MAI-Code-1-Flash didn't even get close. It was fast, yes, but speed without correctness is useless.

Website Audit: Passable, Not Impressive

The audit of my own site was the most respectable result. Fast turnaround, and it found a handful of real issues. It also flagged several non-issues with full confidence and missed things that stronger models catch reliably. If I'd never run this test with a better model, I might have been satisfied. I have, so I wasn't.

Passable. That's the word. Not a disaster, not a reason to pick it.

How MAI-Code-1-Flash Compares to the Benchmarks

Here's where my results and Microsoft's marketing part ways.

Microsoft's launch numbers show MAI-Code-1-Flash beating Claude Haiku 4.5 across every coding benchmark it published, including a 16-point lead on SWE-Bench Pro (51.2% vs 35.2%), while using up to 60% fewer tokens. Sounds great. Three caveats.

First, every comparison is vendor-run, in Microsoft's own VS Code harness, against exactly one competitor, and Haiku is the smallest model in Anthropic's lineup. That's not a benchmark table, that's a controlled demolition.

Second, on independent leaderboards, ~51% SWE-Bench Pro sits well below the frontier. Opus 4.8, GLM-5.2, Qwen3.7 Max, MiniMax M3, GPT-5.5 and Kimi K2.6 all score meaningfully higher. To be fair to Microsoft, 51% from a 5B-active model is strong for its size (Opus 4.6 scored around 52% on the same benchmark not that long ago). The engineering is real. The competitive position isn't.

Third, and this is the part benchmarks never capture: my hands-on results don't match the story. A model that scores 51% on SWE-Bench Pro should not produce a poker simulation where everyone wins. Benchmarks and real-world usability diverge, and this release is a textbook example.

Task	Result
Coffee roaster website	Functional, worst design in my testing history
Clothing store website	Weak design, good animations
Go poker simulation	Fail (800-900+ wins per player after 1,000 hands)
Website audit	Passable, missed issues stronger models catch
Speed	Genuinely fast, as advertised
Cost	Genuinely cheap, as advertised

One more thing worth knowing before you buy the "clean, licensed data" pitch: Simon Willison dug into the underlying technical paper and found the same public-web-crawl licensing situation as every other major LLM, roughly 1.2 trillion crawled pages plus a Common Crawl portion. The Data Card also discloses that OpenAI models were used for data preparation. Technically compatible with "no distillation," but the marketing is doing some heavy lifting.

Is MAI-Code-1-Flash Worth Using?

For me, no. And I've tried to find a reason.

The pricing is real: $0.75 per million input tokens, $0.075 cached, $4.50 output under Copilot's AI Credits system. That undercuts Haiku 4.5 on input, and the token efficiency claim means effective cost per task could be lower still. If your entire use case is autocomplete and boilerplate at maximum volume and minimum cost, it might squeeze into your setup on price alone.

But at similar price points you can get Kimi K2.7 Code, Qwen 3.7 Plus, MiniMax M3, or DeepSeek V4, and every one of them beat MAI-Code-1-Flash in my testing. There's no dimension where it wins except being made by Microsoft. If you're in Copilot and want a cheap model, my honest recommendation is Kimi K2.7 Code. It costs about the same and doesn't lose track of who won the poker hand.

One practical warning if you do try it: multiple users have reported a plan-mode looping bug that burns credits at speed while producing nothing. Under usage-based billing, set your budget caps before experimenting, not after.

The genuinely interesting open question is MAI-Thinking-1, the flagship reasoning model still in private preview. It's the base MAI-Code-1-Flash was trained from, it's a much bigger model, and Microsoft's claims for it are more ambitious. If the small model is this rough and the big one is good, the strategy still works.

Final Thoughts

Fast and cheap: confirmed. Both claims check out completely, and I want to give Microsoft credit for shipping exactly the performance profile it advertised.

Quality: not confirmed. The design output was the worst I've tested, the logic task failed outright, and the audit was merely okay. For a model whose entire pitch is "good enough for everyday work," it wasn't good enough for my everyday work.

I remain curious about where Microsoft goes from here. Training inside the production harness is a smart idea, the token efficiency is real engineering, and MAI-Thinking-1 might change the picture entirely. I'll test it the moment I can get access, same four tasks as always.

Until then: skip this one. Your credits deserve better.

Previously in this series: my reviews of Claude Fable 5, MiniMax M3, and DeepSeek V4. And if you enjoy watching hype meet reality, there's also the DeepSeek V5 rumour that wasn't.