Essay

Claude Code Is Not a Code Editor. Here’s What I Actually Built With It.

March 2026

Most people use Claude Code to write functions, fix bugs, and refactor files. I do that too. But over the past few months I’ve turned it into something closer to a personal operating system — one that shops for me, builds a personal wiki from my conversations, stress-tests my own ideas, and remembers who I am across sessions.

None of this required special access or plugins. It’s all built with features that ship in the box: skills, hooks, memory, CLAUDE.md, and the Agent tool. Everything here works in the terminal CLI — no IDE or extension required.

1. Manufacturing fresh eyes

When you’ve been deep in a document or plan, you can’t see the holes anymore. You’re too close. The usual advice is “get a fresh pair of eyes.” With Claude Code, you can manufacture them.

The pattern is a structured review skill that works in stages:

  1. Cold read. Spawn a brand-new agent with zero conversation history. Feed it ONLY the document and critique instructions — no summaries, no author reasoning, no “here’s what we were thinking.” The agent reads it completely cold and produces a structured review: what’s sound, what’s shaky, what’s missing, recommended changes.
  2. Dialogue rounds. The facilitator (you, or a skill acting on your behalf with full context) writes an advocate response — conceding where the critic is right, pushing back where they’re wrong. Then a new fresh-context agent reads the artifact, the initial critique, and the advocate response, and rebuts. Back and forth.
  3. Synthesis. Agreed changes (both sides concur), contested points (user decides), and new insights that emerged from the exchange.

The critical design decision: the critic only sees the document and instructions. The moment you leak context — “we chose this approach because...” — you’ve defeated the purpose. The entire value is the cold read. Guard it.

Two rounds captures most of the value. I’ve caught significant flaws this way that I was blind to after hours of working on the same document.

2. Meta-skills: one conductor, many specialists

The most powerful pattern I’ve found is skills that orchestrate other skills. A meta-skill doesn’t do the work itself — it dispatches multiple specialist agents in parallel, judges their results, sends weak performers back out with specific feedback, and then curates across all results.

Here’s how it works in practice. Say you have five specialist skills that each search a different category — jackets, pants, knitwear, whatever your domain is. The meta-skill launches all five as parallel agents. When results come back, it plays editor: “The jacket search returned great stuff, but the knitwear results are all the same brand — go back and dig deeper.” The weak agents re-run with that specific feedback. Finally, the meta-skill curates across all categories, picking pieces that work well together, not just individually.

The general shape:

  1. Deploy — launch N agents in parallel, each with its own instructions and search criteria
  2. Judge — assess quality as results arrive. Any category empty? Results too similar? Wrong price range?
  3. Re-hunt — send specific agents back with targeted feedback
  4. Curate — pick the best results across all categories, looking at how they work together, not just individually

The trick is that sub-agents can’t invoke skills directly — so the meta-skill prompt has to inline the full instructions for each specialist. This is verbose but it works. Each agent reads its own criteria, runs the freshness check, searches, verifies, and reports back independently.

Claude Code’s parallel Agent tool makes this practical — multiple agents running at the same time, each doing its own searches and checks, all reporting back to one conductor that makes the final call. Be aware: this pattern uses a lot of tokens. Each parallel agent uses its own context window, and the conductor needs room to review all of their output. The conductor can also miss bad results from an agent — it’s not perfect quality control.

3. The Freshness Problem (and how state solves it)

If you build a skill that searches for things, you’ll hit this fast: AI search agents return the same results every time. The same queries hit the same cached pages. Run a search skill on Monday, run it again on Thursday — same results.

I solved this with a small Python script that gives skills memory across runs. The concept is simple:

The script is ~100 lines of Python. It reads a JSON state file, prints a few variables for the skill to parse, and exits. No database, no server. One thing to watch: if the state file gets corrupted or desynchronized, deduplication breaks silently and you’re back to repeat results. I keep mine in a git-tracked directory so I can roll back.

The pattern is general. Any skill that searches for recurring inventory — job listings, apartments, research papers, marketplace deals, domain names — has the freshness problem. A small state file and some query rotation fixes it completely.

4. Conversations as a knowledge source

Most conversations with Claude Code produce knowledge — decisions, facts, connections between ideas. That knowledge disappears when the conversation ends unless you capture it.

I built a harvest skill that runs at the end of every substantive conversation. It scans the exchange, extracts insights, and proposes them as structured notes — each one a small markdown file with a title, tags, and links to related notes. For example, after a conversation where you debated whether to build a feature in-house or use a third-party API, the harvest might produce a note titled “Build vs. buy: payment processing” linked to existing notes on “vendor lock-in” and “maintenance burden.” Over time, you build a personal wiki where the entries are byproducts of work you were already doing.

The linking works because Claude reads the existing note index and spots relationships between notes that share no obvious keywords but relate conceptually. It’s not doing anything fancy under the hood — it’s just reading a list of titles and tags and reasoning about what connects to what. That catches connections I wouldn’t make manually.

The collection of notes compounds over time. Periodically, I run a separate reasoning skill that reviews everything — surfacing connections between notes that nobody explicitly linked, flagging gaps in what I know, and proposing summary notes when several notes start circling the same topic. This step isn’t automatic; the harvest skill nudges me when enough new notes have accumulated.

The loop is: work → harvest (automatic) → reason (prompted) → discover → work. It’s not fully automatic — the reasoning step needs a kick. But each conversation still feeds the next one, and the notes get richer and more useful over time.

The CLAUDE.md instruction that makes the harvest step automatic:

At the end of every substantive conversation, run the harvest skill automatically. Substantive = produced new knowledge. Skip for trivial exchanges. Don’t ask — just do it.

5. Memory that compounds

Claude Code’s memory system lets you persist information across conversations. Most people save a few ad hoc notes. The leverage comes from structure.

I organize memory into typed categories:

Each memory is its own markdown file with a small header that says what type it is. A top-level index (MEMORY.md) provides the lookup table — but here’s the design choice that matters: MEMORY.md gets loaded into every conversation’s context window. If you dump all your memories into that file, it balloons and eats tokens before you’ve even said anything.

The fix is sub-indexes. MEMORY.md stays thin — one line per category with a link to a category-level INDEX.md. Each sub-index lists the actual memory files in that category. Claude reads the top-level index every time, but only dives into a sub-index when the conversation touches that category. My top-level index is 17 lines covering 18+ memory files across four categories. It costs almost nothing to load, but everything is reachable when needed.

Over time, you accumulate a profile that makes every new conversation smarter than the last — Claude knows who you are, what you’ve decided, what worked, and where to find things, without you repeating any of it.

6. Session handoffs: picking up where you left off

Claude Code conversations have a context limit. Long sessions eventually hit it, and even when they don’t, you might just need to stop for the day. Either way, the problem is the same: all the accumulated context — decisions made, approaches rejected, gotchas discovered — vanishes when the conversation ends.

The handoff pattern solves this with two pieces:

A /handoff skill that you run before ending a session. It scans the full conversation and writes a structured memo to a fixed file (.claude/handoff.md). The memo captures:

A SessionStart hook that checks whether a handoff file exists and is marked “pending.” If so, it injects the full memo into the new conversation’s context before you say anything. The new session reads the handoff and picks up seamlessly — same mission, same decisions, same awareness of what’s been tried.

A related hook solves a different persistence problem: when long conversations hit the context limit, Claude Code summarizes older messages to free up space — and your carefully written CLAUDE.md instructions get summarized along with everything else. A hook that fires after summarization and re-injects the full CLAUDE.md keeps your conventions intact. If you have a detailed CLAUDE.md and you do long sessions, this one hook is worth knowing about.

This pattern matters most for multi-session projects: a feature that spans a few days, a debugging session you have to pause overnight, a document that goes through multiple revision cycles. Without it, you spend the first five minutes of every new session re-explaining context. With it, you start where you stopped.

This post is actually an example: the previous session wrote, scrutinized, and revised the blog post, then ran /handoff. This session picked it up cold and knew exactly what was done, what wasn’t, and what to do next.

The meta-lesson

Claude Code is a terminal with an LLM in it. The LLM can read files, write files, run commands, search the web, and launch other agents. That makes it a general-purpose automation tool, not just a code editor.

The shift that unlocked all of this for me was a simple question: what workflows in my life can be described as “read this, filter by that, decide based on these criteria, and present results like so”? Once I started looking, they were everywhere — and none of them required writing much code to automate.

Built with Claude Code. Scrutinized by a fresh-context critic who caught five things I missed (section 1). Finished in a second session that picked up cold from a handoff memo (section 6).