Building a Second Brain That Actually Works — With Copilot Cowork as the Librarian#

Every knowledge worker I know has the same problem: too much information, not enough structure. Meeting notes live in one tool, research in another, ideas scribbled on Post-its, articles bookmarked but never read again. The stuff you need in six months is exactly the stuff you can’t find.

I’ve tried note-taking apps, wikis, bullet journals. They all fail the same way — the capture is easy, the retrieval is the problem, and the maintenance is what kills it.

This post is about how I solved it for myself: a personal Second Brain in OneDrive, structured around PARA, and driven by Copilot Cowork that knows where things belong. It took me a few weekends to set up. It’s been paying off every day since.

If you’re thinking about building something similar — for yourself, not for a team — this is the blueprint.

The Core Idea#

A Second Brain is a persistent, external memory for the things your wetware can’t be trusted with: decisions, context, half-formed ideas, research, conversations. Tiago Forte popularized the term and the PARA methodology (Projects, Areas, Resources, Archive). I use that as the backbone, but I extended it in two ways:

1. A dedicated space for AI-generated artifacts — briefings, research outputs, meeting debriefs, weekly reviews. This stuff piles up fast once you start working with Copilot Cowork, and it needs its own home.
2. A skill-based routing layer — instead of me deciding where each note goes, I describe the intent in natural language (“debrief this meeting”, “capture this thought”, “save this article to read”) and Copilot Cowork figures out the right folder.

The key insight: the hard part of a Second Brain isn’t storage, it’s routing. If every new note forces you to stop and think “where does this belong?”, you’ll stop capturing. Automate that decision and the system runs itself.

The Folder Structure#

Here’s the tree that sits in my OneDrive:

/Second Brain
  /01_Inbox              ← Unsorted captures, landing zone
  /02_Projects           ← Time-bounded work with defined outcomes
  /03_Areas              ← Ongoing responsibilities (leadership, team, domains)
  /04_Resources          ← Evergreen reference material (by topic)
  /05_Archive            ← Completed projects, retired material
  /06_AI                 ← Session logs, research, briefings, reviews, meeting debriefs
  /07_Templates          ← Reusable note templates

A few opinions baked into this structure:

• 01_Inbox is sacred. It’s the default destination whenever the routing logic isn’t confident. Better to park something in the Inbox than force a bad classification. I empty it weekly.
• 03_Areas is where most of my time goes. Projects end; areas (people I lead, domains I own, ongoing initiatives) don’t. Most knowledge workers underweight this folder.
• 06_AI is my addition to PARA. Once you have Copilot Cowork producing real artifacts — morning briefings, meeting debriefs, research — you need somewhere to keep them that isn’t Projects (too narrow) or Resources (too generic).
• 07_Templates reduces friction. Every recurring note type (meeting debrief, 1-on-1, project brief, decision log, weekly review, person profile, reading list) has a template. I don’t start notes from a blank page.

Inside 02_Projects and 03_Areas I create sub-folders per project or area. Each gets an Overview.md at the top — a single page explaining what this area is, who’s involved, what’s active. Think of it as the README for that slice of your life.

The AI Routing Layer#

Here’s where it gets interesting. I use Copilot Cowork (running inside my M365 environment) with a set of custom skills — small instruction files that teach Copilot Cowork how to handle specific workflows.

Each skill is just a Markdown file with a name, a description of when to trigger, and a playbook. My skills roughly map to intents:

The routing logic inside each skill is boring and explicit. For example, quick-capture has a table that says: project update → 02_Projects/<project>, leadership observation → 03_Areas/People Lead, readable article → append to the Reading List, unclear → 01_Inbox with a tag. No magic, just heuristics I worked out by watching what kinds of things I actually capture.

Copilot Cowork doesn’t write anywhere it wants. Every save goes through one skill (save-to-vault) that knows the folder IDs, handles the Graph API copy, and verifies the file landed. Centralizing that logic means when something breaks — a renamed folder, a new sub-structure — I fix it in one place.

Templates, Not Blank Pages#

Every recurring note type has a template. The ones I use weekly:

• Meeting debrief — goal, decisions, action items (with owner and deadline), observations, open questions, follow-up
• 1-on-1 — topics discussed, what the person said (verbatim where possible), concerns, development areas, next time
• Project brief — goal, stakeholders, timeline, key decisions log, current status
• Decision log — context, options considered, decision, rationale, revisit date
• Weekly review — what happened, what I learned, what’s blocking, priorities for next week
• Person profile — role, communication preferences, shared history, open threads
• Reading list — queue, currently reading, finished (with takeaway), archive

Templates do two things: they make capture fast (no thinking about structure), and they make retrieval useful (consistent frontmatter means I can filter by type, tag, or date later).

Every template starts with YAML frontmatter:

---
type: meeting-debrief
date: 2026-04-23
project: [project-slug]
attendees: [names]
tags: [#debrief]
---

Six months from now, when I’m looking for “all the decisions I made about X in Q2”, the frontmatter is what makes that search tractable.

A Day in the System#

Here’s what actual usage looks like:

Morning (2 minutes) — I ask for a daily brief. Copilot Cowork pulls today’s calendar, unread emails flagged as important, and recent chat activity. It writes a short overview and archives a copy to 06_AI/Briefings. I skim, adjust priorities, start the day.

During meetings — I don’t take notes in the moment. After each meeting I say “debrief this” and Copilot Cowork pulls the transcript (if Teams recorded it), extracts decisions and action items, classifies the meeting type (1-on-1, team, client), and saves the debrief to the right folder. Two minutes per meeting.

Between tasks — any thought, article, observation goes through quick-capture. “Capture this: we should rework the onboarding flow, the handoff is losing people.” One sentence, Copilot Cowork parses the type, routes to the right folder, confirms with a link.

Friday afternoon — weekly review. Copilot Cowork goes through the Inbox, helps me classify each item, summarizes what happened across projects and areas, surfaces stuck items, and writes the review note to 06_AI/Weekly Reviews. About 20 minutes, and my Inbox starts Monday at zero.

The rhythm only works because the friction is close to zero. If capture took more than 15 seconds, I’d skip it. If retrieval took more than a minute, I’d stop trusting the system.

What I Learned the Hard Way#

A few non-obvious lessons from the build:

1. Start with too-few folders, not too many. My first version had deeply nested structure. I never used most of it. Now I default to flat — if a folder doesn’t have 5+ items after a month, it probably doesn’t need to exist.

2. The Inbox is a feature, not a bug. I used to feel guilty about unclassified items. Now I treat the Inbox as a legitimate parking lot. Some things genuinely don’t know what they are yet. Force-fitting them into a category makes the system worse.

3. Preserve wording, don’t paraphrase. When capturing decisions, observations, or things people said, keep the exact phrasing. “We’ll revisit this in Q3” is different from “we decided to wait.” Your future self needs the literal words.

4. Templates beat discipline. I used to try to remember what sections a meeting debrief should have. I’d forget one every time. Now the template has the slots, I fill them in. Consistency is a property of the system, not of me.

5. Persist everything outside the tool. Whatever AI assistant you use — I use Copilot Cowork — assume you’ll switch tools eventually. My notes live as plain Markdown in OneDrive. No proprietary formats, no vendor lock-in. If the AI layer disappears tomorrow, the Second Brain is still there.

6. Build the routing logic gradually. Don’t try to design the perfect taxonomy up front. Start with 3–4 obvious categories, watch what you actually capture over a few weeks, add categories as patterns emerge. My current routing table took about a month to stabilize.

7. One skill per intent, not per tool. I was tempted to build a “Teams skill”, an “Outlook skill”, a “OneDrive skill”. Bad idea. Intents (“summarize this meeting”, “capture this thought”) cross tools. Build skills around what you want to do, not around where the data lives.

How to Start Your Own#

If you want to build something similar, here’s the minimal path:

1. Pick a storage layer that isn’t a note app. OneDrive, Dropbox, Google Drive, a plain folder — anything that syncs and lets you write Markdown files. Not Notion, not Obsidian (yet), not Evernote. Start with files.

2. Set up the PARA folders. Projects, Areas, Resources, Archive. Add Inbox for captures and (optionally) an AI folder if you work with Copilot Cowork or a similar assistant.

3. Create 3–4 templates. Whatever note types you produce weekly. Meeting notes, weekly review, and a decision log is a decent starter set.

4. Write one Overview.md per active project and area. Two paragraphs each: what this is, who’s involved, what’s active.

5. Pick one capture flow. The single highest-leverage habit is capturing thoughts into the Inbox with a one-sentence intent. Everything else is polish.

6. If you have an AI assistant with custom instructions — like Copilot Cowork, Claude, or ChatGPT with Custom GPTs — teach it the folder structure and the routing rules. Even without automation, explicit rules written down make the system more robust.

7. Run a weekly review. Non-negotiable. 20 minutes every Friday: empty the Inbox, scan projects and areas, plan the coming week. Without this ritual, the system decays.

That’s it. Everything else is optimization.

The Real Value#

What a Second Brain actually gives you isn’t organization. It’s cognitive leverage. You stop using your working memory for storage and start using it for thinking. You stop rediscovering the same conclusions and start building on them. You stop losing context between meetings and start entering each one already prepared.

The honest test, six months in, is this: can I answer “what did I decide about X in Q1, and why?” in under a minute? If yes, the system is earning its keep. If no, something in the routing or retrieval is broken and needs fixing.

I think mine passes the test. Yours will too, if you keep the system small, the capture frictionless, and the review weekly.

The hardest part isn’t the setup. It’s trusting the system enough to stop keeping a parallel one in your head.

If you want to discuss your own setup or see specific examples of the templates and skill definitions I use, feel free to reach out.