48 hours · 1 app · Claude Code

I picked a small problem I had personally: I keep losing track of which YouTube transcripts I've already pulled with my fetcher, which I've actually read, and which I've already synthesized into a MOC. Three states, no source of truth, manual tracking in random Obsidian files.

The brief, written before opening the editor:

• One feature: a small tool that scans my Dev OS folder, lists every channel-playlist, and shows the read / unread / synthesized state.
• Three SLC cuts decided up-front: no auth, no sync, no styling beyond defaults.
• Done state: I can open it on my laptop, see the list, mark videos as read. Anything else is scope creep.

The brief took 15 minutes. Most of the 15 minutes was not designing additional features I wanted but couldn't have.

Hour 12 was where I almost broke the rules. Claude proposed — actually proposed — adding a small AI-summary feature: pull the current transcript's content into Claude, generate a one-line summary, store it next to the read state.

The temptation was strong. It would have been five minutes of work, low complexity, technically possible inside the deadline. I declined.

Every 48-hour build has a wall. Mine was hour 30, somewhere around Saturday afternoon, when the parsing logic for the existing MOC files hit a structural edge case I'd assumed was simple.

The actual problem was that my own Dev OS folder convention was less consistent than I thought it was. Some MOCs had frontmatter with the playlist name; some had it embedded in the H1; some had neither and inferred the name from the folder. The parser kept disagreeing with itself across folders.

Claude wanted to write a sophisticated heuristic to detect and normalize all three patterns. I wanted that too. Then I remembered the rule: 48 hours, one feature path, no detours. I rewrote three of my own MOC files to make them consistent rather than building a parser that handled all three forms.

The fix that shipped was normalize the input data, not the parser. Less elegant. Saved four hours.

What landed at the deadline:

• A small CLI that scans ~/Documents/Dev OS/Resources/YouTube/, lists every channel-playlist folder, and shows count of video notes per folder
• A "read state" stored as a JSON file in the same folder (one source of truth, no DB)
• A minimal web UI on localhost:3000 that lets me toggle the read state per video and per playlist
• Zero auth, zero sync, no styling beyond Tailwind defaults

What didn't ship:

• The AI summary feature I almost added
• Mobile responsiveness (laptop-only)
• Any data export (the JSON file is the export)
• The cute fade animations I considered for hour 42

The tool's been live on my laptop for about three weeks since. I've used it most days. That's the SLC test: did I use it the week after I shipped it?

Scored against the rubric from my AI tooling stack post:

• % of code written by Claude: roughly 80%. Most was correct on first try. Refactors usually held.
• Times I reverted its changes: four times. Three were CSS-related. One was a parser that became over-engineered.
• Bugs it found I missed: two. Both were edge cases in date parsing I would have shipped without noticing.
• Bugs it caused: one. A regex that worked on my data but would have broken on any path with a parenthesis in it. Subtle. I caught it because I happened to have a test case with that exact pathology.

Net: positive. Without Claude Code, this build doesn't fit in 48 hours. With Claude Code, the deadline was the actual constraint, not the typing.

If I ran another 48-hour challenge, the rules I'd keep:

• One feature, decided before opening the editor.
• Three explicit SLC cuts written down in advance.
• A scope-creep rejection rule for hour 12 (the historical moment scope expands).
• A pre-existing, personally felt painkiller. Not a hypothetical idea.

The rules I'd change:

• Build slightly more buffer for the hour-30 wall. Every build has one; assuming none means missing the deadline.
• Skip the trial of any new tool inside the 48 hours. The deadline is too short to fight tool unfamiliarity.

The thing I most underestimated: how much the deadline itself sharpens scope discipline. SLC is harder to maintain on an unconstrained timeline because every feature could fit. 48 hours forces you to admit which ones won't.

Edmund's framing — that solo founders' edge is speed of iteration, and that speed is impossible without disciplined scope — landed for me in a way the videos alone hadn't. The lesson isn't anyone can build an app in 48 hours. The lesson is anyone can build the right v1 if they're forced to cut everything that isn't the v1.

The deadline was the teacher. Claude Code was the assistant. The discipline was the thing I had to bring.