# How to give Claude Code context: CLAUDE.md, skills, MCP, and keeping it current

> Claude Code's official docs cover installation and configuration but leave the harder problem to you: feeding the agent accurate context about your architecture and decisions, and keeping that context current as your codebase changes. This guide covers the three native context mechanisms (CLAUDE.md, skills, and MCP) and how Falconer's MCP integration closes the maintenance gap with a knowledge base that auto-updates from merged PRs.

- Date: 2026-06-04
- Tags: claude-code, mcp, ai-coding-assistants, documentation, developer-tools

---
Claude Code's official documentation answers setup questions well: installation paths, commands, hooks, sub-agents, pricing tiers, MCP configuration. What it leaves to you is the harder problem: how to give Claude Code context about your architecture, your conventions, and the reasoning behind your decisions, and how to keep that context accurate while your codebase changes weekly. This guide covers the setup and pricing essentials first, then the three context mechanisms (CLAUDE.md, skills, and MCP) and how Falconer closes the maintenance gap by giving Claude Code a knowledge base that updates itself from merged PRs.

You've read the Claude Code setup guide, installed it via npm or the desktop app, configured your API key, and worked through the hooks and sub-agents documentation. The reference material covers commands, pricing tiers (Pro at $20, Max plans, API token costs), VS Code and terminal installation steps, and how to connect MCP servers to tools like Linear or Postgres. The gap shows up the moment you try to use it on a real codebase: Claude Code has no map of your services, no memory of why your team chose certain patterns, and no awareness of the architectural decisions living in old Slack threads. CLAUDE.md, skills, and MCP give you places to inject that context, but keeping those files accurate as your code evolves is manual work the documentation barely touches.

## TLDR

- Claude Code's official docs cover installation, commands, and configuration but leave context strategy almost entirely to you.

- Install via the native installer (no dependencies, Anthropic's recommended path), npm (npm install -g @anthropic-ai/claude-code, Node.js 18+), the VS Code or JetBrains extensions, the desktop app, or the web.

- Pricing runs through your existing Claude plan: Pro at $20/month, Max at $100 or $200/month, Team Premium seats at $100/seat/month billed annually, or API pay-as-you-go.

- CLAUDE.md, skills, and MCP servers all accept company context, and all three require manual maintenance as your code and conventions change.

- Falconer's MCP integration gives Claude Code read-write access to a knowledge base that auto-updates from merged PRs.

## What Claude Code documentation covers (and what it doesn't)

Anthropic's official Claude Code docs walk you through the expected ground: installation, CLI commands, configuration flags, hooks, sub-agents, and the permissions model. They're solid reference material for getting the tool running and understanding what each flag does. The API docs and SDK references cover token handling, model selection, and authentication. If you need to know how a specific command works, the answers are there.

Where the documentation thins out is the part that matters for daily use inside a real codebase. How do you feed Claude Code your team's architectural decisions, naming conventions, or the reasoning behind that unusual retry pattern in your billing service? The official docs describe the mechanisms (CLAUDE.md files, skills, MCP servers) but leave the strategy of populating them with accurate, current company context almost entirely to you. That gap is where most teams stall.

## How to install Claude Code across environments

Claude Code runs in four forms, and picking the right one depends on where you already spend your time.

- Terminal CLI: the native installer is Anthropic's recommended path and requires no Node.js or other dependencies (a curl script on macOS and Linux, PowerShell on Windows, or Homebrew on macOS). The npm install -g @anthropic-ai/claude-code path still works and requires Node.js 18+.

- VS Code and JetBrains extensions: install from the respective marketplaces. These wrap the CLI inside your editor so you can issue commands without leaving your project.

- Desktop app: a standalone app for macOS and Windows. Useful if you prefer a dedicated window over terminal tabs.

- Web interface: accessible at [claude.ai](http://claude.ai) with no local install at all.

The most common stumbling block on Windows is a broken PATH after the npm global install. If claude returns "command not found," run npm config get prefix and confirm that directory is in your system PATH. Restarting your terminal session after the fix is easy to forget and accounts for most lingering issues.

Full setup details live in Anthropic's official setup guide.

## Claude Code pricing breakdown: Pro, Max, API, and team plans

Claude Code doesn't have its own price tag. You access it through your existing Claude subscription or API account, so the plan you're already on determines your limits. Plans and figures below are current as of June 2026; on the Team plan, note that Claude Code is only available on Premium seats, not Standard.

| Plan | Monthly cost | Claude Code access |
| --- | --- | --- |
| Pro | $20 | Included, usage-capped |
| Max (5x) | $100 | Higher usage ceiling |
| Max (20x) | $200 | Highest individual ceiling |
| Team Standard | $25 monthly | Not included |
| Team Premium | $125 monthly | Included, 6.25x Pro usage |
| API (pay-as-you-go) | Token-based | Full flexibility, no cap beyond spend |

For API users, Verdent's Claude Code pricing analysis, based on Anthropic's published averages, puts the typical cost at $6 per developer per day, with 90% of users staying under $12/day.

![](https://falconer.com/api/file/s3/images/1780634281822-ouzty.png)

## What is CLAUDE.md and what goes in it?

CLAUDE.md is the first file Claude Code reads when it enters your project. It sits in your repo root and accepts two broad categories of content: semantic context (architectural decisions, service boundaries, naming conventions) and absolute references (directory layout, build commands, test scripts).

A well-structured CLAUDE.md typically includes:

- Project overview and high-level architecture, giving the agent a map of how services relate to each other

- Directory structure with brief explanations of each top-level folder so file lookups start in the right place

- Build, test, and deploy commands the agent can run without asking

- Coding conventions and style rules that keep generated code consistent with your existing patterns

- Key dependencies and the reasoning behind each choice

Without this file, Claude Code defaults to inferring context from whatever code it can see in the current session. With it, the agent starts from your team's actual decisions instead of guessing. Avinash Selvam's breakdown of Claude Code internals walks through the mechanics in more detail.

CLAUDE.md is a static file, though. You write it, commit it to your repo, and it stays exactly as written until someone updates it manually.

## Skills: teaching Claude Code specialized knowledge

Skills are modular instruction packages that teach Claude Code how to handle domain-specific tasks, like generating migration scripts or writing API tests that follow your team's patterns. They follow the Agent Skills open standard, making them portable across tools that support it. Structurally, each skill is a directory containing a SKILL.md file: YAML frontmatter between `---` markers (with at minimum a name and a description that tells the agent when to use it) followed by the markdown instruction body, meaning the steps, conventions, and output format the agent should follow for that task category, plus any supporting scripts or reference files.

You store skills in a .claude/skills/ directory in your repo (or globally in \~/.claude/skills/ for cross-project use). A migration skill, for example, might specify which ORM to target, how to name migration files, what rollback patterns your team requires, and which tests to run before committing. Instead of re-explaining those conventions in every prompt, the skill encodes them once and the agent applies them consistently.

The loading mechanism uses progressive disclosure. Claude reads skill metadata at startup to know what's available, but only fetches the full instruction set when the current task is relevant. A skill for database migrations stays dormant while you're refactoring a React component, and only activates when the task description or file context signals a schema change. This keeps the active context window lean without sacrificing depth when it matters.

### When to write a skill versus a prompt

- If you find yourself pasting the same multi-step instructions repeatedly, that repeated sequence belongs in a skill

- If the task requires domain knowledge that changes infrequently (test conventions, deployment checklists), codify it once as a skill so every teammate can use it

- If the instructions are short and context-dependent, a line in CLAUDE.md is simpler and easier to maintain

## MCP integration: connecting Claude Code to external tools and data

Model Context Protocol (MCP) is an open standard that lets Claude Code talk to external systems directly. Instead of copying data into a prompt, you configure an MCP server, and the agent can query it mid-task.

Practical examples look like this:

- A Linear MCP server lets Claude read open issues, check ticket status, or pull acceptance criteria while planning a feature

- A Postgres MCP server lets Claude query your database schema to generate accurate migrations

- A Slack MCP server gives the agent access to conversation history for context on recent decisions

You configure servers with the claude mcp add command or in a .mcp.json file at your project root, which you can commit to git so the whole team shares the same setup; user-scoped servers live in \~/.claude.json. Keeping documentation in sync with these external systems requires ongoing maintenance. Anthropic maintains a registry of community servers, and writing a custom one is straightforward if your toolchain has an API.

The constraint is the same one that applies to CLAUDE.md and skills: MCP servers surface live data, but they only know what you point them at.

## Why does Claude Code start every session with a blank slate?

Every Claude Code session opens with the same blank slate. The agent has no memory of yesterday's conversation, no awareness of why your team chose event sourcing over CRUD, and no map of which services talk to each other. It knows how to write code. It does not know how to write your code, which is the same context gap that slows down [engineer onboarding](https://falconer.com/guides/reduce-engineer-onboarding-time/) when new teammates join.

The three native mechanisms covered above (CLAUDE.md, skills, MCP) give you places to inject context, but they share a structural limitation: someone has to write and maintain that context by hand. CLAUDE.md drifts the same way any static doc drifts. Skills freeze the moment your conventions evolve. MCP servers return live data from external tools, yet they can only surface what you've explicitly wired up.

Claude Code can accept company context. The real bottleneck is keeping that context accurate as your codebase, decisions, and team knowledge change weekly.

## How to give Claude Code persistent context with Falconer's MCP integration

We built the @falconer/mcp package to close the gap between what Claude Code can accept and what teams can realistically keep current. Once configured, it gives the agent live, read-write access to your [Falconer knowledge base](https://falconer.com/guides/ai-knowledge-bases-engineering/) during any coding session.

The read side means Claude Code can pull architecture specs, service ownership maps, and decision rationale without anyone pasting context into a prompt. The write side is where things shift structurally: when Claude Code updates a service or changes an API contract, it can push changes back into the docs inside Falconer. Every session leaves your [company brain](https://falconer.com/guides/how-to-build-company-brain/) more accurate, not less.

Because [Falconer's MCP](https://falconer.com/guides/falconer-mcp/) knowledge layer auto-updates from merged PRs and connected sources, the context Claude Code reads tomorrow reflects what your team shipped today.

The agent detects available tools at runtime, so there is no hardcoded prompt scaffolding to maintain. You wire it up once in your MCP config, and Claude Code operates with organizational memory that persists across sessions, teammates, and projects.

![](https://falconer.com/api/file/s3/images/1780634293607-eq5yuo.png)

## Final thoughts on context infrastructure for Claude Code

The official documentation gets Claude Code installed and configured in an afternoon. Making it useful on your codebase is a different job, and it comes down to whether the context you feed the agent stays true as the code changes. CLAUDE.md, skills, and MCP servers are the right mechanisms; maintaining them by hand is where teams fall behind. Sign up for Falconer to give the agent read-write access to a knowledge base that stays current automatically, so context accuracy stops being a manual bottleneck and starts being infrastructure that maintains itself.

## FAQ

### How do I make Claude Code remember context between sessions?

Natively, it doesn't: every session starts fresh, and CLAUDE.md is the only context that persists, frozen at whatever was last committed. Connecting an MCP server to a maintained knowledge base changes that. Falconer's MCP integration gives Claude Code organizational memory that persists across sessions, teammates, and projects, and stays accurate because the knowledge base updates from merged PRs.

### What should I put in a CLAUDE.md file?

Project architecture, directory structure, build and test commands, coding conventions, and key dependencies with the reasoning behind each choice. Keep it focused, since CLAUDE.md loads into every session and a bloated file costs context window on every task. It's also static, so anything that changes weekly is better served through an MCP connection to a maintained source.

### How do I keep CLAUDE.md up to date automatically?

You can't with Claude Code's native tooling: CLAUDE.md only changes when someone edits and commits it. The pattern that works is keeping CLAUDE.md thin (commands, conventions, directory layout) and serving everything that changes often through an MCP server backed by a knowledge base that updates from merged PRs, which is what Falconer's integration provides.

### Do I need Node.js to install Claude Code?

Only for the npm method, which requires Node.js 18 or later. The native installer is Anthropic's recommended path and has no dependencies: a curl script on macOS and Linux, PowerShell on Windows, or Homebrew.

### How much does Claude Code cost for a team of developers?

Claude Code itself has no separate price: you access it through your existing Claude plan. On the Team plan, Claude Code requires Premium seats at $100 per seat per month billed annually ($125 monthly); Standard seats don't include it. API access runs roughly $6 per developer per day on average, token-based with no usage cap beyond spend.

### What's the difference between CLAUDE.md, skills, and MCP in Claude Code?

CLAUDE.md is best for project-level architecture and build commands, skills work for reusable domain-specific instruction sequences (like migration checklists), and MCP connects Claude Code to live external data sources. For context that changes weekly with your codebase, Falconer's MCP server handles all three categories and keeps them current automatically.

### How do I give Claude Code access to my company's internal documentation?

Configure an MCP server that connects to wherever that documentation lives, or write it into CLAUDE.md if it's small and stable. The structural problem is maintenance, since docs go stale unless something updates them. Falconer's MCP integration gives Claude Code read-write access to a knowledge base that updates itself from merged PRs and Slack threads.

### Can documentation update automatically when a pull request merges?

Not with Claude Code alone; you can script doc updates through hooks or CI, but then you're maintaining that pipeline by hand. Falconer does this natively: when a PR merges, it scans the diff, detects which docs reference the changed code, and flags or applies updates. Through its MCP server, Claude Code reads that corrected context in the very next session.