Getting Started with Claude Code: Building a Personalized AI System

Every conversation with AI starts from scratch. You explain your role, your projects, your constraints — and twenty minutes later, the context window closes and all of that disappears. If you work in diplomacy, defense, or federal government, you already know this frustration. The tools feel too shallow to bother with, so most of your professional thinking gets zero AI assistance.

This tutorial fixes that. You'll build a system where the AI already knows who you are, what you're working on, and how you like to work — using Claude Code or Cowork, a text editor, and a folder on your computer. You don't need to be a developer or write any code.

One important scope note: this is about the non-sensitive work that fills most of your professional life — drafting talking points, synthesizing open-source research, preparing for meetings, writing articles, managing your professional development, organizing your thinking across a dozen concurrent projects. If your work involves classified information, compartmented programs, or CUI on government systems, external AI tools aren't the right fit for that content. You know this already. But the rest of it is fair game, and that's where we're headed.

Understanding the Options

Not all AI interfaces are the same, and the differences matter more than most people realize. Here's how the major options compare:

The key distinction is between conversation tools and working partners. Chat interfaces — even good ones with Projects features — operate inside a browser tab. You type, they respond, and the context either disappears when you close the window or stays confined to that single project thread. They can't see your files, can't write documents to your computer, and can't connect to the tools you actually use.

Claude Code and Cowork work differently — they're agents that live in your filesystem, reading your files, writing new ones, running commands, and connecting to external tools within the context of your actual work. You build a system of files that Claude reads automatically — meeting notes, project plans, reference documents, personal context — and every session starts from that foundation instead of from zero.

Both Cowork and Claude Code are available through the Claude Desktop application on macOS. You don't need to open a terminal to use either one — though Claude Code also runs as a standalone terminal tool if you prefer that.

Cowork is the right starting point for most people reading this. Anthropic launched it in January 2026 as a more accessible interface to Claude Code's agentic capabilities — specifically designed for knowledge workers rather than software engineers. It runs in the Claude Desktop app, reads your files, writes new ones, and connects to external tools, all through a visual interface. Cowork reads your CLAUDE.md file at session start, just like Claude Code does, so the persistent context system described in this tutorial works the same way in both.

One honest caveat: Cowork doesn't have full parity with Claude Code yet. It handles most of what this tutorial covers — file reading, writing, context loading, tool integrations. But some power features, like automatically discovering and loading custom skills, work more reliably in Claude Code's terminal interface. For the foundation this tutorial builds, Cowork is more than sufficient. If you find yourself wanting finer control later, Claude Code is right there in the same application.

Claude Code (the terminal version) gives you maximum control — precise command approval, full system access, and the complete feature set. If you're comfortable in a command line, it's the more powerful option. But it's not necessary to start, and this tutorial works with either. When I say "Claude Code" going forward, I mean both.

Why These Tools — and Why Now

Google's Antigravity and OpenAI's Codex are building similar agent-based approaches — persistent context, file access, tool integrations. As of early 2026, neither matches what Claude Code and Cowork deliver for non-developer knowledge work. Antigravity remains developer-focused and in public preview. Codex is a capable terminal agent but narrower in its tool ecosystem and without anything like Cowork's accessible interface. That will change — probably faster than any of us expect — which makes the next point matter more than which tool is currently ahead.

There's a deeper reason to start now rather than wait for the field to settle: portability. The system you'll build in this tutorial is a folder of plain text files on your computer. It's not locked into Anthropic's platform or anyone else's. If a better tool appears next year — or your agency approves a different product — you can take your vault with you. The instruction file (CLAUDE.md) and your context documents work with any AI agent that reads from the filesystem. Your investment is in the knowledge structure, not the specific tool. The tools are replaceable, but your accumulated context is not.

One Folder for Everything

Before installing anything, understand the organizing principle: everything goes in one place.

In software development, a "mono-repo" means keeping all of a project's code in a single repository instead of scattering it across many. The same idea applies here. Create a single folder — with subfolders for organization — that holds all of your working files: notes, project documents, reference materials, context files for Claude. Not scattered across Google Drive, Notion, Dropbox, and your desktop, but one place where everything lives together.

Why this matters: Claude reads from the filesystem. When your files live in one folder tree, Claude can search across all of them, find connections between projects, and reference yesterday's meeting notes while helping with today's deliverable. Scatter your files and you're left with two bad options: missing context, or compensating by giving Claude access to your entire computer. The second is a bad security practice that also risks other files inadvertently diluting or polluting your work content.

Here's a simple starting structure:

my-vault/
├── CLAUDE.md              ← System instructions (Claude reads this first)
├── claude-refs/           ← Context files about you and how you work
├── daily/                 ← Session logs, one per day
├── projects/              ← One subfolder per project
├── meetings/              ← Meeting notes and prep
├── references/            ← Research, analysis, reference material
└── inbox/                 ← Quick capture, sort later

Start with this or something close to it. The structure will evolve as you use it — mine started with five folders and now has a dozen, because I discovered I needed separate spaces for meeting prep versus meeting notes, and project folders wanted their own decision logs. What matters now is that everything lives under one root folder and that the organization makes intuitive sense to you.

A note on file format: use plain text markdown files (.md). They're readable by any text editor, searchable, version-controllable, and Claude works with them natively. Obsidian, VS Code, or any markdown editor works well for managing them. If you need to share something as a Word or PowerPoint file, you can always export from markdown — but keep your working files in plain text. Proprietary formats (.docx, .pptx) are opaque to Claude unless you convert them, which means Claude can't search, reference, or build on that content.

Building Your CLAUDE.md

This is the most important file in your system. CLAUDE.md sits at the root of your folder and acts as system instructions — Claude reads it at the start of every session. It defines how Claude works with you.

Here's a complete starter skeleton. Create a file called CLAUDE.md in your vault root and paste this in, then fill in the brackets:

# System Instructions

## About Me
I'm a [role] at [organization] working on [what]. My current priorities
are [priorities]. I need Claude to help me [think through problems,
draft documents, manage projects — whatever fits].

## How to Work With Me
- Challenge my assumptions. Test my logic. Provide alternative perspectives.
- Be direct. Skip the caveats and qualifiers unless genuinely uncertain.
- When I'm wrong, say so and explain why.
- Provide evidence and citations for claims.
- [Add your own preferences here — how you like feedback, what annoys you,
  what kind of output you find most useful]

## Session Startup
On first interaction, load `./claude-refs/personal-context.md` for work context.

## Vault Structure
- `claude-refs/` — Personal context files, load at session start
- `daily/` — Daily session logs
- `projects/` — Active project folders
- `meetings/` — Meeting notes and prep documents
- `references/` — Research and analysis
- `inbox/` — Quick capture, needs sorting

Three things are happening in this file. The About Me section gives Claude enough context to make its responses relevant to your actual situation — not a resume, but enough that it understands your role, your constraints, and what kind of help you need. The How to Work With Me section shapes Claude's behavior — AI trained on helpfulness defaults to agreement unless you instruct otherwise, so be explicit about wanting pushback, directness, or whatever matters to you. The Vault Structure section tells Claude where your files live so it can find them. The Session Startup section tells Claude to load your personal context file (which we'll create next) at the beginning of every session.

The file will grow as you discover what instructions actually change Claude's behavior and which ones are noise. Expect to revise it frequently in the first few weeks, then less often as it stabilizes.

Tip: You don't need to edit CLAUDE.md by hand. Tell Claude "update your CLAUDE.md to reflect that I'm now working on X" or "add a rule that you should always do Y" — and it will edit the file itself. Same goes for any file in your vault. Claude can create, edit, and reorganize your files on your behalf. You review and approve the changes. This is one of the core differences from chat-based AI: Claude operates on your files, not just in a conversation window.

CLAUDE.md is a living document. It evolves as your work changes and as you learn what Claude needs to be effective. Schedule a deliberate review every week or two, but don't wait for the review to fix something that's not working.

Personal Context Files

Personal context files tell Claude who you are in depth.

Create a file called personal-context.md in your claude-refs/ folder. Here's a starter template:

# Personal Context

## Current Role
[Your role, organization, and how long you've been in it. What you're
responsible for. What success looks like in this position.]

## Active Projects
- **[Project 1]:** [What it is, why it matters, current status, key deadline]
- **[Project 2]:** [Same format]
- **[Project 3]:** [Same format]

## Key Stakeholders
- **[Name/Role]:** [What they care about, your relationship, any tensions]
- **[Name/Role]:** [Same format]

## Constraints
[What limits your work — budget, timeline, political dynamics, compliance
requirements, organizational culture, reporting chains that matter]

## Goals
[What you're actually trying to achieve — not your task list, but the
outcomes that would make this year a success]

## Preferences
[How you like to work — communication style, when you do deep work,
what kind of output you find most useful, what annoys you]

The more specific you are, the better Claude's output gets. "I work at the State Department" produces generic output. "I'm a mid-career FSO on my second tour in the political section, covering economic reform and anti-corruption, managing three locally employed staff, trying to build relationships with reform-minded officials in the finance ministry while navigating a skeptical front office" produces output that accounts for your actual situation.

Why two files instead of putting everything in CLAUDE.md? They serve different purposes and change at different rates. Think of CLAUDE.md as how Claude should behave — your standing instructions, behavioral preferences, and file organization. It's the operating system. Your personal context file is what Claude should know about you — your projects, stakeholders, constraints, and goals. It's the briefing document.

CLAUDE.md changes when you refine how Claude works with you (maybe once a month after the initial weeks). Your personal context changes when your work shifts — new projects, new stakeholders, changed priorities (maybe every week or two). Separating them means you can update one without wading through the other. It also means you could share your CLAUDE.md structure with a colleague without exposing your personal context, or swap in a different context file for a different role.

The Session Startup line in your CLAUDE.md skeleton already tells Claude to load this file — that's what ./claude-refs/personal-context.md points to. Once both files exist, every session starts with Claude knowing both how to work with you and what you're working on.

Persistent Memory on Projects

Individual sessions with Claude are useful, but sessions that build on each other — where Tuesday's research informs Wednesday's draft and last month's decisions shape this week's analysis — are where the system actually earns its keep.

Three mechanisms create persistent memory:

Daily notes. Create one file per day in your daily/ folder (I use YYYY-MM-DD.md). During your session, log what you worked on, what decisions you made, and what files you created or modified. This doesn't need to be elaborate — a few bullets under timestamped headers. The value comes when Claude reads yesterday's note at the start of today's session and picks up where you left off.

# 2026-02-06

### ~09:00 - Project X kickoff prep
Drafted stakeholder analysis. Key tension: budget holder wants
speed, technical lead wants thoroughness. Need to reconcile
before Thursday meeting.

### ~14:00 - Client call follow-up
Created three Asana tasks from meeting action items.
Updated project timeline — delivery pushed to March 15.

You can do this manually, but you shouldn't have to. Claude Code supports custom skills — small instruction files that automate recurring tasks. A daily logging skill can instruct Claude to automatically note milestones, file changes, and decisions as you work, without you stopping to write them down. The daily-patterns-pack on GitHub does exactly this — session logging, pattern analysis, and automation built for Claude Code. Install it, and the daily logging happens in the background while you focus on your actual work.

Project folders. Without project context, Claude treats every session like a new engagement. Give each project its own folder with a README (what is this project, what's its current status) and a PROJECT-LOG (chronological decisions and milestones). Claude reads these files and understands the history — what's been decided, what's still open, what's been tried and didn't work.

Working memory files. For complex, multi-session work, create a dedicated file that captures the state of your thinking. Key decisions made, open questions, dependencies, next actions. Think of it as a save file for a project's strategic context. Claude loads it at the start of relevant sessions so you don't re-explain the situation every time. Critically, you can always ask Claude to save things to this, rather than manually editing it yourself.

The pattern in practice: Claude reads your daily note and relevant project context at session start, you work together through the day, and Claude logs what happened — so the next session picks up where this one ended instead of starting cold.

After a few weeks of this, something shifts. Claude starts making connections you didn't prompt for — referencing a decision from last Tuesday that's relevant to today's problem, or noticing a pattern across two projects that you hadn't connected yet. Each session gets a little smarter because it's drawing on everything that came before it.

Going Further

Once the foundation is working, three extensions are worth knowing about — though none are necessary to start.

Skills are reusable instruction files for specific tasks: meeting prep, background research, writing review, weekly planning. Each one is a markdown file that Claude follows when triggered. Think of them as saved workflows — you write the instructions once, and Claude executes them on demand.

Tool integrations connect Claude to your broader work system through MCP (Model Context Protocol). Task management, CRM, calendar — the same agent that reads your vault can also check your Asana tasks or look up a contact in HubSpot. This is the difference between an AI that knows your files and one that knows your whole working environment.

If you write regularly, a voice profile is worth the investment. It's a reference document that captures how you (or your principal) writes — sentence patterns, vocabulary, what to avoid. Claude drafts in that style instead of generic AI prose. The claude-voice-analyzer on GitHub can build one from samples of your writing.

Add these when you feel the need for them. There's no hurry.

Starting This Week

Here's what to do in your first three sessions:

Session 1: Install Claude Code (or Cowork). Create your vault folder with the basic structure. Write your CLAUDE.md and personal context file. Then work on something real — not a test. Pick a task you'd normally do alone: synthesize three open-source articles on a policy question you're tracking, draft a speech for an upcoming event, or research a contact you're about to meet for the first time. See how the output changes when Claude has your context file versus when it doesn't.

Session 2: Create your first daily note. Start a project folder for whatever you're actively working on — add a README with the project's purpose, status, and key stakeholders. Try asking Claude to help you think through a problem: "I need to brief my director on the trade-offs between Option A and Option B for this project. Help me structure the argument, and push back where my reasoning is weak." Notice where Claude's responses are generic and update your context files to fix that.

Session 3: At the start, tell Claude to read yesterday's daily note. Notice the difference when it has session history. Try a multi-step workflow: "I'm writing remarks for a panel on [topic]. Read the research I saved yesterday in references/, then draft a 5-minute opening that takes a clear position and anticipates the strongest counterargument." Start logging decisions and milestones during your session — or ask Claude to do it for you.

By the end of your first week, you'll notice the difference — Claude's responses start fitting your actual situation instead of sounding like they could be for anyone. A month from now, Claude opens your vault and already knows your projects, your stakeholders, your preferences, and the decisions you've made along the way. You built that, one file at a time.

What to Try Next

This tutorial covers the infrastructure — the system that makes AI actually useful across sessions. But infrastructure without workflows is a toolkit sitting in a drawer. Here are a few things to try once your foundation is working.

The common thread in all of these: the value comes from the intersection of public information and your private vault context. Anyone can ask Claude to summarize a think tank report. The difference is when Claude summarizes that report and knows which of its findings conflicts with the position you took in last week's briefing, or which author is someone you're meeting on Thursday.

• Policy research. Drop three or four open-source articles, think tank reports, or congressional testimonies into your references/ folder and ask Claude to identify where they agree, where they diverge, and what the implications are for a question you're working through. Because Claude has your project context, it doesn't just summarize — it filters through what matters to your specific situation. "Given what I'm trying to accomplish with [project], which of these arguments strengthens my case and which undermines it?" This is probably the workflow I use most. The difference between a generic summary and one that accounts for your documented positions, your stakeholders' known concerns, and the deadline you're working against is the difference between research and intelligence.
• Media analysis. Track how a policy issue or diplomatic event is being covered across different outlets. Save articles to your vault and ask Claude to map the framing — who's characterizing it as a success, who's calling it a failure, what's being left out. If your vault documents your stakeholders and their positions, Claude connects the coverage to the people: "this editorial aligns with what [stakeholder] argued in the last meeting you documented."
• Contact research. Before meeting someone new, ask Claude to pull together what's publicly available: published work, organizational affiliations, recent public statements, areas of expertise. Save the profile to your vault. Next time that person comes up, Claude already has the file and layers new information on top. Over time, your vault becomes a working relationship map that gets richer with each interaction you document — not a static contact database, but accumulated context.
• Speech and remarks drafting. This is where the vault context really compounds. If you give talks, write op-eds, or draft remarks for principals, Claude reads your project folder while drafting — pulling specific examples, referencing your documented positions, and avoiding contradictions with things you've already committed to publicly. Pair that with a voice profile (a document describing how you or your principal writes) and the output starts close to finished rather than starting from generic prose. You'll still edit 30-40% of it. That's the feature, not the bug — the AI gets you to a strong working draft in minutes instead of hours, and your judgment shapes the final product.
• Grant or program research. Synthesize publicly available information on potential grantees or partner organizations — track records, published impact reports, leadership backgrounds, media coverage. Save each assessment to a project folder. When the next evaluation cycle arrives, Claude reads last year's assessments alongside this year's public data and flags what changed.
• Weekly review. Ask Claude to review your daily notes and surface patterns: what got done, what's stalled, what you committed to but haven't started. The vault holds both your session logs and your project context, so Claude can flag a deadline approaching in a project folder, a contact you said you'd follow up with three weeks ago, or a deferred decision that's quietly blocking two other workstreams.

I'll cover these workflows in depth in a companion piece. But start with the foundation — it's what makes everything else work.