Markdown editors were built for notes, not for agents

September 12, 2026 · ThreadGrab

There is a category of file that did not exist five years ago and now sits at the centre of how software gets written. It is not source code. It is the pile of markdown that tells a coding agent what to do: CLAUDE.md, AGENTS.md, rules, skills, sub-agents, commands. On September 2, 2026, Kunihiro Ishiguro published a post titled "Markdown Editors Weren't Built for Coding Agents, So I Made One" and shipped the editor he wanted: Marginal.

The post opens with a problem I recognise from a completely different direction. The author says that after using coding agents heavily, mainly Claude Code, he ended up with "an overwhelming number of markdown documents, sometimes more than 100, scattered across different subdirectories," and had "completely lost track of which skills are currently available, which sub-agents are installed, and which rules are in effect."

I write about archiving social content, so my interest here is not the editor. It is the file class. Those instruction files are a record of what an AI was told, and almost nobody is keeping dated copies of them.

What Marginal actually does differently

Most markdown editors treat a file as a file. You give them a folder and they show you what is in it. Marginal inverts that: you tell it which coding agent you use, and it finds the files that agent actually reads, wherever they happen to live.

That distinction is the whole product. The author's complaint is precise - some instruction files are project-local, some are shared across an account on a specific machine, and each agent searches different paths. A generic folder view cannot answer "which rules are in effect right now," because the answer is spread across at least three locations and depends on which agent is running.

The supported agents and the files each one reads

Per the Marginal manual, the agent is selected in Settings under AI, with Claude Code as the default. The manual lists every folder each agent reads:

Read that table twice and something obvious falls out. Four of the six agents read a file called AGENTS.md, and they all read it from different places. The same filename means different things depending on who is looking. If you maintain instructions for more than one agent, you are maintaining overlapping documents with no shared index - which is exactly the state the author describes.

The other features, briefly

• Subdirectory file listing - opt-in, for when your markdown is spread across nested folders. Filter by path fragment, including / to match a directory.
• Two AI interfaces - select text and press ⌘K for an inline rewrite that streams in as a diff you accept or reject as one undo step; or press ⌘J for a terminal panel and run claude or codex in place.
• Live reload on agent writes - when the agent writes to a file you have open, Marginal notices and offers to reload, and a newly saved skill appears in the sidebar without reopening the folder.
• Read and export - double-click a file in Finder to open it in reading mode, then export as PDF or HTML.
• Emacs and Vim editing modes with custom key mapping, and ten built-in themes in five light/dark pairs (Marginal, GitHub, Solarized, Zenburn, Dracula) plus user JSON themes loaded without a restart.

One implementation detail is worth naming because it explains the export quality: a single Rust markdown engine drives the editor, the preview, the PDF export, and the context handed to the AI. One parser, four consumers.

The pricing model is friendlier than most

Marginal has one plan, two ways to pay: $10 per month, or $96 per year which works out to $8 a month, with a 14-day trial that asks for no card. But the split between free and paid is the interesting part, because it is drawn at writing rather than at reading:

The stated consequence of a lapsed subscription is read-only rather than locked: "Your files are plain markdown on your disk, and they are never held hostage." The AI runs on your own key from Anthropic, OpenAI, Google, xAI or Alibaba Cloud, stored in the system keychain rather than on the vendor's servers, and the site states plainly that the subscription never gates the AI.

Why agent instruction files deserve dated copies

Here is the part that connects to what I actually do. Marginal answers "what is in effect right now." It does not answer "what was in effect when this happened," and those are different questions.

Consider what a CLAUDE.md or an AGENTS.md contains after a few months of real use. It accumulates rules the agent must follow, project conventions, forbidden patterns, deploys you are not allowed to touch. It is edited constantly, often by the agent itself. Six months from now, when you are reading a commit, a plan file or a security audit that the agent produced, the instruction file as it was at that moment is the missing half of the record. The version you have today is a different document that happens to share a filename.

This is the same failure mode as archiving a thread by its handle. Both are cases where the thing you saved still resolves, but resolves to something else. Notula covers the reading direction - making sure your markdown is clean enough that an agent can use it. Marginal covers the editing direction. Neither covers the historical direction, which is nobody's product and everybody's problem.

Capturing agent state alongside the content it produced

You do not need a special tool for this, which is the good news. The instruction files are plain markdown on your disk, so a dated copy is a copy. The work is deciding what to snapshot and where to put it.

A minimal snapshot script - drop it next to the project and run it whenever the agent has done something you might need to explain later:

#!/usr/bin/env bash
# Snapshot the coding-agent instruction files for a project.
set -euo pipefail

PROJECT_DIR="${1:-.}"
STAMP="$(date -u +%Y-%m-%dT%H-%M-%SZ)"
OUT="agent-state/${STAMP}"

mkdir -p "$OUT"

# Instruction files this project may use, across the agents Marginal lists.
for f in CLAUDE.md AGENTS.md QWEN.md GEMINI.md; do
  if [ -f "$PROJECT_DIR/$f" ]; then
    cp "$PROJECT_DIR/$f" "$OUT/$f"
  fi
done

# Cursor rules, if present.
if [ -d "$PROJECT_DIR/.cursor/rules" ]; then
  cp -R "$PROJECT_DIR/.cursor/rules" "$OUT/cursor-rules"
fi

# Skills and commands, if present.
for d in .claude/skills .claude/commands .codex/prompts; do
  if [ -d "$PROJECT_DIR/$d" ]; then
    mkdir -p "$OUT/$(dirname "$d")"
    cp -R "$PROJECT_DIR/$d" "$OUT/$d"
  fi
done

echo "Snapshot written to $OUT"

Run it with the project directory as the argument and you get a timestamped folder holding exactly the instructions that were in force at that moment. Commit the snapshots, or keep them out of git if the rules contain anything sensitive - either way, they exist as files rather than as a memory of what you meant to check.

Filenames are the easy part. The other half of an archive is knowing what the content you captured actually said, and for that the provenance pattern matters:

# Record the instruction version alongside what the agent produced.
# Keep this in the same directory as the artifact it explains.
cat > artifact.provenance.txt <<EOF
agent: claude-code
instruction_files: CLAUDE.md AGENTS.md
captured_at: $(date -u +%Y-%m-%dT%H:%M:%SZ)
source_url: https://github.com/org/repo/commit/abc1234
snapshot_dir: agent-state/$(date -u +%Y-%m-%dT%H-%M-%SZ)
note: rules in effect at generation time, not today's rules
EOF

The point of the second file is the last line. Any archive that stores an artifact without the rules that shaped it will be misread later - not because anyone is careless, but because the rules quietly changed and nothing recorded the change.

The stack, end to end

Put the pieces in order and a pattern emerges that is much older than coding agents:

1. Discovery - find the files that are actually in effect. Marginal, in the editor.
2. Snapshot - copy them, dated, so the version survives the next edit.
3. Capture - store the artifact the agent produced next to the rules that produced it.
4. Re-verification - before citing something from months ago, check the snapshot, not the current file.

Step 1 is now a product someone sells for $10 a month, which tells you the problem is real and common. Steps 2 through 4 are still manual, and they are the ones that decide whether your archive is usable in a year.

Where ThreadGrab fits

ThreadGrab captures public X, Bluesky and LinkedIn content into Markdown with timestamps and the source URL, so what you saved keeps the identity it had when you saved it. It is a social content archiver, not a developer tool, and it does not read your repository. What it shares with the Marginal problem is the principle: the copy you control, stamped with when you took it, is the only version that still means what it meant.

If you maintain agent instructions, the question is not whether you will need the old version. It is whether you will have it.

FAQ

Last verified: September 12, 2026. Primary sources: Marginal, "Markdown Editors Weren't Built for Coding Agents, So I Made One" by Kunihiro Ishiguro (September 2, 2026) at marginal.md/blog.html; the Marginal manual at marginal.md/docs including the coding-agents page and the per-agent instruction-file table; and the Marginal pricing page at marginal.md/pricing.html for the $10 monthly / $96 yearly plan, the 14-day trial terms, the free-versus-paid feature split, and the supported API-key providers. The Hacker News submission of the post (September 3, 2026) is cited for the low discussion volume. Pricing and the supported-agent list are the details most likely to change; verify them on the vendor pages before purchasing.