MiniMax M3 Coding Benchmark: 1/765th the Price of Opus, but Better Code Quality?

MiniMax M3 is a recently launched open-source large language model that has been drawing significant attention. Released on June 1 by Chinese AI lab MiniMax, it features a million-token context window, native multimodal capabilities, and a price point that's almost hard to believe — for the same $20, you get 765 times more tokens than Claude Opus.

But can something this cheap actually be good? YouTube creator Tech With Tim put MiniMax M3 head-to-head against Cursor's built-in Composer 2.5 across three real-world coding tasks, and the results are quite thought-provoking.

MiniMax M3 Key Specs: Million-Token Context, Open Weights, and Disruptive Pricing

MiniMax M3 comes from Chinese AI lab MiniMax. Unlike the closed-source approaches of Anthropic and OpenAI, MiniMax has chosen to fully open-source its weights — you can download, fine-tune, and freely use the model. This strategy stands in stark contrast to the two dominant camps in the AI industry: Anthropic (Claude series) and OpenAI (GPT series) follow a closed-source model where users can only access models through APIs without access to model parameters; while Meta's LLaMA series, Mistral, DeepSeek^Ad, and others take the open-source route. Open weights mean developers can deploy models locally, fine-tune them for specific tasks, and even build commercial products on top of them — this is particularly important for enterprises with strict data privacy requirements (such as healthcare and finance), since data never needs to leave their own servers.

The model's core specifications include:

• Context Window: Up to 1 million tokens, with a guaranteed minimum of 512K tokens. One million tokens is roughly equivalent to 7.5 million English words, or about 1,500 pages of technical documentation. For comparison, GPT-4 Turbo's context window is 128K tokens, and Claude 3.5 Sonnet's is 200K tokens. Achieving million-token context typically relies on techniques like Sparse Attention, sliding window attention, or linear attention variants to avoid the quadratic complexity problem of attention computation in standard Transformer architectures. For coding scenarios, this means the model can "read" an entire large codebase in one pass, understanding cross-file dependencies and architectural design without needing to chunk code and stitch context together.
• Multimodal Support: Natively trained on image, video, and text generation (not bolted on after the fact). "Native multimodal" means the model was trained simultaneously on text, image, video, and other data types during pre-training, giving it cross-modal understanding capabilities from the ground up. The alternative "bolted-on" approach — training a text-only model first, then connecting a vision encoder via adapters — typically underperforms native approaches on tasks requiring deep cross-modal reasoning (such as generating code from UI screenshots), because the representation spaces of different modalities haven't been sufficiently aligned during training.
• Open Source: Fully open weights with API access available
• Autonomous Operation: Official demos have shown the model running autonomously for 12 hours without human intervention

The most jaw-dropping aspect is the pricing strategy. At $20 per month, MiniMax M3 provides approximately 1.7 billion tokens; for the same budget, Claude Opus offers only about 2.2 million tokens, Claude Sonnet about 3.7 million, and Claude Haiku about 11.1 million. That makes MiniMax M3's cost-effectiveness 765 times that of Opus. This number alone is enough to change many developers' model selection strategies.

Test 1: Building a URL Shortener from Scratch — Fast and Rough vs. Slow and Polished

The first task used the same prompt for both models to build a URL shortener web application from scratch, requiring API endpoints, redirect functionality, a dashboard page, and a modern UI.

Composer 2.5's Performance

Cursor is one of the most popular AI-powered coding IDEs today, deeply customized on top of VS Code with multiple built-in AI assistance features. Composer is Cursor's core AI agent feature, allowing users to describe requirements in natural language while the AI automatically generates, modifies, and refactors code. Unlike direct API calls, Composer can perceive the entire project's file structure, read relevant file contents, and apply code changes directly in the editor. This high level of integration into actual development workflows is why it serves as the "baseline opponent" in this comparison.

Composer completed the task in about 2 minutes, generating 7 files. The functionality basically worked — URL shortening, redirects, click tracking, and dark/light mode toggle all functioned properly. But the code structure was rough: all logic was crammed into a few large files, with no test code, no input validation, and no comments. As the creator put it, "it gave the absolute bare minimum."

MiniMax M3's Performance

MiniMax M3 took about 15 minutes but generated 21 files. The code structure was clean — configuration, database, error handling, routing, service layer, and utility functions were each in their own modules, with appropriately sized files. More importantly, it automatically wrote comprehensive test cases, verified functionality in the browser, and self-corrected when it found issues.

The longer completion time had two reasons: first, the codebase was larger; second, the model drafts a complete plan before implementing step by step, repeatedly self-reviewing and correcting along the way. While it was 5-6x slower, the output quality was noticeably higher — a classic "fast and rough" vs. "slow and polished" comparison.

Test 2: Rust Ray Tracer — A Hardcore Test of Low-Level Programming Ability

The second task stepped outside the comfort zone of web development, requiring a ray tracer written from scratch in Rust that renders a scene with 4-5 spheres on a checkerboard floor, outputting a PPM format image. This is a computationally intensive, low-level programming task that severely tests both the model's Rust language proficiency and algorithm comprehension.

Ray tracing is a classic rendering technique in computer graphics that generates realistic images by simulating the physical process of light rays traveling from a camera and interacting with objects in a scene. Implementing a basic ray tracer requires knowledge of vector math (dot products, cross products, normal calculations), ray-geometry intersection algorithms, Phong or Blinn-Phong lighting models, and recursive reflection and refraction calculations. Choosing Rust adds another layer of difficulty — Rust is known for its strict ownership system and borrow checker, with the compiler rejecting at compile time any code that could lead to memory safety issues. PPM (Portable Pixmap) is a simple uncompressed image format commonly used in graphics education and testing because it requires no external libraries to generate. This task comprehensively tests the model's mathematical reasoning, algorithm implementation, and language feature mastery.

The results showed significant differences:

• Composer 2.5: The generated image was upside down, and even after flipping, the reflection effects had obvious errors — the spheres' specular reflections exhibited abnormal mirroring artifacts. The code lacked comments, and while the file structure was acceptable, the core algorithm implementation had bugs.
• MiniMax M3: The generated image was correctly oriented, with noticeably better 3D depth and reflection effects on the spheres. While one sphere was still clipped, the overall rendering quality was higher and more accurate. Code comments were clear and file organization was well-structured.

Both models generated similar amounts of code, but MiniMax M3 spent 3-4x more time on deeper analysis and verification. This led the creator to a key observation: MiniMax M3's architecture seems specifically designed for long-running complex tasks — it fully leverages the million-token context window for deep analysis rather than optimizing for the fastest possible output.

Test 3: Complex Codebase Feature Extension — The Closest to Real-World Work

The third task was the most realistic work scenario — adding a "Daily Streak" feature to a full-stack application (Python backend + TypeScript frontend) containing tens of thousands of lines of code. This required the model to first understand the existing codebase's architecture, then add backend APIs, frontend UI, and core service logic in the correct locations.

The gap in this task was relatively smaller but still noticeable:

• Composer 2.5: Completed quickly, adding a simple Daily Streak component to the UI with a single small test file. Changes were primarily small UI patches.
• MiniMax M3: While Composer had already finished, it was still analyzing the codebase. The final output included more detailed code, more comments, additional features like "Best of 17 days" records, and more comprehensive test coverage.

The creator noted that while the code quality gap wasn't as dramatic as in the first two tasks, MiniMax M3's code was still superior in terms of maintainability.

Who Is MiniMax M3 For? Strengths, Weaknesses, and Use Cases

After three rounds of coding benchmarks, MiniMax M3's positioning is crystal clear.

Core Strengths

• Disruptive pricing — 765x more tokens than Claude Opus for the same budget
• High code quality — automatically generates test cases, comments, and clean project structure
• Million-token context window — ideal for large codebase analysis and comprehension
• Strong self-review capabilities — proactively identifies and fixes code issues
• Open weights — downloadable and fine-tunable with maximum flexibility

Main Weaknesses

• Noticeably slower — complex tasks may take 15+ minutes
• Not the absolute best coding model currently available
• Tendency to over-engineer — may generate excessive code even for simple tasks

Recommended Use Cases

• Cost-sensitive individual developers and small teams
• AI Agent tasks requiring long autonomous operation. This reflects an important industry trend from "conversational assistants" to "Autonomous Agents" — traditional AI coding assistants require developers to issue step-by-step instructions, while AI Agents can autonomously plan tasks, execute operations, verify results, and iterate on fixes. Achieving long-running autonomous operation requires solving multiple technical challenges including context management (avoiding loss of critical information in long conversations) and error recovery (self-diagnosing and fixing when encountering exceptions). The million-token context window enables the Agent to maintain awareness of the full task picture throughout its entire run.
• Large codebase analysis and refactoring
• Projects with high requirements for code quality and test coverage

As the creator summarized: "This isn't the best model out there right now, but for over 90% of tasks, you'll get more value from it because it's so much cheaper, and it still gets the job done well."

In the landscape of AI coding tool selection, cost-effectiveness is becoming an increasingly important dimension. MiniMax M3 has demonstrated through real-world performance that "good enough and extremely cheap" may be more suitable for most developers' daily needs than "the best but expensive."