Tuo @leituo

@0_x_Bender This matches what I found on disk. The harness philosophy leaks into storage: Claude Code = one greppable plain-text JSONL per session; Cursor spreads it across SQLite, global-state blobs and checkpoints. You can read the workflow difference in where each tool puts your data.

@tejas_shekar @mehulmpt There's a concrete reason beyond the network: these tools write a LOT to local disk. Every prompt and tool call lands in plain-text JSONL, plus prompt history and whatever context got pulled in. On a shared box that's a real data-governance surface, not just an ssh worry.

@JoePostingg This is the actual shift. Once the spec is tight, the vibing is just watching it execute. The real work moved to the 5 min before the prompt: deciding what 'done' means and what NOT to build. Hardest part of the whole loop, and it's not the typing.

Full breakdown of every local Cursor store I found (store.db, composerData/bubbleId, agentKv, checkpoints) and how the UUIDs do and don't line up: vibe-replay.com/blog/cursor-lo… `npx vibe-replay` merges them into one replayable view.

Claude Code stores a session as one plain-text JSONL file. Cursor has no equivalent. ~/.cursor = 2.1 GB, App Support/Cursor = 4.9 GB, and state.vscdb alone is 1.24 GB: 88,826 agentKv keys + 55,889 bubbleId keys. It's a local storage stack, not a transcript log.

@abh1sek @debamitro Been running something similar. What made it work: each task self-contained enough that a fresh agent picks it up with zero planning context, plus an auto review + retry pass. The decomposition mattered way more than the execution.

@normonics @MorlockP This matches my experience. After a year of mostly working this way, the unit shifted from keystroke to intent: I write far less, read far more, and every model response becomes a code review. The "real engineering" moved upstream, to deciding what to build, not typing it.

Full writeup, all numbers pulled from local session data: tuo-lei.com/notes/one-year… (I parse my own Claude Code + Cursor sessions with: npx vibe-replay)

Biggest shift: I write less code and read way more. Every AI response is now a code review. The hard part was never the prompt. It's the 5 min before it: what does "done" look like, what should I NOT build. You can build the wrong thing faster than you realize it's wrong.

399 days. 878 AI coding sessions. 52,900 tool calls. 9,852 file edits. A year ago I typed a vague instruction into a terminal instead of writing code. I basically never went back. What a year of vibe coding actually taught me:

@ParamSiddh Fundamentals matter, agreed — but I'd reframe the dichotomy. The edge isn't avoiding vibe coding, it's being able to read what the model wrote. After ~880 AI sessions the real gap I see is between people who audit the diff and people who ship it blind.

@tskulbru Nice — OTel is the clean way to do this fleet-wide. Solo, I go the other way: parse the ~/.claude JSONL after the fact. Every assistant msg carries a usage object (incl. service_tier), and the leaked modelCost.ts has the exact per-model rates to cost it against.

Full writeup of all 5 fixes — the isMeta bug leaking skill injections into replays, stop_reason truncation, MCP tool naming, pricing validation: vibe-replay.com/blog/claude-co… I parse my own Claude Code sessions with it: npx vibe-replay

Claude Code accidentally shipped its full source map in the npm package — 513k lines of TypeScript, trivially extractable. We read it and shipped 5 fixes in a day. Best find: every compaction summary has `isCompactSummary: true` — we'd been string-matching the intro instead.

@nksages "Creates value" is the right filter. The trap I keep hitting: vibe-coding something that works but that I can't reason about a week later. Keeping the session history around so future-me can see why it was built that way is what stops it being throwaway.

@Reshad020 Agree. The prototype is the easy 20%. What flipped it for me was actually reading what the AI did when it broke — every tool call and edit gets logged, so "something broke" turns into a traceable diff instead of a black box. Fundamentals still win, but the logs shorten the loop.

Full breakdown of what's in there — cost & caching, sub-agent internals, the hidden file-history: vibe-replay.com/blog/claude-co… I parse these files with vibe-replay: npx vibe-replay

Ran `du -sh ~/.claude/` today and it said 858 MB. Just three weeks of Claude Code. Every prompt and tool call sits in plain-text JSONL on your disk. 17,487 tool calls logged, and 43% were Bash, not Read/Edit. It also keeps ~36 MB of invisible undo history.