Planning with your second brain

The hardest part of planning isn’t the thinking. It’s getting the thinking out of your head, into a shape you can actually execute, and then not losing track of it by Thursday. This is the pipeline I use: brainstorm it honestly, split it into strategy notes, chunk it into action items, track the chunks in a dashboard I’ll actually read. It’s how I turn a vague idea into shipped work.

The problem this solves

Most people are fine at having ideas. Most people are also fine at doing the work. The gap where things fall apart is in the middle: the slow, uncomfortable process of turning a half-formed idea into a real plan that has steps, owners, deadlines, and a place you’ll come back to when you forget what you were doing.

I’ve lost count of the ideas I’ve had that died in that gap. A new business angle that felt urgent on Tuesday and was forgotten by Friday. A launch plan I wrote on a napkin and never typed up. A retrospective on a project that I meant to do and didn’t. The problem is not the quality of the thinking — it’s the friction between “I had a thought” and “I have a durable document I can execute from.”

This workflow is designed to kill that friction. It uses the AI agent as a planning partner that asks the hard questions you’d skip on your own, and it uses your vault as the durable home for the output so the plan doesn’t evaporate the moment the conversation ends. It is the thing that has made me actually finish projects this year instead of just starting them.

The four stages

Every time I need to plan something real, I run the same four stages in order. Skip any of them and the whole thing falls apart.

1. Honest brainstorm. I tell the agent what I’m actually thinking, including the parts that don’t sound smart yet. The agent pushes back on weak reasoning. We end up with a rough shape.
2. Split into strategy notes. The rough shape becomes two to four separate Markdown notes in the vault, each with a clean scope. One note for the overall strategy, one for the tactical sprint, one for the content backlog, one for the technical fixes. Each note stands on its own.
3. Chunk into action items. Each strategy note gets a list of checkbox action items that are small enough to execute in a single session without re-loading the context. Not “launch the membership.” Small. Specific.
4. Track in a dashboard. Every action item from every strategy note flows into one cross-project dashboard I actually read when I feel scatterbrained. The dashboard is the single source of truth for “what should I work on next.”

The four stages form a pipeline from “vague idea” to “executable work” that survives contact with tomorrow. The rest of this post walks through each stage with the prompts and patterns that make it work.

Stage 1 — honest brainstorm

The first stage is the one most people do badly. A normal brainstorm with an AI chat goes like this: you describe the idea, the AI enthusiastically lists fifteen good things about it, you feel validated, and you close the tab. Nothing is learned. Nothing is written down. The idea feels more real but is no closer to being executable.

An honest brainstorm is different. It requires the agent to push back on weak parts of the idea, name the things you’re avoiding, and surface the assumptions you’re smuggling in. That doesn’t happen by accident. You have to ask for it.

The prompt I use is something like this:

I’m thinking about [idea]. Before you suggest anything, I need you to stress-test the idea. What’s the weakest assumption I’m making? What would a skeptical version of me say? What questions would I have to answer before this is a real plan? Don’t be flattering. If the idea is worse than I think, say so.

That prompt inverts the usual dynamic. Instead of the agent enthusiastically listing upsides, it plays the role of the colleague who asks the uncomfortable question. What you get back is often a list of three or four things you were avoiding — and those are the things the plan needs to address.

After the stress-test, I ask the agent to summarize the rough shape of the plan based on what survived the pushback. That summary becomes the seed for Stage 2. It should not be polished yet. It should be rough and honest and about three paragraphs long.

Stage 2 — split into strategy notes

A single giant strategy note is the enemy of execution. When every decision, every task, and every open question is in one document, you have to load the whole document every time you want to make progress. That load is expensive. You end up not loading it at all, which means you don’t work on the plan.

The trick is to split the rough shape from Stage 1 into several smaller notes, each with a clean scope that you can open on its own and make progress inside of. For anything non-trivial, I split a plan into three or four notes along these lines:

• The strategy note. The one-page “why” of the plan. The thesis, the target outcome, the decision criteria, the reasons this is worth doing. This is the note you read when you forget why you’re doing any of the work.
• The sprint note. The tactical execution plan. Usually organized by weeks or milestones, with concrete action items under each. This is the note you read when you sit down to do the work.
• The backlog or content roadmap note. The list of things that need to get created, prioritized, with enough detail that you can pick one up without re-loading the strategy. This is the note you read when you’re asking “what’s next to ship.”
• The technical or operational fixes note. The non-glamorous list of plumbing tasks that unblock the real work. Database migrations, webhook automation, DNS verifications, permissions cleanup. This is the note you read when something is on fire.

The agent creates all of these in one session and links them together. I end up with a small family of notes, each with a clean job, each referenced from the main strategy note. When I come back the next day, I don’t have to load the whole plan — I just open the one note that’s relevant to what I’m doing.

Here’s the prompt I use:

Good, the rough shape is solid. Split this into three or four separate strategy notes in Business/: a strategy note, a sprint note, a backlog, and a technical fixes note. Each one should stand on its own. Link them all to each other using wiki-links. Use the existing Business/[similar plan] notes as a format reference.

The agent writes the notes, I read them, I fix anything that doesn’t match my thinking, and they become the canonical planning artifact.

Stage 3 — chunk into action items

Strategy notes are still too abstract to execute from. The final translation step is to take every section and chunk it into concrete checkbox action items small enough to finish in a single session.

The size test is simple: if you can’t imagine sitting down and finishing the item in one sitting with no re-loading of context, it’s too big. “Launch the membership” is not an action item — it’s a project. “Rewrite the homepage hero to one CTA” is an action item. “Verify the domain in Resend” is an action item. “Write the first weekly newsletter” is an action item.

I use Markdown checkboxes so the state is visible in Obsidian:

- [ ] Rewrite homepage hero to ONE CTA
- [ ] Write founding-member landing copy on community.html
- [ ] Verify wasserai.ca domain in Resend dashboard
- [x] Ship Foundations Module 2

The agent does this pass for me at the end of Stage 2. I tell it: “for each section of the sprint note, write checkbox action items that are each small enough to execute in a single session. If an item is too big, break it into two. Include enough context in each item that future-me can understand what it means without re-reading the whole note.”

That last instruction is the one that separates useful action items from dead ones. “Fix the Wi-Fi issue” is useless in three weeks when you’ve forgotten what the Wi-Fi issue was. “Fix recurring Wi-Fi dropouts on the ASUS ROG Xbox Ally X, root cause is the MT7922 driver, install the reference driver 3.5.0.1376 from the Downloads folder via the install-fix.ps1 script, needs elevated terminal” is executable in three weeks with zero re-loading. The difference is how much context lives inside the action item itself.

Stage 4 — track in a dashboard

The last piece is the one that ties everything together. I keep a single note called Open Loops.md in the AI/ folder of my vault, and it is the single cross-project dashboard of all pending work.

Its structure looks roughly like this:

• Critical / blocking. Items actively blocking other work or costing money right now. Read this first.
• Active sprint. The current sprint’s action items, grouped by week.
• Content roadmap. Background work, not sprint-critical, but in the pipeline.
• Technical fixes. Non-blocking technical work prioritized low to high.
• Parked / may return. Things that aren’t dead but aren’t active.
• Recently completed. A rolling seven-day window of done work so I can feel the momentum.

The dashboard is pointer-only. Each item is a one-line link to the source note that has the full context. You never execute directly from the dashboard; you open the source note first. But you always start at the dashboard, because that’s where the priority lives.

Every session starts with me reading the dashboard (my hooks do this automatically). Every session ends with me updating it — checking off things that shipped, moving completed items to the rolling-completed section, adding anything new that surfaced mid-session. The dashboard stays fresh because updating it is part of my session-end ritual, not a separate task I’d forget.

This single file is probably the most important thing in my entire vault. It’s the reason I can walk into any session, any day, and know what to work on without having to remember.

A real example: the Wasser AI membership launch

I built the plan for this business using exactly this pipeline, and I want to walk you through it because the artifact is real and you can feel the shape.

Stage 1 — brainstorm. I told the agent I was thinking about launching a paid membership tier on this site. I asked it to stress-test the idea. It pushed back on the thin content (“a subscriber would consume everything in 25 minutes”), the confused homepage CTAs (“four competing paths, no hero”), and the fact that Stripe-to-role sync was manual (“doesn’t scale”). It also named a key insight I hadn’t articulated: the value isn’t the content, it’s my taste as a filter. That reframing shaped the entire plan.

Stage 2 — split into notes. The agent split the result into four strategy notes:

• Business/Wasser AI Membership Strategy.md — the thesis, the free-vs-paid split, the founding-member pitch, the uncomfortable truths to keep visible
• Business/Wasser AI Launch Sprint.md — the three-week execution plan with weekly goals
• Business/Wasser AI Content Roadmap.md — the prioritized content backlog (free modules to finish, paid Workflows anchor posts, weekly cadence)
• Business/Wasser AI Technical Fixes.md — the plumbing work (Stripe webhook automation, Resend domain verification, homepage CTA consolidation)

Stage 3 — chunk into action items. Every note got filled with small, executable checkboxes. “Rewrite homepage hero,” “Write founding-member landing copy,” “Verify Resend domain,” “Draft This Week in AI #1,” etc. Each was small enough to finish in a single session with no re-loading.

Stage 4 — track in the dashboard. All of it flowed into AI/Open Loops.md under the appropriate section (critical, Week 1, content roadmap, technical fixes). Every subsequent session started with me reading Open Loops and picking the next chunk.

The plan was built in one planning session and has survived for weeks as the canonical source of what-to-do-next. That’s the promise of the pipeline: a single good planning session produces an executable structure that you don’t have to rebuild the next time you sit down.

What breaks

The agent validates instead of pushing back

If you don’t explicitly ask for stress-testing, the agent defaults to enthusiasm. That’s training, not malice — it was taught to be encouraging. The fix: front-load every brainstorm with “don’t be flattering, push back on weak reasoning.” Say it twice if needed. The honest brainstorm only works if you insist on it.

The strategy notes get too polished

Strategy notes are working documents, not publishable artifacts. If you spend time making them read well, you’re treating them like something they’re not. The fix: first drafts are fine. Grammatical imperfection is fine. Raw honesty is better than smoothness.

Action items sound complete but aren’t executable

“Redesign the homepage” feels like an action item and is actually a project. You’ll know it’s too big when you keep skipping it. The fix: whenever you find yourself skipping an item three days in a row, break it into smaller pieces and let the agent help you do it. The skipping is a signal, not a character flaw.

The dashboard becomes aspirational

If you never mark items done, the dashboard turns into a wall of open checkboxes that you stop reading. The fix: mandatory end-of-session update. Check off what shipped. Move it to recently-completed. Trim the oldest recently-completed entries. A dashboard that reflects reality stays useful; one that doesn’t becomes wallpaper.

Your turn: plan one real thing

Pick one thing you’ve been meaning to plan. Not an imaginary project — a real one. Something that matters enough to finish and vague enough to feel stuck on.

1. Open Claude Code. Make sure it can read and write files in a folder you use for notes (any folder is fine).
2. Run the stress-test prompt. Describe the idea, ask for pushback, don’t be flattered.
3. Let the agent propose the split. Ask it to write two to four strategy notes in the folder. Read them, correct anything off, accept the rest.
4. Chunk each note into action items. Small, specific, with enough context that future-you can execute without re-reading.
5. Create an Open Loops.md dashboard pointing to each action item with a one-line excerpt. This is your single source of truth for what’s next.
6. Tomorrow morning, open Open Loops.md first. Pick one item. Execute it. Check it off. Feel the difference.

The whole first run should take you about an hour. After that, subsequent plans take minutes — you’re not building the system, you’re just running it. That hour of setup is the highest-ROI hour I’ve spent on my business in a year. The thing that matters isn’t the plan you produced — it’s that you now have a repeatable way to turn any future idea into an executable plan without losing it.

Back to

All workflows

→