Turn Stale Obsidian Notes Into a Claude Code Brief in 10 Minutes

On a Tuesday morning I pasted my Obsidian “article rewrite” note straight into Claude Code. Three weeks of notes, maybe 2,000 words. What came back was a suggestion to “fix” the call-to-action wording, the exact button copy I had already corrected the week before.

Why? Because that note had a three-week-old hypothesis (“the free PDF might be too weak”) sitting on the same flat bullet list as last week’s decision (“locked the free PDF in as the main CTA”). To the AI, both lines were just “information written in the note,” carrying equal weight. So it second-guessed a settled decision and re-suggested work I had already finished.

The notes weren’t too thin. The problem was that I was handing over stale guesses and locked-in decisions all mashed together. Today I want to show you the ten-minute morning routine that fixes exactly this.

Key takeaways

• Paste a long Obsidian note as-is and the AI treats old guesses and settled facts as equally important, then reopens work you already closed.
• Sort the note into five slots, things still true today, decisions made, open questions, the next move, and how you’ll verify, and you pass less information with better judgment.
• The sort takes ten minutes. There’s a copy-paste Node.js script below that runs with no extra installs.
• Deciding “fact or hypothesis” is a human job. Writing the prose is the AI’s job. Blur that line and you crash.
• Send beginners to a free learning path and teams improving their workflow to a consultation, picking one exit per reader.

Why pasting the raw note crashes

Obsidian’s strength is that you can keep piling information in. But the moment you hand it to an AI, that strength backfires.

When a human reads a note, we unconsciously weight it, “this part is stale, this part is current.” From the dates and the order, we silently filter. The AI does none of that. The third bullet and the thirtieth bullet are received with equal force, both as “the current state of things.”

So a “this might be the case” from three weeks ago gets treated as a settled fact in today’s request. And conversely, something you locked in last week gets demoted to just one option among many. My Tuesday crash was exactly this. The more notes you have, the more you need to sort before you hand them over.

The ten-minute sorting template

Every morning, or before you start a task, split the target note into these five slots. Ten minutes, tops. If it’s taking longer than that, you’re probably stuffing too much into the slots.

1. Things still true today, keep just three. Verified, and still holds today, only.
2. Decisions already made, write two. Policies you won’t reopen, like “the free PDF is the main CTA.”
3. Still unknown, write exactly one. Something today’s request to the AI is meant to settle.
4. The next move, one sentence. A concrete action that ends in a verb, like “rewrite one CTA paragraph and check the published URL opens.”
5. How to verify, write what “done” looks like. A test run, a visual check, a broken-link check.

The slot counts are fixed on purpose. Three facts, two decisions, one unknown. Add any more and you slide right back to “hand over everything.” The slot caps force the courage to throw things away.

Rewrite a note into these five slots and Obsidian stops being a “dump anything in here” warehouse and becomes today’s workbench.

What the AI does vs. what you decide

Blur this and you crash. Let me make the boundary explicit.

Step	Owner	Why
Judging fact vs. hypothesis	You	The AI tends to treat old guesses as settled
Which decisions still hold today	You	Only a human knows which policy is current
Sorting and summarizing into five slots	AI (first draft)	Mechanical tidying is fast
Writing the brief prose	AI	Prose generation is its strength
Final call on publishing or going live	You	Stop the irreversible actions

The trick is that only a human presses the “this is a fact” button. Let the AI build the first draft, but never hand off the final call on the sort. That alone makes “reopened decision” crashes almost disappear.

If note management itself feels shaky, read the basics of Obsidian integration and how to turn Obsidian notes into a Claude Code brief first, and this template will click into place.

A copy-paste prompt template

To make the AI build the first-draft sort, use this request verbatim. You just paste the body of your Obsidian note at the end.

Sort the following note into five slots. Always respect each slot's cap.

- Things still true today: up to 3 (verified and still holding today only)
- Decisions already made: up to 2 (policies you won't reopen)
- Still unknown: exactly 1 (the thing to settle today)
- The next move: one sentence (a concrete action ending in a verb)
- How to verify: the conditions for calling it done (test, visual check, etc.)

Rules:
- "might be" / "could be" never go in facts; move them to unknowns.
- If an old decision and a new decision conflict, take the new one and drop the old.
- Information that won't fit the slots is cut, not forced in.

Note body:
(paste the Obsidian note here)

The key is spelling out “respect the caps.” Leave it out and the AI, trying to be helpful, keeps everything. Tell it inside the request that cutting matters more than keeping.

A conversion script you can copy and run

Here’s a script that shapes your sorted result into text you can paste straight into your first request to Claude Code. It runs on Node.js 18 or later with no extra installs. Save it as brief.mjs and run it with node brief.mjs.

// Convert a note sorted into five slots into a Claude Code brief
const note = {
  facts: [
    "CTA fits on mobile without wrapping",
    "Gumroad product URL is swapped to the latest version",
    "top-traffic articles match beginner search intent",
  ],
  decisions: [
    "the free PDF is the primary CTA",
    "only readers stuck on setup or permissions go to the paid setup guide",
  ],
  unknowns: [
    "which locale has the lowest CTA click rate",
  ],
  nextAction: "rewrite one CTA paragraph and check the published URL opens correctly",
  checks: [
    "the body meets the required word count",
    "take a mobile screenshot",
    "confirm the published h1 and canonical URL are as intended",
  ],
};

// Mechanically check the caps aren't exceeded (a self-check on the sort)
function validate(n) {
  const errors = [];
  if (n.facts.length > 3) errors.push("too many facts (3 max)");
  if (n.decisions.length > 2) errors.push("too many decisions (2 max)");
  if (n.unknowns.length > 1) errors.push("too many unknowns (1 only)");
  if (!n.nextAction || !n.nextAction.trim()) errors.push("the next move is empty");
  return errors;
}

function toBrief(n) {
  return [
    "[Facts today] " + n.facts.join(" / "),
    "[Decisions] " + n.decisions.join(" / "),
    "[Still unknown] " + n.unknowns.join(" / "),
    "[Next move] " + n.nextAction,
    "[How to verify] " + n.checks.join(" / "),
  ].join("\n");
}

const errors = validate(note);
if (errors.length > 0) {
  console.error("The sort exceeds its caps:");
  errors.forEach((e) => console.error("  - " + e));
  process.exit(1);
}

console.log(toBrief(note));

The validate function is the point. The machine catches the mistake of writing four facts and handing them over without noticing, a mistake I make myself. Paste the five output lines straight into your first request to Claude Code. You don’t hand over every old idea; you hand over only the facts you need for today’s judgment. That template is now locked in.

Three places this pays off at work

The meaning of the slots stays the same, but the contents change by job. Here are three.

1. Content and article operations Separate a popular article’s search intent, its current CTA target, and the next product you want to sell. For a beginner article, put the free PDF first and send only the readers who get stuck on setup to the paid setup guide, written into “the next move.” That keeps your suggestions from drifting every time.

2. Handing off development work Separate the facts of a reproduced bug, the most recent design decision, and the still-unknown cause. Put a “hypothesis” about the cause into the facts slot here and the AI sprints full speed in the wrong direction. If the cause isn’t settled, send it to “still unknown” without hesitation.

3. Prepping for an onboarding consultation or meeting Separate what the customer actually said, the agreed scope of work, and the questions to ask next time. Write the deliverable of the consultation into “the next move” and the proposals you bring become concrete.

Common pitfalls and how to fix them

Three failures I fell into early on, with the fix for each.

The first is pasting a whole long page. Lots of information, thin judgment. The fix is simple: trim it into the five slots before you paste. Don’t hand over the warehouse, hand over the workbench.

The second is mixing decisions and open questions. Paste “the free PDF might be weak” next to “free PDF locked in as the main CTA” and the AI starts doubting the settled fact. Always move the “might be” line into the “still unknown” slot. That alone stops the reopening.

The third is not writing how to verify. With just “tell me when it’s done,” the AI decides “done” by its own standard. Hand over machine-checkable conditions up front, a test run, a visual check, a broken-link check. The trick is keeping the definition of finished in human hands.

FAQ

Q. Does this work with note apps other than Obsidian? A. Yes. Notion, the native Apple Notes app, whatever, the five-slot sorting idea is the same. The script doesn’t care about the source as long as you can pull out the text.

Q. I don’t have ten minutes to sort every time. A. You don’t have to do every note. Sorting just the one note you’re handing to Claude Code today is plenty. Once you’re used to it, it takes three or four minutes.

Q. Can’t I just let the AI do the whole sort? A. The first draft, sure, hand that off. But keep the final call, “this is a fact,” “this is a decision,” in human hands. Let go of that and the reopening crash from the intro comes right back.

Q. How is this different from writing things in CLAUDE.md? A. Stable policies go in CLAUDE.md; that day’s facts and next move go in the brief. The role of CLAUDE.md is also laid out in the official Anthropic documentation. For how to write it, see how to write CLAUDE.md and permission setup recipes too.

Q. I want to push my prompt accuracy further. A. How to build a prompt collects concrete tactics for making your requests stable. Combine them with this sorting template and you’ll see the effect.

What happened when I tried it

After the reopening crash in the intro, I tried sorting the same note into five slots before handing it over. I checked two things.

First, whether the “let’s re-examine that decision” replies would disappear. Just placing “free PDF locked in as the main CTA” as a single line in the [Decisions] slot, and the AI worked from that policy as a given and never reopened it again. The time I spent sorting was about four minutes, measured.

Second, whether validate really catches mistakes. I deliberately wrote four facts and ran it, and as expected it stopped with “too many facts.” With that in place, even a barely-awake version of me can’t break the caps. Rather than inventing a clever request, having one template that trims before you hand things over turns out to be the fastest path. That’s how it feels now.

If you want to extend this template into your team’s workflow improvements, a training and consultation session can land it in your real operations.