How I Find Article Ideas From 30 Days of Coding Transcripts

The article already happened. It’s sitting in a transcript I never reread.

Author: James Phoenix | Date: July 2026

The Problem

Most of my best article ideas don’t arrive as ideas. They arrive mid-task, buried inside a coding session: a workaround for something that didn’t behave as documented, a decision I reversed after ten minutes because my first instinct was wrong, an opinion I stated in passing while explaining a tradeoff to Claude. In the moment, none of it feels like “content.” It feels like just getting the task done.

By the time the task ships, the insight is gone. Not deleted, just buried under the next session’s transcript, and the one after that. I don’t reread old conversations. Nobody does. The knowledge that would make a genuinely good, opinionated post is sitting in plain text on disk, and I never look at it again.

The article already happened. It’s sitting in a transcript I never reread. That’s the gap this workflow closes.

Two Tools, Two Storage Models

I split my coding time between Claude Code and Codex, and they store history completely differently, which means any mining workflow has to check both places, not one.

• Claude Code keeps one folder per project, named by slugifying the absolute path (/Users/james/foo becomes ~/.claude/projects/-Users-james-foo). Every session in that project is a .jsonl file inside it. Finding “everything for this project” is a glob.
• Codex files sessions by date, not by project: ~/.codex/sessions/2026/07/04/rollout-*.jsonl. There’s no per-project folder at all. The only way to know which sessions belong to a given project is to open each file and check the cwd recorded in its first line.

Neither format is designed to be read raw. Most of the bytes in a session file are tool calls, thinking blocks, and injected boilerplate: CLAUDE.md and AGENTS.md get dumped into the first user turn of every single session, verbatim, every time. If I fed a whole day’s transcripts into a summarizer, I’d be paying to re-read my own instruction files a hundred times over.

Why This Isn’t a Script

My first instinct was to write a Python script: locate the files, parse the JSON, strip the boilerplate, dump a clean digest. I actually built one. It worked, and it was also the wrong tool for the job.

A script can filter by shape (this block is type text, that one is type tool_use). It cannot filter by interest. Deciding that a throwaway line about labour arbitrage economics is more article-worthy than a routine file edit is a judgment call, not a pattern match. A script finds text. An agent finds signal, which is the actual bottleneck now that extraction itself costs nothing.

So I deleted the script and turned it into a prompt instead: a skill that tells Claude where both tools hide their transcripts, what the injected boilerplate looks like so it can be skipped on sight, and then hands the reading and judging over to the model.

The Workflow

1. Locate the sessions. Bash/Grep across both locations for the project in question. Claude Code sessions are a direct glob; Codex sessions need a scan across the dated tree, filtered by the cwd field in each file’s first line.
2. Fan out. Reading dozens of raw session files in one thread burns context fast, and most of each file is noise. Instead I split the matched files into batches and launch multiple agents in parallel (the same swarm pattern I use for review work), each one reading a handful of files and reporting back anything worth a second look: a decision and its reasoning, a workaround, a reversal, a strong opinion stated in passing. Each candidate comes with a quote and a session id, not a vague summary.
3. Weight by recurrence. A pattern that shows up in one session might be a one-off. The same pattern showing up across three sessions, maybe across two different projects, is evidence I’ve actually found something durable, not just a mood I was in on a Tuesday.
4. Shape into a claim. Every surviving signal gets turned into a title plus a one-sentence thesis stated as something someone could disagree with, not a question. “Should scripts replace judgment calls?” is not an angle. “A script finds text, an agent finds signal” is.
5. Deduplicate against the vault. Before anything reaches me, each candidate gets run through qmd_query plus a keyword grep against the knowledge base. If it’s already written, up to a new angle on an existing note, it gets folded in rather than proposed as new. This is the same discipline behind the capture pipeline that keeps the vault from becoming a landfill of near-duplicates.
6. Stop at a shortlist. The output is five to ten ranked ideas: title, thesis, the evidence behind it, why it’s non-obvious, and where in the vault it belongs. Nothing gets written automatically. I still decide which ones are actually worth an article.

Why the Judgment Stays Manual

Two places in this workflow deliberately keep me in the loop instead of automating further. First, deduplication doesn’t auto-merge; it flags and waits, because a false merge silently erases a genuinely new angle. Second, the shortlist doesn’t turn into files on its own. The conversation is the asset, but not every asset is worth spending an article on, and that call is still mine to make.

What Changed

Before this, the only way an idea from a coding session reached the blog was if I happened to remember it later, which meant most of them didn’t. Now the last month of actual work, spread across two tools and however many projects, gets a monthly pass. Not everything it finds is good. But the things it finds are things that actually happened, backed by a real quote and a real date, instead of me trying to reconstruct a good opinion from memory three weeks after the session that produced it.

Related

• Prompts Are the Asset, Not the Code – Why the conversation, not the code, is the durable artifact
• Zero-Cost Knowledge Extraction – Signal detection is the bottleneck, not extraction
• Zero-Friction Knowledge Capture Pipeline – The capture and dedup pipeline this workflow feeds into
• Agent Swarm Patterns – Multiple agents over multiple files for coverage, not just speed
• Institutional Memory via Learning Files – Persistent knowledge across sessions