📅 Feb 3, 2026 📁 Notes App Task 🏆 Qwen Wins

🏆 Winner: Qwen3-Coder-Next

Despite being over 2x faster, Qwen delivered a more polished, bug-free implementation with better code organization and modern patterns.

📊 Key Metrics

5m 57s
Qwen Completion Time
13m 18s
MiniMax Completion Time
2.2x
Speed Difference
1
Critical Bug (MiniMax)

📈 Score Breakdown

Speed Qwen: 95 | MiniMax: 45
Code Quality Qwen: 85 | MiniMax: 75
Bug-Free Execution Qwen: 100 | MiniMax: 60
Feature Completeness Qwen: 90 | MiniMax: 90
UI/UX Design Qwen: 80 | MiniMax: 85

📁 Code Statistics

Metric MiniMax Qwen3
Backend Lines (app.py) 296 lines 273 lines
Frontend Lines 385 lines (JS) + ~500 (CSS/HTML) 833 lines (single file)
File Organization Separated (templates/, static/css/, static/js/) Single static/index.html
Git Commits 3 commits 1 commit
External Dependencies Flask only Flask + Flask-CORS

🎯 Final Recommendation

Use Qwen3-Coder-Next When: Recommended
  • Speed is critical (2x+ faster)
  • You need reliable, bug-free output
  • Modern patterns like CORS and UUID are needed
  • Proper Flask context management is required
  • You want proper request-scoped DB connections
Use MiniMax When: Consider
  • Better file separation is preferred
  • More polished UI interactions are needed
  • Modal-based editing is desired
  • You can fix minor bugs in generated code
  • Local development without API costs

🔧 Backend Architecture

ID Strategy

🟠 MiniMax Integer Auto-increment
cursor.execute('''
    CREATE TABLE IF NOT EXISTS notes (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        ...
    )
''')

# Usage
note_id = cursor.lastrowid
🔵 Qwen3 UUID Primary Key
import uuid

cursor.execute('''
    CREATE TABLE IF NOT EXISTS notes (
        id TEXT PRIMARY KEY,
        title TEXT NOT NULL,
        ...
    )
''')

# Usage
note_id = str(uuid.uuid4())

Analysis: UUID approach is more production-ready (no sequential enumeration, better for distributed systems). Integer IDs are simpler but expose creation order.

Tag Storage

🟠 MiniMax JSON String
# Storage
tags TEXT DEFAULT '[]'

# Save: json.dumps(tags)
# Load: json.loads(data['tags'])

# Query
'WHERE tags LIKE ?'
f'%"{tag_filter}"%'
🔵 Qwen3 Comma-Separated
# Storage
tags TEXT  # "work,personal,ideas"

# Save: ','.join(tags)
# Load: tag_str.split(',')

# Query
'WHERE tags LIKE ?'
f'%{tag}%'

Analysis: Both approaches have trade-offs. JSON is more structured but heavier. Comma-separated is simpler but can have edge cases with tags containing commas.

Database Connection Management

🟠 MiniMax Per-call connections
def get_db():
    """Get database connection."""
    conn = sqlite3.connect(DATABASE)
    conn.row_factory = sqlite3.Row
    return conn

# Each endpoint:
conn = get_db()
cursor = conn.cursor()
# ... do work ...
conn.close()  # Manual close
🔵 Qwen3 Flask g context
def get_db():
    """Request-scoped connection."""
    if 'db' not in g:
        g.db = sqlite3.connect(DATABASE)
        g.db.row_factory = sqlite3.Row
        g.db.execute('PRAGMA foreign_keys = ON')
    return g.db

@app.teardown_appcontext
def close_db(error):
    db = g.pop('db', None)
    if db is not None:
        db.close()

Analysis: Qwen's approach is the Flask-recommended pattern. Request-scoped connections prevent resource leaks and are more efficient. Also enables PRAGMA settings.

CORS and Security

🟠 MiniMax No CORS
from flask import Flask, request, jsonify

app = Flask(__name__, 
            static_folder='static',
            static_url_path='/static')

# No CORS configuration
# Works for same-origin only
🔵 Qwen3 Flask-CORS
from flask import Flask, request, jsonify, g
from flask_cors import CORS

app = Flask(__name__, 
            static_folder='static', 
            static_url_path='')
CORS(app)  # Enable CORS for all routes

# Allows cross-origin API access

🎨 Frontend Architecture

File Structure

🟠 MiniMax Structure
model-test-minimax/
├── app.py
├── notes.db
├── templates/
│   └── index.html
└── static/
    ├── css/
    │   └── style.css (500+ lines)
    └── js/
        └── app.js (385 lines)
🔵 Qwen3 Structure
model-test-qwen/
├── app.py
├── notes.db
├── requirements.txt
└── static/
    └── index.html (833 lines)
        ├── <style> (inline CSS)
        └── <script> (inline JS)

Analysis: MiniMax has better separation of concerns (separate CSS/JS files). Qwen's single-file approach is simpler to deploy but harder to maintain for larger apps.

UI Interaction Pattern

MiniMax: Modal-Based MiniMax
  • Click "New Note" → Opens centered modal
  • Edit button → Same modal with populated data
  • Overlay dims background
  • More familiar desktop UX pattern
  • Keyboard shortcut: Ctrl+N opens modal
Qwen3: Sidebar Form Qwen
  • Always-visible form in left sidebar
  • Edit populates sidebar (scrolls to top)
  • No overlay - notes always visible
  • More efficient for rapid note-taking
  • Keyboard shortcut: Ctrl+N focuses form

🐛 Critical Bug Found

🚨 MiniMax: Undefined Function Bug MiniMax

The MiniMax implementation has a critical bug that causes a 500 error on the index route:

Bug Location app.py:59
# Line 10: Imports send_from_directory
from flask import Flask, request, jsonify, send_from_directory

# Line 59: Uses non-existent send_from_static_files
@app.route('/')
def index():
    """Serve the main HTML page."""
    return send_from_static_files('.', 'index.html')  # ❌ BUG!
✅ The Fix
Corrected Code
@app.route('/')
def index():
    """Serve the main HTML page."""
    # Option 1: Use send_from_directory
    return send_from_directory('templates', 'index.html')
    
    # Option 2: Use render_template (if using Jinja)
    # return render_template('index.html')

Production Readiness Checklist

MiniMax 6/10
  • Works out of box (has critical bug)
  • Input validation on title
  • Error handling with try/except
  • DB connections (manual close)
  • CORS support (not included)
  • XSS protection (escapeHtml)
  • Responsive design
  • Loading states
Qwen3 9/10
  • Works out of box (no bugs)
  • Input validation on title
  • Error handling with try/except
  • DB connections (Flask g context)
  • CORS support (Flask-CORS)
  • XSS protection (escapeHtml)
  • Responsive design
  • Loading states

📝 Best Practices Comparison

Practice MiniMax Qwen3
Docstrings ✓ All functions documented ✓ All functions documented
Type Hints ✗ None ✗ None
Error Messages ✓ Descriptive JSON errors ✓ Descriptive JSON errors
HTTP Status Codes ✓ Proper (201, 400, 404, 500) ✓ Proper (201, 400, 404, 500)
SQL Injection Protection ✓ Parameterized queries ✓ Parameterized queries
Request Context Management ⚠ Manual connection handling ✓ Flask g + teardown
requirements.txt ✗ Missing ✓ Included
README.md ✓ Comprehensive ✓ Comprehensive

🖥️ Application Screenshots

To view live demos, start both applications:

Start Commands
# Terminal 1 - MiniMax (port 5001)
cd ~/openclaw-brain/projects/model-test-minimax
python3 app.py

# Terminal 2 - Qwen3 (port 5002)  
cd ~/openclaw-brain/projects/model-test-qwen
python3 app.py
MiniMax Notes App Port 5001
🟠

http://localhost:5001

⚠️ Note: Returns 500 error due to bug

Qwen3 Notes App Port 5002
🔵

http://localhost:5002

✓ Works correctly

🎨 Visual Design Comparison

Aspect MiniMax Qwen3
Color Scheme Blue primary (#4a6fa5), Light background Indigo primary (#4f46e5), Light gray background
Typography System fonts, clean hierarchy System fonts, clean hierarchy
Card Design Rounded corners (16px), subtle shadows Rounded corners (12px), minimal shadows
Layout Grid-based notes, sticky header Two-column (sidebar + grid), sticky header
Animations Modal slide-in, hover transforms Toast slide-in, hover shadows
Empty State Emoji icon + CTA button Text message + link

🔄 Interaction Patterns

MiniMax: Modal Pattern

Pros

  • Focused editing experience
  • Clear visual separation
  • Familiar desktop pattern
  • Better for complex forms

Cons

  • Extra click to start creating
  • Can't see notes while editing
  • More code to manage modal state
Qwen3: Sidebar Pattern

Pros

  • Always ready for input
  • Can reference notes while writing
  • Faster for rapid entry
  • Simpler state management

Cons

  • Takes up screen real estate
  • Less focused experience
  • May feel cluttered on mobile

📱 Responsive Design

Breakpoint MiniMax Qwen3
Desktop (≥1200px) Multi-column grid, sticky header 2-column layout (350px sidebar + grid)
Tablet (≥768px) 2-column grid, modal adjusts Single column, form above notes
Mobile (<768px) Single column, actions always visible Single column, form at top
Touch Targets ✓ Adequate (32px+ buttons) ✓ Adequate (touch-friendly)

🔌 API Endpoints

Endpoint MiniMax Qwen3
GET / ✗ Returns 500 (bug) ✓ Serves index.html
GET /api/notes ✓ List all notes ✓ List all notes
POST /api/notes ✓ Create note ✓ Create note
GET /api/notes/:id ✓ Get single note ✓ Get single note
PUT /api/notes/:id ✓ Update note ✓ Update note
DELETE /api/notes/:id ✓ Delete note ✓ Delete note
GET /api/tags ✓ List unique tags ✓ List unique tags
Tag Filter (query param) ?tag=work ?tag=work
Search (query param) ?q=search ?search=term

🎯 Frontend Features

Feature MiniMax Qwen3
Create Notes
Edit Notes
Delete Notes ✓ (with confirmation) ✓ (with confirmation)
Tag Support
Tag Filter Dropdown
Search ✓ (debounced) ✓ (debounced)
Toast Notifications
Loading States ✓ (spinner) ✓ (text)
Empty State ✓ (with CTA)
Note Timestamps ✓ (created + updated) ✓ (created + updated)
Clickable Tag Links

⌨️ Keyboard Shortcuts

Shortcut MiniMax Qwen3
Ctrl + N ✓ Open new note modal ✓ Focus title input
Ctrl + F ✓ Focus search (documented) ✗ Not implemented
Escape ✓ Close modal ✓ Reset form

🔍 Search & Filter Capabilities

MiniMax Search MiniMax
  • Client-side filtering after initial load
  • Searches title and content
  • 300ms debounce on input
  • Tag filter via dropdown
  • Server-side tag filtering with ?tag=
  • Server-side search with ?q=
Qwen3 Search Qwen
  • Client-side filtering after initial load
  • Searches title and content
  • 300ms debounce on input
  • Tag filter via dropdown
  • Server-side tag filtering with ?tag=
  • Server-side search with ?search=

📊 Summary Matrix

Category MiniMax Qwen3 Winner
Speed 13m 18s 5m 57s Qwen 🏆
Bug-Free ✗ Critical bug ✓ Works perfectly Qwen 🏆
File Organization Separated files Single file MiniMax 🏆
DB Patterns Manual connections Flask g context Qwen 🏆
CORS Support ✗ None ✓ Flask-CORS Qwen 🏆
UI Polish More polished CSS Clean & functional MiniMax 🏆
UX Pattern Modal-based Sidebar form Tie
Overall 6/10 9/10 Qwen 🏆