Stop Losing Your Strategy to the Tab Close: A Capture System You Can Stand Up in a Weekend

The exact directory structure, file templates, and mobile workflow that turn 2-hour Claude sessions into compounding strategic infrastructure instead of vanished clarity.

Published: May 2026 Tags: #SoloBuilder #AIWorkflow #StrategyDocs #Claude #BuildInPublic #KnowledgeManagement

The “So What?” - Why You Should Care

Bottom Line Value: A concrete, copy-pasteable capture system for the strategic work you’re already doing with AI assistants. Stand it up in a weekend; maintain it in 30 minutes a week; never re-derive the same conclusions again.

What You’ll Gain:

A specific directory structure (with names) you can mkdir today
A frontmatter template for AI memory entries you can paste into Claude
A 200-word synthesis doc template you fill in after every meaningful session
A claude.ai Projects mobile workflow that actually works on a phone
A decision rule for when to promote working notes to durable strategy
ROI: One Sunday afternoon of setup saves you ~4 hours per week of re-derivation and ~10 hours per major decision of “wait, what did we conclude about this?”

Who This Helps: Solo builders doing serious strategic work with Claude (or similar) and watching that work evaporate at the end of every session. Anyone who’s pasted a Claude transcript into a note-taking app and never re-read it.

Why Bother: AI conversations are the highest-leverage strategic surface most solo builders have ever had — and the most fragile. A 2-hour session can produce more clarity than a week of solo journaling. Lose that, and you’re not making progress; you’re paying compounding interest on the same questions.

TLDR: The Whole System in 6 Steps

Create a private GitHub repo named something like your-research — separate from any product repo. (5 min)
mkdir this exact directory structure (see below). (2 min)
Copy in a README.md with the directory legend. (10 min)
Set up a claude.ai Project with the repo’s key files as project knowledge. (15 min)
After every meaningful Claude session, drop a 200-word dated synthesis doc into 99-conversations/. (10 min/session)
Once a month, audit AI memory against the repo state and update either direction. (30 min/month)

That’s the whole system. Setup time end-to-end: ~45 minutes. Ongoing: ~30 minutes per week of capture + ~30 minutes per month of audit.

Result: Strategic thinking that compounds across sessions, syncs to your phone, and never disappears with a tab close.

The Moment You’re Probably In

You just had a 2-hour session with Claude. You worked through something that was tangled when you started and clean when you finished. Decisions got made. Frameworks emerged. You feel the arc.

You close the tab.

Three weeks later, you open a new conversation and notice you’re asking the same opening questions. The AI has no memory of what you concluded. Your notes app has either nothing or a wall of copy-paste you’ll never re-read. You’re standing in a coffee shop on your phone and can’t search the chat history anyway.

Then this happens:

A teammate asks “what did we decide about pricing?” — you genuinely don’t remember the reasoning
You spend Monday morning re-deriving Friday’s conclusions
You realize the same idea has been “new” to you three times in two months
Someone asks for your strategy doc and you don’t have one

If any of this sounds familiar, you don’t have a thinking problem. You have a capture infrastructure problem. Here’s the fix.

Step 1: The Repo (5 minutes)

Create a private GitHub repo. Personal account is fine. Name it something like research, strategy, or [yourbrand]-research. The important things:

Private by default. Public-later is easier than private-later.
Separate from any product repo. Strategic thinking does not belong in a product’s docs/ folder; it pollutes both surfaces.
GitHub specifically (not Notion / Obsidian / etc.) — because mobile GitHub renders markdown cleanly, supports lightweight editing on phones, and gives you free version history.

Commands:

mkdir ~/research && cd ~/research
git init
gh repo create $(basename $PWD) --private --source=. --remote=origin

5 minutes. Done.

Step 2: The Directory Structure (2 minutes)

This exact structure, with these numeric prefixes:

mkdir -p 00-philosophy 01-strategy 02-products 03-gtm 04-content/drafts 05-experiments 99-conversations
touch 00-philosophy/.gitkeep 01-strategy/.gitkeep 02-products/.gitkeep 03-gtm/.gitkeep 04-content/.gitkeep 05-experiments/.gitkeep 99-conversations/.gitkeep

Why the numbers: phones sort filesystems alphabetically and you can’t easily reorder. Numbers freeze the order so you can navigate by muscle memory. You’ll thank yourself the first time you’re looking for 01-strategy from a phone on a plane.

Why these specific buckets:

Directory	What goes here
`00-philosophy/`	Non-negotiables: brand stance, founding thesis, the values that don’t move
`01-strategy/`	Cross-cutting plans: revenue model, portfolio sequencing, “the plan” docs
`02-products/`	Per-product strategy at a level above the PRD (positioning, GTM logic)
`03-gtm/`	Hooks, experiments, launch playbooks, channel strategy
`04-content/`	Editorial: blog plans, voice guidelines, post drafts
`05-experiments/`	Hypothesis → measurement → decision → report cycles
`99-conversations/`	The most-used directory. Dated synthesis docs from AI sessions.

You don’t need all of them on day one. Create them anyway — empty directories cost nothing, and the structure should be there waiting when you want to use it.

Step 3: The README (10 minutes)

Copy this template into README.md at the root. Edit the bracketed bits:

# [Your] Research

Strategic research and synthesis for [your project / company].

**Status:** Private. May go public later. Write everything as if it might one day be readable.

## What this repo is for

- Capture strategic decisions and their reasoning
- Continue thinking across devices and over weeks/months
- Reference when starting new AI conversations so context survives
- Stage docs that will eventually become public content or formal PRDs

## Structure

- `00-philosophy/` — non-negotiables
- `01-strategy/` — cross-cutting plans
- `02-products/` — per-product strategy
- `03-gtm/` — go-to-market thinking
- `04-content/` — editorial
- `05-experiments/` — hypotheses + results
- `99-conversations/` — dated session synthesis docs

Numeric prefixes preserve order on mobile filesystems.

## How to use

**After every meaningful AI session**: drop a dated synthesis doc into `99-conversations/` using the template below. Don't paste transcripts. Distill to ~200 words.

**Promote to structured dirs** when an idea earns its place — when you'd defend it publicly.

That’s it. The README is navigation, not content.

Step 4: The Session Synthesis Template (the most-used file you’ll write)

Save this as 99-conversations/_template.md. Every session worth capturing gets one of these:

# [Short topic title]

**Date:** YYYY-MM-DD
**Source:** [claude.ai conversation / Claude Code session / etc.]
**Status:** raw | partially-promoted | fully-promoted

## Key insights

- [bullet]
- [bullet]
- [bullet]

## Decisions made (if any)

- [what was decided + reasoning in one line each]

## Open questions raised

- [what's not yet resolved]

## Should promote to

- [ ] `[doc path]` — [what to update]
- [ ] `[doc path]` — [what to update]

Rules for using it:

Date the filename: 2026-05-15-pricing-tier-experiment.md, not pricing.md. Six months from now, the date tells you “is this still current?” without opening the file.
Cap at 200–500 words. If you’re writing more, you’re writing a structured doc, not a synthesis. Move it to a real directory.
No transcripts. Distill. The synthesis is what’s useful; the transcript is what nobody re-reads.
Write the “should promote to” list even if it’s empty. Forces you to think about whether anything from this session actually crystallized.

Filling this out takes ~10 minutes after a 2-hour session. That’s the entire ongoing cost of the system.

Step 5: The Mobile Workflow (15 minutes, one-time)

The reason the repo lives on GitHub (not Notion / Obsidian) is mobile. Here’s the specific setup that makes phone access actually work:

Reading on phone: GitHub mobile app. Free. Renders markdown cleanly. Switch to “Code” view for the file tree.

Continuing strategic conversations on phone:

Go to claude.ai in your browser (or the app)
Create a Project called something like “Research Continuity”
In Project Knowledge, paste in the contents of your repo’s key files: README.md, your manifesto (when you have one), the most-recent synthesis docs from 99-conversations/
From now on, every conversation you start inside that Project has all of that context loaded automatically

This is the difference between “I’m continuing my work” and “I’m starting from scratch every time I’m on my phone.”

Writing back to the repo from phone (optional but useful): install Working Copy on iOS (~$20 one-time, no subscription). It’s a real git client. You can clone, edit, commit, push from your phone. For Android, Termux + git works similarly.

If you don’t want to install anything: capture in Apple Notes / Drafts / Bear during the trip, commit to the repo when you’re back at a real keyboard.

Step 6: The 30-Minute Monthly Audit

The thing that separates this system from the previous five capture systems you abandoned: the monthly audit.

Once a month, sit down for 30 minutes and:

Open 99-conversations/ and look at everything from the last 30 days
For each entry: was anything promoted to a structured directory? If yes, mark fully-promoted in the synthesis doc’s frontmatter. If no, ask whether it should be — or whether it’s truly disposable thinking
Open your AI assistant’s memory (Claude’s MEMORY.md index, or wherever your tool stores it). Cross-reference against the current state of the repo. Update any memory entries that are stale.
Delete or archive any synthesis docs older than 90 days that have been fully promoted (the structured doc supersedes them)

Without this audit, the repo becomes a graveyard and memory drifts from reality. With it, the system stays small and current.

When You’ve Outgrown This: The Working-vs-Canonical Split

You’ll know you’ve grown out of the single-repo version when one of these starts happening:

Multiple people want to reference the strategy but you don’t want them in the working repo where half-formed thoughts live
You can’t tell anymore whether something is “what we’re exploring” vs “what we’ve committed to”
You want a public version of some of the strategy but most of it should stay private

That’s when you split into two repos:

Working surface (the one you already have) — where mid-flight synthesis lives
Canonical — durable, convention-defined, conventionally organized, the source of truth

The hand-off rule is the load-bearing piece:

Anything in the working surface that crystallizes into durable strategy folds back into the canonical repo. Canonical is source of truth; working surface is the working tree.

In practice: when you’d be willing to defend a position in public, it’s ready for canonical. Until then, it lives in working.

You don’t need this on day one. Most solo builders won’t need it for the first 6–12 months. But knowing the split exists tells you what to do when you outgrow tier two.

What to Avoid (Common Failure Modes)

These will kill the system. Avoid all of them:

1. Storing strategy in product repos. Mixes cross-portfolio thinking with product engineering. When a future engineer reads the product repo, they shouldn’t have to skip past business strategy to find the architecture doc. Fix: a separate repo, always.

2. One giant strategy.md. Un-navigable on mobile. Every section ages at a different rate. Fix: split into multiple files in the directory tree.

3. Pasting whole AI transcripts as “notes.” The synthesis is what’s useful; the transcript is what nobody re-reads. Fix: force the 200-word distillation at capture time.

4. Skipping the date prefix in filenames. Six months later you can’t tell what’s current. Fix: every file in 99-conversations/ starts YYYY-MM-DD-.

5. No should promote to discipline. Capture-without-promotion turns the working surface into a graveyard. Fix: every synthesis doc has the list, even if empty.

6. Skipping the monthly audit. The system rots silently. Fix: 30 minutes on the last Sunday of every month. Calendar invite to yourself.

7. Trying to be perfect. Synthesis docs aren’t blog posts. Strategy docs aren’t books. Fix: ship the rough version; promote when something earns durability.

What This System Doesn’t Fix

Honest limitations:

Bad strategy doesn’t become good by being captured. Structure doesn’t replace clarity of thought.
Mobile editing is still clunky for substantial work. Read and reference from a phone; deep editing wants a real keyboard.
The system has a maintenance cost. ~30 minutes per week of capture + ~30 minutes per month of audit. Skip the audit and the system rots within 90 days.
AI memory drift is real. What’s in MEMORY.md and what’s in the repo can diverge if you don’t audit. (Ours had four stale entries when we audited recently.)
If you’re working alone, the system feels like overkill until your first vacation. Then it feels like the most important thing you set up that year.

Try It This Week

Specific homework, in order:

Sunday afternoon (90 minutes):

Create the repo (5 min)
mkdir the structure (2 min)
Paste the README template, edit the brackets (10 min)
Paste the synthesis template into 99-conversations/_template.md (5 min)
Set up a claude.ai Project with the README as initial knowledge (15 min)
Push the repo (5 min)
Schedule a recurring monthly audit on your calendar (3 min)
Leave 45 minutes for the inevitable “wait, where should X go?” decisions

Monday morning:

Your next strategic Claude session — at the end, spend 10 minutes filling out the synthesis template
Commit it as 99-conversations/YYYY-MM-DD-[topic].md

One week later:

You’ll have 1–3 synthesis docs in 99-conversations/. Spend 10 minutes reading them. Notice what you’d already started forgetting.

That’s the entire setup. The compounding starts immediately.

The Takeaway

Strategic thinking with an AI assistant is the highest-leverage surface most solo builders have ever had. It’s also the most fragile. Without structural capture, your work decays at the rate of your worst memory.

The fix is concrete, not philosophical:

A specific repo (private, separate, GitHub)
A specific structure (numbered directories, 99-conversations/ for raw)
A specific template (200 words, dated, with “promote to” list)
A specific mobile workflow (claude.ai Projects, GitHub mobile)
A specific maintenance cadence (30 min/week capture + 30 min/month audit)

None of these decisions are clever. All of them compound.

If you’re losing strategy to tab closes, you don’t need a better tool. You need this system, or one like it, standing between your conversations and your future self. The weekend you spend setting it up will pay back the first time you pick up after a gap and don’t have to re-derive what you’d already figured out.

That’s worth a weekend.

Coming up next: how we use this system during a Claude session — the in-conversation prompting patterns that produce the synthesis docs in the first place. Capture infrastructure is half the system; the prompting discipline that fills it is the other half.