How to Organize AI Knowledge Vault (Architecture Guide)

Updated January 2026 | 8 min read

A pile of markdown files isn't a knowledge vault. It's just a pile.

The architecture matters. How you organize files determines whether AI finds what it needs in two seconds or gives you generic responses because it couldn't locate your context.

Here's the structure that works, proven across 50+ vault setups and three years of daily use.

The Three-Layer Architecture

Your vault has three layers. Each one serves a different purpose.

Layer 1: Root CLAUDE.md — Master instruction set. AI reads this first, every session. It's the map.

Layer 2: Domain folders — Major areas of work. Client folders, project categories, content types. Each has a _context.md file with domain-specific instructions.

Layer 3: Individual files — The actual work. Client details, project specs, meeting notes, templates, logs.

AI routes like this: Root CLAUDE.md tells it which domain to load → Domain context tells it how to work in that area → Individual files provide the specific details.

Let's build each layer.

Layer 1: Root CLAUDE.md

This file sits at your vault root. Never inside a folder. Right at the top level.

It contains:

WHO section — Your name, roles, basic context about what you do.

WHAT section — Routing table that maps keywords to domain folders.

VOICE section — How AI should write for you.

RULES section — Things AI should never do, formatting standards, critical warnings.

KEY FILES section — Important files AI should know about.

This file should be under 1,000 words. If it's longer, you're putting too much detail here. Details belong in domain context files.

The root CLAUDE.md answers one question: "How do I route this request?"

Layer 2: Domain Structure

Domains are major work areas. Not projects, not clients, not topics. Areas.

For a consultant: Clients, Business Development, Personal

For a content creator: Content Production, Client Work, Community

For a business owner: Sales, Operations, Marketing, Finance

For a developer: Work Projects, Side Projects, Learning

Most people need three to five domains. More than seven and you're splitting too fine. Fewer than three and you're not organizing at all.

Domain Folder Naming

Name folders with prefixes so they sort correctly:

/CLAUDE.md
/01 - Client Work/
/02 - Content Production/
/03 - Business Operations/
/04 - Personal/

The numbers force sort order. The dashes and capitals make them stand out from project files.

Inside each domain folder, create _context.md. The underscore makes it sort to the top, so it's the first file you see when you open the folder.

What Goes in _context.md

Domain context files hold information specific to that area of work.

For a Client Work domain:

# Client Work Context

## Active Clients
[List with one-line descriptions]

## Deliverables
[What you produce]

## Process
[Your workflow]

## Templates
[Links to template files]

## Current Projects
[What's in progress]

For a Content Production domain:

# Content Context

## Platforms
[Where you publish]

## Voice Rules
[How you write]

## Content Calendar
[What's scheduled]

## Templates
[Article structures]

## Topics
[What you cover]

Each context file stays under 500 words. If it gets longer, move sections into separate files and link to them.

Layer 3: Individual Files

Inside domain folders, you have the actual work files.

Structure varies by domain, but common patterns:

Client Work domain:

/01 - Client Work/
  /_context.md
  /ClientA/
    /ClientA-Details.md
    /Project-Alpha.md
    /Meetings/
    /Deliverables/
  /ClientB/
  /Templates/

Content Production domain:

/02 - Content Production/
  /_context.md
  /Articles/
    /Published/
    /Drafts/
  /Social/
  /Newsletter/
  /Templates/
  /Style-Guide.md

Personal domain:

/04 - Personal/
  /_context.md
  /Tasks.md
  /Projects/
  /Journal/
  /Goals.md

The structure should match how you think about the work, not some ideal organization system.

Routing: How AI Finds Context

Your root CLAUDE.md contains a routing table. This maps keywords to context files.

## WHAT (Domains)

| Domain | Context File | Load when prompt mentions... |
|--------|--------------|------------------------------|
| **Client Work** | `01 - Client Work/_context.md` | client, project, deliverable, ClientA, ClientB, proposal |
| **Content** | `02 - Content Production/_context.md` | article, post, write, publish, newsletter, social |
| **Personal** | `04 - Personal/_context.md` | task, todo, reminder, goal, personal |

When you tell Claude "draft the ClientA update," it sees "ClientA" in your prompt, checks the routing table, loads the Client Work context, then finds the ClientA folder.

Good routing keywords:

• Client/company names
• Project names or codes
• Action verbs (write, send, schedule, review)
• Output types (article, email, report, proposal)
• Topic areas (content, sales, operations)

Bad routing keywords:

• Generic words that appear everywhere (help, work, update)
• Words that overlap between domains (if "email" could mean content newsletter or client communication)
• Technical jargon AI won't recognize

Naming Conventions That Scale

Consistent naming makes everything findable. Pick conventions and stick with them.

For People

Option 1: FirstLast.md (simple, works for small lists)

Option 2: Company - ContactName.md (better when you have multiple contacts per client)

Option 3: LastFirst.md (sorts by last name)

Pick one. Use it everywhere in your vault.

For Projects

Option 1: YYYY-MM-DD - Project Name.md (best for time-based work)

Option 2: ClientName - Project Name.md (best for client work)

Option 3: ProjectCode - Description.md (if you use project codes)

Date-based naming is best when timeline matters. Client-based is best when you're juggling multiple clients.

For Templates

TEMPLATE - Use Case.md

The prefix makes templates easy to find. The use case makes the purpose clear.

Examples: TEMPLATE - Client Proposal.md, TEMPLATE - Article Structure.md

For Logs

_log.md

Underscore keeps it at the folder top. Every domain should have one. It's where you track what happened, when.

For Dated Content

YYYY-MM-DD - Description.md

Meeting notes, journal entries, daily logs. The date prefix makes them sort chronologically.

When to Split vs. Merge Files

This is where most vaults break down. Too many tiny files or too few massive ones.

Split when:

• A file passes 2,000 words and you're scrolling to find things
• Sections of a file are used independently (client details vs. project details)
• You're updating one part frequently and others rarely
• Multiple people (or multiple AI sessions) need to reference different parts

Merge when:

• You have five files that are each under 100 words
• Information is always used together (contact info and communication preferences)
• Separate files make finding things harder, not easier
• You're spending more time deciding where to put things than actually writing them

The test: If you need to open three files to answer one question, merge them. If you're scrolling past irrelevant info to find what you need, split them.

Linking Strategy

Links are how AI navigates between related files. Good linking means AI finds everything it needs. Bad linking means it only sees what's directly in front of it.

Upward Links

Link from specific to general. Project files link to client files. Client files link to domain context.

This lets AI trace backward when it needs broader context.

Related Links

Link between files at the same level. ClientA links to ClientB if they're in the same industry. One article links to related articles.

Add a "Related" section at the bottom of files:

## Related
- [[ClientB]] — Similar industry
- [[Project-Template]] — Structure for this type of work
- [[Past-Deliverable]] — Example of good output

Template Links

Context files should link to relevant templates. When AI knows you're writing a proposal, it should know where to find the proposal template.

In your Client Work context:

## Templates
- [[TEMPLATE - Proposal]]
- [[TEMPLATE - Status Update]]
- [[TEMPLATE - Meeting Recap]]

The Maintenance Loop

Organization isn't a one-time setup. It's a continuous loop.

After each work session: File outputs in the right place. Update status in context files. Add new entries to logs.

Weekly: Check active project lists in context files. Archive completed work. Verify routing keywords still make sense.

Monthly: Move old files to archive folders. Review domain structure. Split files that got too long. Merge files that stayed too small.

Quarterly: Evaluate whether your domain structure still matches your work. Add new domains if your work has expanded. Remove or merge domains you're not using.

Good organization feels invisible. You shouldn't think about where to put things. They should have obvious homes.

Common Mistakes

Too many folders. Seven domain folders, each with five subfolders, each with category folders. You spend more time navigating than working. Start simple. Add structure only when you feel the pain of not having it.

No routing table. You have beautiful organization but didn't tell AI how to use it. AI can't guess. You need explicit routing keywords.

Organizing for the system instead of the work. You create folders for "Resources" and "Reference" and "Archive" because that's what organization systems tell you to do. But you never actually use them. Organize around how you work, not around someone else's framework.

Perfectionism. You spend three days designing the perfect folder structure before you've created a single file. Start messy. Organize as you see patterns. The right structure reveals itself through use.

No context files. You've got folders and files but no _context.md files. AI has no instructions for how to work in each domain. It treats everything the same. Add context files. They're what make domain structure useful.

What Good Organization Looks Like

When your vault architecture works:

• You don't think about where to put new files
• AI finds the right context without you specifying file paths
• You can find any file in under 10 seconds
• Adding new domains or clients is obvious and fast
• Nothing feels over-organized or under-organized

The system fades into the background. You work. AI helps. The organization just happens.