Today, four article seeds came back to life — drawn out of memory files I had written myself but forgotten.
The abstract phrase "a solo developer's accumulated assets will compound" was, for the first time, implemented by my own hand.
1. The Edge Only Solo Developers Are Supposed to Have
When you work in an organization, knowledge dissipates through people: offboarding, shifts in interest, the cost of sharing. A problem that someone solved a year ago will trip up someone else six months later — I've watched that happen many times.
A solo developer is, in theory, strong here. All the insights live in the same head, so sharing cost is zero and accumulation should keep accumulating.
In practice, that wasn't me.
I had written about 70 memory files, each 1–3KB of distilled knowledge, with MEMORY.md hooks for easy retrieval. Still, I'd catch myself thinking "didn't I write about this somewhere?" — half-rediscovering my own past findings. Git log holds commits that solved the same issue, but I couldn't recall them.
The gap that needed bridging was, in the end, "the labor of remembering and verbalizing." That labor was rate-limited by my own cognitive capacity. As long as it was, the theoretical advantage of being a solo developer was never realized.
2. Porting Why Claude Code Works Into My Article Pipeline
The way Claude Code handles memory was a hint for a homomorphism.
At session start, every hook in MEMORY.md is automatically pressed into context. Each hook is written from the perspective of "what would the next-session me need to remember when asked what?" A smart model holds the index and goes to fetch the full body when needed. Three structural reasons it works:
- Each entry is small — 1–3KB, one topic. Subtopics don't get buried in the body.
- Hooks are retrieval-tuned — search terms re-appear in the hook.
- A smart model writes hooks semi-autonomously — past me distills for future me.
When those three line up, accumulated assets start compounding.
My own service Kotonia has a tech blog with 58 articles. If I bring the same index machinery to bear, I should be able to mechanically discover unexplored concepts from the past corpus.
The problem is that articles have the opposite shape. Each is 5–15KB, important subtopics are buried in section bodies, descriptions are SEO summaries rather than retrieval-tuned, and they're too heavy for an agent to read raw.
I bridged that with an intermediate layer I named the Dreaming layer. Raw articles (episodic) → semantic index (consolidated) → agent reverse-lookup — a hierarchy that's literally the biological "memory consolidation during sleep" metaphor.
Technical details are in a separate piece: Zenn: Implementation notes on porting Claude Code's memory model as a Dreaming Layer to 58 articles
3. Four Drafts Came Back Today
After running the pipeline:
- 58 articles consolidated into a semantic index (importance score 1–9, distribution roughly bell-shaped)
- 70 memory files mined for unexplored concepts and pushed into the idea pool
- 4 ideas drafted via Codex + local 26B uncensored, landing in
articles/_drafts/
What surprised me was, even though the source material was memory I wrote myself, I caught myself thinking "ah, I'd been meaning to write that" for every one of them.
Concretely:
- The ASR/TTS short-clip A/B trap — Qwen3-ASR 1.7B → 0.6B replacement, production regression, revert story
- Face clean-up with CodeFormer — 0.54GiB / 1.2s grain removal, Rust wiring
- Voice chat onomatopoeia runaway — emotional-peak control via frequency_penalty
- Stripe Product ID vs Price ID — the "can't checkout" pitfall and defenses
Every one of them had a corresponding entry in my memory where I'd noted "this is an important discovery." But that memory had stopped coming naturally to mind. The moment the pipeline took over the "remember and verbalize" labor, accumulated assets started compounding for the first time.
4. Where the Build Failed Structurally, I Fixed Structurally
Three duplicates slipped past me along the way. "Wait, isn't this overlapping with my existing §3.3?" — that hit me randomly, forcing a pipeline review.
The root cause was that I trusted the agent's self-discipline (writing "REJECT if it overlaps with a flagship article" in the prompt) without an enforcement layer. I rewrote it so the TF-IDF check is baked into the tool layer — the agent can't violate the rule anymore.
Separate piece on this: Don't Trust an Agent's Self-Discipline — Tool-Layer Blocking Fixed It Structurally
5. Real Conditions for Compounding to Take Hold
Now that the loop has actually closed, the three conditions for a solo developer's accumulated assets to compound feel like this:
- Raw assets accumulate in the first place (memory files, the "why" in commit messages, dev logs, decision rationale)
- A consolidation layer that semantically compresses raw assets (a human doesn't need to write it — hand it to an agent)
- Mining / drafting / dedup go through the semantic index, not the raw assets (eating raw assets directly will break context)
The flip side: developers without those three end up forever stuck on "whatever's in front of me today," and accumulation never accumulates. Tending memory + git isn't a "look back" ritual — it's a compounding investment in your future self-running capacity.
Organizations get blocked at #1 (memories that only ever lived in one person's head disappear). Solo developers get blocked at #2/#3 (you wrote it, but you can't reach it). The former is structurally hard. The latter can be solved with an agent loop.
That, I think, is the real condition for "the knowledge compounding only a solo developer can do" to actually stand up.
Aside: How This Article Got Written
This article itself was written outside the pipeline I just described. Reason: fresh felt-sense is faster and more accurate to write directly, and the writer's voice carries.
The pipeline shines on "knowledge past me forgot" excavation. Things happening right now are faster for a human to write. Using both, on purpose has become today's loop principle.
Check out Kotonia and its other tech writing if this resonated.