Video summary

I Built the Same App With MiniMax M3 and Composer

Main summary

Key takeaways

Product Review

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.

Original video