Token-heavy projects that stress Cursor

What to actually stress

Codex and Claude Code are strong at generating a pile of files in a sandbox. They are weaker at a tight IDE loop: see the diff, run the app, click the broken control, fix that file, keep the rest consistent, repeat.

Build projects that require these Cursor surfaces:

Plan → Agent → browser → fix

A screenshot is not verification. Click through the broken control.

Rules and AGENTS.md

Later edits must not drift off the original design system.

Multi-file consistency

Design tokens, shared state, one bug that spans eight files.

Parallel subagents

Explore vs implement vs review in the same session.

MCP only for a real loop

GitHub issues or live data. Ask before new dependencies.

Checkpoints and Origin

Rewind a long session that went off the rails, then push when it works. Origin CLI is macOS, Linux, or WSL. Native Windows is not supported yet.

Spec + AGENTS.md → Plan mode → Agent edits → Browser click-through → Origin + Pages

Broken in the browser → back to the agent. Optional MCP feeds the agent. Stable UI → publish.

Ranked list (this order)

Messy 60–100 file product, then architectural refactor

What: Generate a working but ugly mini Linear: issues, board, filters, localStorage, duplicated CSS, copy-pasted components. A second long session refactors to tokens, one state module, and one router without breaking drag, filters, or deep links.
Why token-heavy: Two full products in one repo. Every refactor pass re-reads the graph.
Why Cursor wins: CLI agents dump a refactor and hope. Cursor has to keep the live board working while files move. Browser click-through after every slice is the point.
Origin shape: index.html + js/ + css/. GitHub Pages embed in README.

Spreadsheet with a real formula engine

What: Vanilla JS grid, selection, fill handle, SUM / IF / AVERAGE, cell refs, cycles, undo, CSV import/export.
Why token-heavy: Hundreds of edge cases: circular refs, parse errors, copy-paste, keyboard nav. Tests plus UI polish.
Why Cursor wins: You type in cells and watch it lie. The agent has to reproduce the bug in-browser, not from a stack trace.
Origin shape: Single-page app, no backend.

Vector editor (Figma-lite, one artboard)

What: Select, move, resize, layers, groups, stacking, snap, undo, SVG export, keyboard shortcuts.
Why token-heavy: Hit-testing, handles, zoom/pan, selection model.
Why Cursor wins: Visual tools are screenshot-plus-click work. CLI models cannot see that the resize handle is 4px off.

In-browser desktop OS

What: Window manager, taskbar, three real apps (notes, finder, fake-VFS terminal), persistence, z-index, focus, minimize.
Why token-heavy: Cross-app state, many CSS files, accessibility, mobile vs desktop.
Why Cursor wins: Every session is a clipped window, a focus trap, a dock overlap.

Compiler playground (invented language)

What: Lexer, parser, AST viewer, bytecode VM, stepper, error squiggles, docs generated from the grammar.
Why token-heavy: Many files, golden tests, a UI for each compiler stage.
Why Cursor wins: Change a token and the parser, VM, and docs all have to update.

Pixel-clone, then instrument a complex public page

What: Recreate a dense marketing or docs page, then add a live inspector: click a node, edit copy or color, persist in localStorage.
Why token-heavy: CSS archaeology plus a second app sitting on top.
Why Cursor wins: Clone quality is a visual loop. Cursor can iterate until breakpoints match.
Constraint: Ask before clone-site tooling. Prefer hand-built CSS.

City, traffic, or ant simulation with a control panel

What: Canvas or SVG agents, charts of population or flow, sliders, seed replay, pause/step.
Why token-heavy: Tuning loops burn tokens for hours with almost no new deps.
Why Cursor wins: The agent has to run the sim in the browser, not eyeball the update function.

Design-system SaaS shell (one workflow, many pages)

What: A real 6–8 view app (hiring pipeline or incident commander), shared tokens, empty/error/loading states, keyboard shortcuts.
Why token-heavy: Consistency tax unless AGENTS.md and rules are enforced across files.
Why Cursor wins: Rules, file mentions, and repo-wide search.

Shader / WebGL studio

What: Live GLSL editor, uniforms, presets, error overlay, thumbnail gallery of shaders the agent authors.
Why token-heavy: Compile errors plus visual iteration. Many shader files.
Why Cursor wins: GPU output is ground truth. Default is raw WebGL2, no deps.

Knowledge-graph explorer of a generated corpus

What: 200–500 nodes, layout, search, filters, detail panel, URL state.
Why token-heavy: Dataset generation, layout bugs, interaction polish.
Why Cursor wins: Wire Canvas or MCP later and it becomes Cursor-only.

Explicitly skip

These fight this workspace: Origin, GitHub Pages, and “ask before adding dependencies.”

Backends, auth, or paid APIs
ChatGPT clones and generic landing pages
Native apps, Docker, or Python GUIs
Huge real-world repo imports

How to run the bake-off so it is fair

Write a frozen spec in the repo (SPEC.md + AGENTS.md) before Agent starts.
Session A: implement to demoable.
Session B: polish only from browser-repro bugs. No spec changes.
Session C (the Cursor tell): refactor or add a cross-cutting feature and prove old flows still work in the browser.
Publish: README with a live GitHub Pages iframe; push az9713/ and Origin when WSL or Origin CLI is available.

Codex and Claude can do session A. Cursor is supposed to still be coherent after session C.

Suggested first pick

This repo is running #1 (messy product → refactor). Spreadsheet and vector editor are later, not nested in this pass.

Windows / Origin

This machine is native Windows. Origin CLI install is not supported outside WSL. Plan GitHub Pages first. Push to Origin from WSL (or a Mac/Linux agent) when you want origin.cursor.com.