From an empty folder to eleven live apps

1. The brief — two briefs, weeks apart

The repo did not start as a bake-off. It started as an empty folder and a request to learn Cursor.

please work in the folder <local-repo>

The original prompt named a machine-local directory. That path is redacted here.

Then: “walk me through the best practices of starting a Cursor coding project.” The agent interpreted that as onboarding, not as “build a product.” That interpretation was correct. The user never named an app that night. The agent offered to write .gitignore and AGENTS.md and never did it in that chat.

Seven days later the real product brief arrived in a different chat titled “Token-heavy Cursor projects”:

Please suggest a list of token-heavy projects that showcase Cursor coding abilities and distinguish Cursor from Codex and Claude. Ask me if questions

Silent interpretation that shaped everything after:

• “Token-heavy” meant many files, engines, and a browser-verify loop — not a chatbot wrapper.
• “Distinguish Cursor from Codex and Claude” meant the IDE loop (see the broken control, fix that file, keep the rest coherent), not first-draft volume.
• “Ask me if questions” was later revoked by “i will be off and cannot answer further questions” and “will you be able to complete 3-10 autonomously.”

The user then froze two house rules that the first chat never mentioned: customer-facing docs are HTML; internal specs may be Markdown. That rule is why this journey is HTML and why token-heavy-projects.html exists instead of a README essay.

2. Evidence and reconstruction — this is not one live session

The dev-journey skill says write from the live transcript, and mark reconstruction when the session is past. This document covers three chats plus one aborted starter, then git history. Context in the long bake-off chat was already summarized once before this file was requested. Silent reconstruction would be a lie.

Rule learned: the session transcript is perishable. This file exists because the user asked whether a journey doc already existed, heard no, and then invoked the skill. The skill also says to offer a journey doc at the natural end of a substantial build. That offer was never made after Mini Linear, after projects 3–10, or after query-studio Session C.

3. Cold start — empty folder, then a week of silence

Environment at minute zero, Aug 31 2026: native Windows, Git 2.55, local cursor_origin folder empty, no remotes, no Origin CLI on PATH. The first move_agent_to_root aborted. Retry bound the chat. The empty-window copy of the same prompt died with "User aborted request".

What the agent reused instead of inventing: Cursor skills origin, new-repo, create-rule, update-cursor-settings, plus four background cursor-guide subagents. Official docs beat forum folklore except when the UI did not match the docs (no chevron next to the terminal +).

The only file edit that night was Cursor user settings: default terminal profile PowerShell → Git Bash at C:\Program Files\Git\bin\bash.exe. The user ran git init themselves. The agent said “Don’t add a remote yet.”

Commit 3e58d97 on 2026-08-31 added .gitignore and a short AGENTS.md. That commit is not in the onboarding transcript. Someone — user or a later unlogged action — finished the bootstrap the agent only described. Between Aug 31 11:21 PM and Sep 7 6:33 AM there is no agent transcript for this repo. That gap is a finding: the “entire project since the very first prompt” is not one continuous agent run.

Sep 7 opened in Plan mode. The agent tried to write HTML and could not. SwitchMode to Agent was rejected twice. Verbatim: “Plan mode can only edit Markdown. I tried to switch to Agent… that switch was rejected.” The user had to click Agent mode. The agent spawned cursor-guide b5f55cb7 to answer “how do i switch to Agent mode.” Human-in-the-loop, before any app existed.

4. Design decisions — options considered, losers named

Hub repo, not one-app repo

First instinct was a repo named for Mini Linear. The user overrode it: “we will have multiple sub-project folders in ./cursor_origin/. so use az9713/cursor-origin (match this folder).” Rejected: nested apps inside mini-linear/, overwriting hub index.html, or a new GitHub repo per app.

Rule learned: the folder name is the GitHub name; the hub is a directory, not an app.

Customer docs are HTML

User, Sep 7 6:38 AM: “please commit to your memory that html docs are preferred for customer-facing docs. for internal docs, md are fine.” Written into AGENTS.md, user-level AGENTS.md, and .cursor/rules/docs-format.mdc. Rejected: shipping the briefing as Markdown; this journey as DEVELOPMENT-JOURNEY.md.

No new dependencies

Standing rule: ask before adding dependencies. Combined with GitHub Pages + Origin, that killed backends, auth, paid APIs, Docker, native apps, and “import a huge real repo.” Every app is vanilla HTML/CSS/JS. Rejected for shader-studio: three.js. Rejected for page-clone: cloning a third-party site. The page-clone worker prompt said “Do NOT clone a real third-party website.”

Visual language

IBM Plex Sans / Mono, Fraunces headings, paper #f3eee4 / #ebe4d6, rust #b4451a, dark chrome #2a251f / #241f1a. Chosen so eleven apps look like one studio, not eleven demos. Rejected: Tailwind, component libraries, per-app fashion.

Frozen SPEC before Agent

Bake-off protocol in token-heavy-projects.html:

1. Freeze SPEC.md + AGENTS.md before implementation.
2. Session A: implement to demoable.
3. Session B: polish only from browser-repro bugs. No spec changes.
4. Session C: one cross-cutting feature or refactor. Prove old flows in the browser.

Quote from the briefing: “Codex and Claude can do session A. Cursor is supposed to still be coherent after session C.” That sentence is the product thesis. Everything else is evidence for or against it.

GitHub first, Origin second, two remotes forever

Options: Origin-only (CLI unsupported on native Windows), GitHub-only (loses the Cursor-hosted copy), or dual remotes. Chosen: GitHub remote name origin → https://github.com/az9713/cursor-origin.git. Cursor Origin remote name cursor → https://origin.cursor.com/az9713/cursor-origin.git. Do not replace origin with Origin. After any git push -u cursor, restore git branch -u origin/main. Prefer git push cursor main without -u.

Sep 9 1:26 PM the user made this a standing order: “from now on till revoked, commit and push means both.”

localStorage keys are versioned per app

spreadsheet-v2 after the demo seed changed. query-studio-v1, vector-editor-v1, desktop-os-v1, simulation-v1, saas-shell-v1, page-clone-v1, compiler-v1. Rejected: one shared key. Near-miss: Mini Linear messy and clean still share storage. That was noticed and left.

Descoped on purpose

Never built: backends, OR in SQL, subqueries, CTEs, LEFT JOIN, writes, paid APIs, Wave 2 items 12–19. Wave 2 canvas recommended query-studio/ first; the rest stayed a table. Mini Linear HTML5 drag was never proven in automation. Those absences are choices, not forgotten work — except Wave 2 after query-studio, which is simply not started.

5. The coherence problem — still green after Session C

The session’s actual crux is not “can an agent emit files.” Codex and Claude can emit files. The crux is: after a messy Session A, a polish Session B, and a cross-cutting Session C, do the original demo flows still work when a human clicks them?

Mini Linear tested that as messy → 7-file collapse, then a later restore of the messy tree beside the clean app because the user said “do not delete any file.” Query studio tested it as JOIN seed → browser-repro polish → GROUP BY / HAVING, with the seed still required to return 7 rows and Chris Patel / Payments / 155000 first.

The agentic claim is narrower than “built 11 apps.” The claim is: a parent agent can freeze a spec, fan out work, audit the wreckage, reproduce bugs in a real browser, and refuse to treat a screenshot as done. The wreckage is part of the claim. Two of eight parallel builders shipped incomplete apps. The parent had to finish them. That is orchestration, not magic.

6. Tools and features used

7. Subagents and orchestration — yes, and the log is incomplete

Yes. Subagents were used in four waves. The parent kept user-facing speech. Workers researched, built, or audited. The parent merged results, sometimes ignored them, and sometimes had to finish the job.

How orchestration actually worked

1. Docs first. Background cursor-guide workers. Parent keeps talking. System inserts “Perform any necessary follow-up actions in response to the subagent completion above.” Parent folds the answer in.
2. Human gate. “confirm before execute” for projects 3–10. The parent asked. The user said go — twice, because the message was sent twice.
3. Parallel fan-out. Eight builders launched around Sep 7 8:50–9:04 AM. Their Task calls are not in the parent JSONL. The files on disk and the subagent transcripts prove they ran. At 9:36 the parent said folders already existed and audited instead of building from scratch. Reconstructed: the fan-out happened just before or as the “go” landed, and the parent transcript lost the Task payloads. That is a process wart. Autonomy started before the human’s last check was fully digested.
4. Audit the wreckage. Explicit explore Task e6463511: 6/8 complete, saas-shell missing js/app.js, knowledge-graph missing the UI. Parent wrote the missing files in the main thread.
5. Hunt, then reproduce, then fix. Query-studio Session B: explore b6940cf3 listed 16 bugs. Parent reproduced the serious ones in the browser. Fixed only those. Spec stayed frozen.
6. Do the hard Session C inline. GROUP BY / HAVING was parent work, not a builder. Regression proof was browser + selfCheck.
7. Mine the past to write this. Three explore workers in parallel: earliest chats, main bake-off, subagent folder.

Rule learned: a builder that dies after writing CSS is not a finished app. Audit is not optional when you fan out.

Wave 0 — Cursor onboarding (Aug 31)

Wave 1 — bake-off helpers and builders (Sep 7)

Wave 2 — query studio and this document (Sep 9)

Standalone folders named with those UUIDs under agent-transcripts/ are duplicates of the subagent copies, not second reviews.

8. How each project was designed and built

Project 1 — mini-linear/

Designed as the bake-off prototype: Session A messy (60–100 files), Session C collapse to tokens + one state + one router. Session B was browser polish in between. The generator _gen_messy.py wrote duplicated CSS, per-issue seed files, copy-pasted cards. That was intentional token burn, not incompetence.

Problems: create-issue save button used ml-new-save in one tree and ml-modal-save in another. Layout needed #ml-main flex. HTML5 drag was hard to confirm in automation and still is. After the clean refactor, the user said do not delete files. Session A came back as messy.html via _add_session_a.py with a PROTECT list so Session C files were not overwritten. Hub card 1b points at the messy tree.

Subagents: none for the build. Parent did it. Verification: http://localhost:8080/mini-linear/ board, list, search, create, hash filters. Pages: live Mini Linear.

Project 2 — spreadsheet/

Designed after the user asked whether Project 1 had outstanding issues, then “proceed to project 2 Spreadsheet with real formula engine.” Parent built it inline. Engine: SUM, AVERAGE, IF, refs, cycles, fill handle, undo, CSV. Grid A–Z × 40.

User wrote “SUM VAG.” Treated as AVERAGE. Demo column added so every formula had a labeled example. ArrowLeft bug found in browser: SS.select(a.col, a.row - 1) moved up instead of left. Fixed to SS.select(a.col - 1, a.row). Storage bumped to spreadsheet-v2 after the demo seed changed so old localStorage would not hide the new examples.

Subagents: none. Verification: D7 = 20.8, cycle shows #CYCLE!, undo works.

Projects 3–10 — parallel builders, then a parent rescue

User: “will you be able to complete 3-10 autonomously without me in the loop ? confirm before execute.” Then: “go and push to both Github and Origin.” Eight workers got the same constraints: sibling folder, vanilla stack, frozen SPEC, IBM Plex paper/rust, no third-party page clone, no three.js.

• 3 vector-editor. Artboard 800×560, V/R/O/draw, layers, 8px snap, undo, SVG export. Worker fixed a double history snapshot after draw finish.
• 4 desktop-os. Window manager, taskbar+clock, Notes, Finder, Terminal, fake VFS, desktop-os-v1.
• 5 compiler. Toy language Oak: lex → parse → bytecode VM → Run/Step/Reset. Sample prints 0–4. Temp _test.js deleted after verify.
• 6 page-clone. Original “Harbor Ledger” marketing page plus inspector. Reset-after-reload was wrong until originals were captured before overrides.
• 7 simulation. Seeded city, ants, pheromones, sliders, chart. Files landed; browser verify connection-failed.
• 8 saas-shell. Incident Commander, hash routes, eight views. Worker wrote SPEC, tokens, HTML, state, router, a large app.css, then died. IC.render did not exist.
• 9 shader-studio. Raw WebGL2, five presets (Plasma, Rust Noise, Voronoi, Ripple, Gradient Ray). Verify connection-failed.
• 10 knowledge-graph. Worker generated ~350-node data.js and died. Parent wrote index.html, layout.js, app.js, css/app.css. Browser check: search updates hash #?q=Turing. Shipped count in the parent report: 350 nodes / 817 edges.

Commit 06100bf — “Add spreadsheet and projects 3–10 so the hub covers the full stress-test set.” 72 files, +11043 / −6.

Wave 2 proposal, then Project 11 — query-studio/

Sep 9 the machine had shut down. User: “please continue. the machine shut down and we were cut off.” The next ask was agentic projects, not more token volume. Parent drew a canvas of Wave 2 candidates and recommended query-studio: text SQL and visual builder as two views of one AST.

Session A (commit 2ed87ce): lexer, parser, nested-loop join engine, builder, presets, hash #/p/<id> / #/s/<id>, storage query-studio-v1. Language: SELECT / FROM / one INNER JOIN / WHERE AND-chain / ORDER BY / LIMIT. != pretty-prints as <>. Seed: employees ⋈ departments, salary >= 80000, ORDER BY e.salary DESC, LIMIT 10 → 7 rows, Chris Patel first. Bad SQL during build: “Line 1:17 — Expected IDENT, got EOF.”

Session B (commit c0546a9): hunt pass b6940cf3, then parent browser repro. Proven and fixed:

• Unchecking * snapped back to SELECT * because astFromBuilder() fell back to star. Now expands to explicit columns.
• Parse error left the old result grid. Now “Fix the SQL to run.” and the table clears.
• LIMIT -1 used Array.slice and dropped a row (8→7). Now rejected: “LIMIT must be a non-negative integer.”
• Ambiguous id was labeled a parse error and checked both chips. Now a query error; neither chip checked.
• Invalid SQL was persisted; preset-hash edits died on refresh. Boot now keeps hash-matched store SQL when store.hash === location.hash.
• JOIN ON went stale when the table pair changed; aliases flushed late. Reset ON; flush aliases on input / Ctrl+Enter.
• Saved queries could not be renamed; results pane was only 32vh. Rename button; more vertical room. Scripts cache-busted to ?v=2.

Session C (commit 4f09121): GROUP BY, HAVING, COUNT/SUM/AVG/MIN/MAX. Spec grammar grew. Engine order: JOIN → WHERE → group/aggs → HAVING → ORDER → LIMIT. New preset dept-agg “Headcount by department.” Expected 3 rows: Payments/3, Auth/2, Support/2.

Session C bug found in the working tree before commit: QS.renderBuilder called .toLowerCase() on aggregate select items that have no .name. Verbatim: Cannot read properties of undefined (reading 'toLowerCase'). The builder stayed stale while SQL updated. Fix: skip col.type === "agg" in chip match and alias loops. Later polish: ORDER BY dropdown also lists SELECT aliases so ORDER BY n is selectable.

Query-studio Sessions A–C were parent work plus one hunt subagent. No builder wrote the SQL engine.

9. What went wrong, and the fixes

1. Workspace move aborted. First move_agent_to_root failed; empty-window chat aborted. Retry bound cursor_origin.
2. Wrong “No Repo” story. Parent said the sidebar group meant no git remote. Subagent 0b21222e said Cursor 3.11 “No Repo” means chats with no project folder (it replaced Home). User’s “Remove from Sidebar” did not remove it. Workaround: group by Updated/Status; archive. Both explanations may have been partly true. Uncertain.
3. Overstated New Chat advice. Walkthrough said start a new chat on every mode switch. User asked why, if a mode already starts new context. Agent retracted after re-reading docs.
4. Git Bash UI mismatch. Docs assumed a chevron next to +. User: “there is no v next to +.” Command Palette profiles; then agent wrote settings.json.
5. Plan mode blocked the briefing. “Plan mode can only edit Markdown.” Switch rejected twice. User switched. HTML appeared on the second implement pass. User had already said “i do not see any html.”
6. Origin on Windows. Origin CLI is not supported on native Windows. Install went through WSL: curl, HTTP/1.1 tarball from downloads.cursor.com, extract to ~/.local/bin/origin, origin auth login, browser deep link. Push pattern: Windows git push origin main, then WSL git push cursor main from the local repo mount.
7. WSL dirty-tree hallucination. After Origin pushes, WSL git status lists dozens of M mini-linear/** files. Windows git status is clean. CRLF. Do not commit that noise. Windows status is source of truth.
8. Four builders died mid-flight with Connection failed repeatedly, usually during browser/MCP verify. Two of those deaths left incomplete products. Audit + parent rescue.
9. saas-shell: missing js/app.js. IC.render never defined. Parent wrote it (~400 lines) and wired the router.
10. knowledge-graph: dataset without a page. Parent wrote the explorer.
11. Port 8080 went bad during query-studio Session B. Stale tabs, empty replies, two listeners. Fallback 8765, then python -m http.server 8790 --bind 127.0.0.1. CDP tests ran on 8790. Rule learned: probe the port, do not trust “the window is visible.”
12. Spreadsheet ArrowLeft. Off-by-axis select. Browser found it; code reading would have found it too if anyone had read the handler before demoing arrows.
13. Query studio * trap, LIMIT -1, stale grid, ambiguous id, hash vs localStorage. See Session B above. The hunt list had 16 items; medium/low a11y and column-order nits were not all fixed. Session B is “proven bugs,” not “every note in the review.”
14. GROUP BY crashed the builder. toLowerCase on undefined. Fixed before commit 4f09121.
15. Parallel builds started before the user’s last confirmation was logged. Autonomy without a clean handshake. The apps exist; the audit saved the two that did not finish.
16. Machine shutdown Sep 9. Wave 2 canvas and query-studio happened after “please continue.” No crash dump. Continuity was the user’s prompt plus git, not an agent memory file.

10. Verification — observed effects, not clean exits

How “it works” was actually checked:

• Mini Linear: clicked board, list, search, create issue, hash filters on localhost:8080. Drag not proven in automation.
• Spreadsheet: opened demo cells; D7 20.8; cycle #CYCLE!; undo; ArrowLeft after the bugfix.
• Projects 3–7 and 9: builder self-reports plus explore audit “COMPLETE.” Parent did not re-click every control in those six apps after the rescue. That is a verification gap.
• saas-shell: parent smoke — dashboard and incidents showed seed data.
• knowledge-graph: 350 nodes visible; search wrote #?q=Turing.
• Query studio Session A/B/C: node QS.selfCheck(); browser seed 7 rows Chris Patel; Headcount 3 rows; All employees 8 rows; status “ROUNDTRIP OK.” Session C CDP dump (verbatim shape): seed.status "ROUNDTRIP OK\\n7 rows", first row Chris Patel / Payments / 155000; group preset 3 rows.
• GitHub Pages polled after first push. Live hub: az9713.github.io/cursor-origin.
• Dual remotes: after Session C, origin/main, cursor/main, and HEAD all 4f09121.

What was not verified: exhaustive keyboard maps on saas-shell; WebGL2 on machines without it; Mini Linear drag; every Wave 1 preset after later hub edits; this journey page in the browser before the first commit of the file (the write you are reading is the first version).

11. Unknown unknowns — the checklist the brief did not name

Invisible constraints

Active style: paper/rust IBM Plex from the briefing, not from a design-system skill. House rules loaded: repo AGENTS.md, user AGENTS.md (HTML vs Markdown), .cursor/rules/docs-format.mdc, git commit protocol, “ask before dependencies,” “do not delete files,” “work in cwd only,” dual-push after Sep 9. Skills invoked by name: Cursor origin / new-repo, canvas SDK types for Wave 2, dev-journey for this file. No minimalism mode was on; the opposite — token-heavy on purpose.

Human-in-the-loop moments (the work does not reproduce without these)

• User ran git init.
• User switched Plan → Agent so HTML could be written.
• User named the hub repo and forbade deleting Session A.
• User said they would be off; then later asked for a last check; then asked autonomy for 3–10; then said go.
• User authenticated Origin in a browser after WSL origin auth login.
• User continued the chat after a shutdown.
• User defined “commit and push” as both remotes.
• User asked for this journey; the agent had not offered it.

Near-misses

A lagging localhost:8080 tab nearly counted as “query studio is broken” or “query studio is fine” depending on cache. The save was switching ports and confirming with Python urllib, then CDP against 8790.

WSL’s dirty mini-linear tree nearly looked like a real diff. Committing it would have been a CRLF disaster.

The Session B hunt listed 16 bugs. Fixing all of them would have been spec creep and a11y busywork. The protocol said browser-repro only. That restraint is easy to drop when a review looks thorough.

Treating eight parallel builders as “done because folders exist” was the wrong conclusion the audit prevented.

Fragility and luck

GitHub Pages and Origin both depend on the user’s gh auth and WSL Origin credential helper. A future Windows-only agent cannot push Origin without that helper. Script cache-bust query params (?v=2 … ?v=4) are a luck protocol: forget them and the browser lies. In-memory SQL has no backend to hide behind; that made Session C honest and also made every parse edge visible.

Costs and limits

No dollar figure appears in the transcripts. Limits that were hit: Plan mode cannot write HTML; Origin CLI absent on Windows; browser MCP connections failed repeatedly for four builders; chat context was summarized before this journey was written; a machine shutdown cut the Sep 7 thread. Token volume was the point of Wave 1 (commit 06100bf alone is +11k lines). Wave 2 was an explicit turn away from more of that.

Wall-clock that mattered: Aug 31 evening onboarding (~3 hours of UI questions). Sep 7 morning: briefing → Mini Linear → spreadsheet → 3–10 fan-out → audit → push, roughly 6:33 AM to early afternoon, then a 1:27 PM “how is progress ?” after the user had left. Sep 9: Wave 2 + query-studio A/B/C in one calendar day, interrupted by shutdown.

Knowledge captured elsewhere

• AGENTS.md — hub conventions and the app list.
• token-heavy-projects.html — ranked list and bake-off protocol. Its “suggested first pick” footer is stale (still talks as if only Mini Linear is running).
• Per-app SPEC.md — frozen product, not history.
• This file — process, including the stale briefing footer called out.
• No HANDOFF.md was written. Continuity after shutdown was git + the user’s “please continue.”

Unfinished on purpose or by stop

• Codebase Atlas Session B (extract-module, import-rule, real git) — not started.
• Wave 2 items after codebase-atlas (language-workbench, block-editor, calendar-engine, and the rest of the canvas) — not started.
• Mini Linear messy/clean shared localStorage — noticed, not fixed.
• Mini Linear drag — not proven in automation.
• Full a11y pass on query-studio — hunt listed it; Session B skipped most of it.
• Compiler Session C (typechecker + rename) was mentioned as a cheaper alternative to a new Wave 2 app. Not built.
• The briefing HTML “now” line says projects 1–10 shipped and Wave 2 started; it does not say Session C landed. Small staleness.

12. Where things stand

As of Sep 13 2026, main at 4f09121 is on GitHub and Origin. Apps 1–11 are on GitHub Pages. Codebase Atlas (app 17) Session A shipped locally — 373 in-memory files, symbol index, call graph, command palette, rename-across-all-refs.

• Hub: https://az9713.github.io/cursor-origin/
• GitHub: https://github.com/az9713/cursor-origin
• Origin: https://cursor.com/codebase/az9713/cursor-origin
• Query studio: https://az9713.github.io/cursor-origin/query-studio/

What this record actually shows about automatic / agentic development: a parent agent can keep a monorepo coherent across eleven vanilla apps if a human sets the constraints, a spec is frozen, workers can be audited, and “done” means a clicked browser, not a generated folder. It also shows the parent will start workers early, lose Task lines from its own transcript, finish two broken apps by hand, lie once about the sidebar, and forget to offer the journey doc until asked.