I Built the Same App With MiniMax M3 and Composer

Product Reviewed

Miniax M3 — described as a newly released Chinese open-weight, multimodal model—was tested primarily for coding tasks and compared against Composer 2.5 (the creator’s daily coding model) inside Cursor.

---

Main Features Mentioned

• Open weights
  • Weights are downloadable and can be fine-tuned.
  • Contrasted with closed models (e.g., Anthropic/GPT).
• Context window
  • Up to 1,000,000 tokens
  • Guaranteed minimum: 512,000 tokens
  • May shrink depending on usage.
• Multimodal native support
  • Can handle image/video + text generation “natively” (not bolted on).
• Tool calling
  • Emphasized as strong.
• Tool-using autonomy demonstration
  • Example where it ran 12 hours autonomously with many tool calls before giving up.
• Release date
  • Stated as June 1st.
• Coding focus
  • Claimed “very good coding performance” relative to price.

---

Pricing / Value (Key Numerical Comparisons)

• Miniax plan
  • $20/month ≈ 1.7B tokens
• Claude comparisons at ~$20:
  • Claude HighQ: ~11.1M tokens
  • Claude Sonnet 4.6: ~3.7M tokens
  • Claude Opus 4.8: ~2.2M tokens
• Stated multiple
  • About 765× more tokens than Opus for the same $20
  • (Creator’s calculation; notes Claude subscriptions may yield slightly more.)
• Creator’s framing
  • Miniax isn’t positioned as “best overall,” but is so cheap that it’s rational for many coding workflows and tool/agent setups (e.g., “open claw or Hermes agent” mentioned indirectly).

---

Setup / User Experience (Cursor Integration)

Tested inside Cursor using Miniax’s API:

• Use a subscription key
• Override the OpenAI base URL to point to Miniax
• Add a custom model named “Miniax-M3”
• Verify by switching the agent model and running a “hello world” prompt

Claim (creator’s opinion): Cursor is best for raw coding tasks due to its coding harness.

---

Coding Task Results (Miniax vs Composer 2.5)

Task 1: URL shortener web app (single project, no Next/No.js)

Goal

• Implement an app with an endpoint + dashboard + styling.

Quality / Output

• Both models produced working apps with similar core functionality:
  • Redirect behavior worked
  • Click counting worked
  • Dark/light mode mentioned
  • Miniax included path validation
• Code organization
  • Miniax:
    • 21 files
    • Clean separation (config, DB, routes, redirect/service/utils)
    • Included full test coverage
  • Composer:
    • 7 files
    • Code more “jammed” into fewer files
    • Fewer/no tests
    • Less validation/verification

Speed

• Composer: ~2 minutes
• Miniax: ~15 minutes
• Creator states Miniax ran ~5–6× longer
• Explanation: Miniax did more self-critical iteration, deeper tool use, and tested by running tools/Browser actions; it drafted code and then revised.

Pros noted (Miniax)

• Better structure
• More comprehensive tests/validation
• More robust than “bare minimum”

Cons noted (Miniax)

• Much slower execution time

---

Task 2: Rust ray tracer

Goal

• Render spheres, a checkered ground, and output dependency-free images to PNG/PPM.

Result / Visual Accuracy

• Composer output (left):
  • Initially described as upside down
  • After flipping, still had issues:
    • Reflections/scene behavior incorrect
    • Checker orientation inconsistencies
    • Missing/incorrect reflection of a yellow ball
• Miniax output (right):
  • Better orientation
  • More accurate/dimensional rendering
  • Still not perfect (some elements cut off), but overall higher quality

Speed

• Miniax described as ~3–4× slower (same pattern as Task 1).

Interpretation

• Creator suggests Miniax is architected for longer-running, deeper analysis tasks that leverage large context.

---

Task 3: Large “refactor-like” addition to a complex codebase

Prompt goal

• Add a daily streak feature to a student dashboard:
  • Track consecutive days each student completed at least one DSA question
  • Add backend endpoints + UI + services
  • Modify and integrate across a complex multi-component app

Speed

• Composer finished first.
• Miniax was still analyzing when Composer completed (Miniax took longer).

Quality

• No dramatic overall quality gap, but:
  • Miniax:
    • Wrote more detailed code and more comments
    • Added more than one test (creator notes the streak change itself had only one test in Miniax, but Miniax still added more maintainable coverage overall)
  • Composer:
    • Mainly added the new UI component
    • Fewer observed changes beyond the streak UI
• Functionality: both were reported as working when loaded/tested.
• Miniax UI showed “best of 17 days” (possibly absent in Composer’s run).

Speed vs depth takeaway

• Miniax spent more time in analysis/tool calls; Composer was faster and more minimal.

---

Pros / Cons (As Concluded by the Creator)

Pros (Miniax M3)

• Exceptional price/token value (major selling point)
• Very capable coding performance
• Stronger output quality in many cases:
  • structure, validation, tests, deeper iteration
• Tool-calling strength
• Handles long-context and long-running tasks better (per creator interpretation)
• Runs within Cursor relatively straightforwardly (base URL + API key override)

Cons (Miniax M3)

• Not the fastest model (often several times slower than Composer)
• Sometimes produces more code than necessary; slower iteration can delay results
• Not always perfect (e.g., ray tracing still had issues)

---

Comparisons Made

• Miniax M3 vs Composer 2.5
  • Composer: faster, more minimal outputs, fewer tests/less validation
  • Miniax: slower, more thorough structure/testing, better correctness in some tasks (notably Rust ray tracing)
• Miniax pricing vs Anthropic (Claude HighQ/Sonnet/Opus)
  • Framed as dramatically more cost-effective due to token count

---

Overall Verdict / Recommendation (Creator’s Conclusion)

• Recommended for most coding tasks (90%+), especially when cost matters
  • The creator argues Miniax’s price/value beats faster-but-expensive options for most workloads.
• Not always best for speed
  • Composer may be better when you need quick scaffolding or minimal acceptable output.
• Bottom line: Miniax M3 is a very capable model with exceptional value, worth using in Cursor for many coding scenarios.

---

Unique Points Mentioned (Consolidated List)

• Open weights; downloadable weights; fine-tuning possible
• Native multimodal (image/video) support
• Context: min 512k, max 1M tokens
• Strong tool calling; autonomy example (12 hours)
• Released June 1st
• Token pricing: $20 → 1.7B tokens
• Claude comparisons and ~765× token-value vs Opus (as stated)
• Cursor setup: override base URL + subscription key + custom model “Miniax-M3”
• Task outcomes:
  • URL shortener: Miniax better structure + tests + validation; slower (15 min vs 2 min)
  • Rust ray tracer: Miniax higher rendering accuracy; slower (3–4×)
  • Existing codebase feature: Miniax deeper analysis and more detailed code/comments; slower; both functioned

---

Speaker Views / Roles

• Single primary speaker (creator/tester): all evaluations, benchmarks, setup instructions, and conclusions come from one viewpoint. No additional speakers’ perspectives were provided in the subtitles.