It’s 11 PM.
The kids are asleep. The house is quiet. On my screen, nine project folders are open.
choviet/ — a community app for Vietnamese-Korean families, in App Store review.
silentia/ — an AI restraint engine, ₩150M government grant pending.
healthnote/ — a health record app for seniors with voice input.
policy-financing/ — a grant-matching pipeline running daily.
lbl_cafe24/ — a custom-goods e-commerce store.
mail_agent/ — thirteen Gmail inboxes condensed into one morning digest.
kaigo-coach/ — a Go AI coach.
ariadne/ — a decision-log engine, Phase 0.
lbl-wordpress/ — the publishing brain.
Nine projects. One person. Eighteen months ago I barely knew Rails.
I’m 52. I’m a chronic myeloid leukemia patient. Two kids in elementary school. No team. No co-founder. No safety net beyond what I build.
You’re probably wondering how. So was I, for a long time.
The honest answer isn’t romantic. It’s not “I worked harder.” It’s not “AI is magic.” It’s something quieter than that.
What I thought it was
When I started, I thought the leverage was the model.
I thought if I just learned to prompt better, picked the right LLM, used the newest framework — the ceiling would lift on its own.
It didn’t.
For months I built things that almost shipped. Almost. The architecture was right. The hardest 70 percent was done. But the last 30 — the testing, the merge, the README, the deployment runbook, the cleanup of three abandoned branches — kept devouring my evenings and pushing launch dates into next month, then the month after.
The model was never the bottleneck. The model was fast. I was the bottleneck — or rather, the discipline around the model was.
That’s when Claude Code stopped being a tool I used and started being the way I worked.
The boring thing that actually scaled
I’ll tell you the unglamorous truth: what saved me was a memory file.
Not a vector database. Not a RAG pipeline. A folder with about thirty markdown files and a one-line index.
When I make a judgment call worth remembering — don’t use the gmail-agent MCP, IMAP is more durable — I write it down. Not the fact alone. The why (three days of OAuth loops) and the how to apply (when integrating any auth-heavy service, default to the boring direct path first).
Every new session loads that index. Mistakes I made in March don’t get repeated in May. Decisions my past self made for good reasons aren’t quietly undone by my present self under deadline pressure.
This sounds small. It is small. It compounds.
After eighteen months of writing things down — what worked, what failed, who I am, what the user actually needs — the loop got tight enough that I stopped losing afternoons to context-loss.
That’s the leverage. Not the AI. The discipline of writing down what the AI taught me, so the next session inherits it.
A failure I won’t repeat
Mail-agent is the cleanest example I have of this loop in action.
Thirteen Gmail accounts. Personal, dev, shop, marketing, three parenting addresses, regional groups. All of them mattered. None of them were readable as a stream. I’d miss things for weeks.
First attempt: the gmail-agent MCP server. The shiny path. Three days of OAuth re-registration. Token expiration. Sessions that worked once and broke on the next launch. I couldn’t recover state cleanly. I killed it.
Second attempt: IMAP, App Passwords, a dumb Python script. Four hours. Cron at 07:00. One digest emailed to my primary inbox every morning.
It shipped on April 26. It hasn’t broken since.
The same day, I wrote a memory file: don’t reach for the MCP server when the boring path is faster and more durable. That note sits in my memory index now. Last week, when I was about to integrate another auth-heavy service the same wrong way, the note caught me. Saved me three more days.
This is what I mean by “Claude Code as daily driver.” It’s not the code generation. It’s the loop where decisions get captured, mistakes don’t repeat, and the time from “I have a brief” to “it’s running in production” collapses — across months, not just one session.
The loop I optimize for
I don’t enjoy starting from scratch. I enjoy closing loops.
The work that fits me looks like this: someone hands me code that’s 70 percent done. The hard architecture is decided. What’s missing is the last 30 — testing, merge, README, runbook, the abandoned branches nobody wants to touch.
That last 30 is where projects quietly die. It’s also where the Claude Code workflow earns its keep. Give it the brief, the existing code, a clear definition of shipped. Read every diff. Catch the wrong ones. Write the commit message future-you will thank past-you for. Merge.
Across nine projects this runs daily. The repos stay clean because cleanup is part of every session — not a quarterly intention I always postpone.
What you’d see if you watched me work
A typical evening:
- I open a project folder. The session loads that project’s
CLAUDE.mdand my memory index. - I give a brief in two or three sentences. Sometimes a paragraph if the brief is uncertain.
- I read every diff before merging. Every one.
- I catch the hallucinations — there are always one or two — and fix them.
- I write the commit message myself, even when the AI offers one. The commit message is the artifact future-me will read.
- I write the README or runbook in the same session. Not in some “documentation sprint” later that never happens.
- I retire abandoned branches as I find them. I don’t let the repo rot.
- If I made a non-obvious decision, I write a memory file before closing the session.
That’s it. Nothing exotic. The exoticism, if there is any, is doing this every night for eighteen months without skipping the cleanup step.
Why I’m telling you this
You probably opened this thinking I’d reveal a stack. A clever prompt. A framework you haven’t heard of.
I won’t. Because that isn’t where the leverage was for me, and I don’t think it’s where the leverage is for you either.
Here’s what I think the leverage actually is:
There is a folder on your machine. Or in your head. A project that’s 70 percent done. Maybe 80. The hardest part is over. What stops you isn’t capability — it’s the dread of the last 30 percent. The testing, the merge, the documentation, the abandoned branches.
You stopped. You moved on. You told yourself you’d come back.
You haven’t.
I’m not telling you the AI will finish it for you. It won’t. You finish it. The AI just removes the bottleneck between clear brief and shipped code — if you build the discipline around it.
That discipline isn’t hard. It’s tiny.
Write down what you learn.
Read every diff.
Close the loop in the same session you opened it.
That’s almost the whole thing.
The folder you put down
Maybe you put down a side project. Maybe a job application. Maybe a portfolio piece. Maybe a business you almost started.
You’re not the same person who put it down. None of us are.
I was 50 when I put down a lot of things. Some of them I’m not getting back. Some of them I am.
The nine folders on my screen tonight aren’t proof I’m special. They’re proof that the loop works — and that I was lucky enough to find it before the kids grow up and stop asking, Dad, can I help?
Open the folder again.
You’re closer than you think.
FIDES TAMEN — trust, nevertheless.
Bloom late, but stronger.
— Late Bloomer Lab
↘ 늦깎이 개발자의 도전을 기념하는 굿즈 · 늦깎이연구소