# Configuration & System

Welcome to the second module. This module was genuinely complicated for me to build. A lot of the concepts I'm going to explain here are kind of under the hood: how Claude Code works.

They get a bit meta because you start understanding them as you build your projects in Claude Code and your file systems. Once you start building your whole system, you understand the power of these concepts and why they matter. I was struggling a bit with how much to front-load at the beginning so you understand the mechanics, versus how much to show you in projects.

There's something at the beginning I need to mention, which is actually the most important thing regarding any LLM: the concept of the context window.

The context window is Claude's working memory. LLMs are trained on general knowledge of the internet, but they are very average if you only rely on that. The way you make them powerful is to give them specific, focused context for what you want to do. Think of it like copying your brain, or copying the collective knowledge of your company. Everything you do needs to be around capturing enough context for the agents to do what you ask with precision, less hallucination, less errors, and a high degree of quality.

As people say in the community: context is like milk. It's best when it's fresh and condensed. If it gets old, it can cause LLMs to hallucinate. They drift, forget your rules, become inconsistent, and the quality of the work drops.

So there are two important rules to remember.

**Rule 1: Never overload the context.** If you start having different conversations in the same chat window with Claude, after a while the context fills up. I'll show you what actually loads into the context every time you start a session: every conversation you have back and forth, all the responses Claude gives you — all of it goes into context. There are limits for both Opus and Sonnet. Opus has a larger context window; Sonnet has a bit less. You should never fill them up and you should always be clinical about your context: keep it fresh and relevant. If you don't, the context gets bloated, Claude forgets things, and quality drops. Many of you have experienced these frustrations when working with ChatGPT.

Claude has been built with mechanisms to control this context. When you start chatting, everything in that session goes into Claude's short-term memory context. All the files we build will be the long-term context for Claude. When we have files in a project folder, those files are accessible on demand to Claude Code because it's running in that folder. LLMs are also trained on general knowledge, and they have access to the short-term context: what's loaded in the current conversation and session.

**Rule 2: Keep separate tasks in separate conversations.** Every task that does not depend on another task should be in its own conversation. Just like with ChatGPT, you wouldn't combine planning a trip with building a competitive product analysis in one chat. If the context of one task isn't relevant to another, keep them separate.

There are two commands that will be your best friends. The first is `/clear`, which wipes the context completely. The second is `/compact`, which summarizes and condenses the context to make space for fresh information. Compact is useful when you want to continue in the same chat and aren't done with your task but need more space. You can also specify what you want the summarization to focus on before running it. For example, if there's been a lot of back and forth but you want to keep focusing on strengthening the product strategy, compact will condense the context while preserving as much detail as possible about that topic.

For running commands: if a command needs an argument, put a space after the command and then write the argument before pressing enter. Most commands execute on enter with no argument needed.

When the context ring hits around 50%, I always run compact. In the interface, the ring appears when the context is 50% full and turns orange as it fills. When it hits 100% it auto-compacts, but you should never let it get that far. From experience, as you start filling it more, Claude gets sluggish, gives wrong answers, and becomes more expensive.

Now let me show you what gets loaded into the context when a session starts. It's okay if you don't fully understand these concepts yet — I'll explain each one in detail in this module.

When a session starts, there's already something in the context. Usually what gets loaded first is a file called CLAUDE.md. This is where your rules, preferences, and instructions live. It's a markdown file that sits at the root of your project — at the same level as your folders and files. I'll walk you through an example and show you how to create it.

CLAUDE.md exists at two levels: global and project. At the global level, anything that is always true and needs to be in the context of all conversations for all your projects can sit in the global CLAUDE.md. I'll show you where the global and project CLAUDE.md files live. The project CLAUDE.md sits inside your project folder. Both get loaded when a session starts.

You also have something called auto memory: Claude saving notes by itself and learning from your corrections and back-and-forth in the chat. As you're having a conversation, Claude decides what is worth capturing for future sessions and stores it at the global level, in project folders within that global directory. I'll open it up and show you an example later.

Skills are also loaded into your context. Skills are the abilities, tools, and capabilities of your agents. Tools also get loaded into the context of every session — these are the connections you have with external apps. For example, connections to Notion, Gmail, Google Calendar, Linear, or Jira. At the beginning of every session, the fact that these are available to Claude gets loaded via some configuration files.

You can already see: a session is not empty when it starts. It gets preloaded with context. It's very important to keep this layer lean and optimized so that when you start a session, you're feeding it the right information from the start without bloating it. This also matters for cost: the more irrelevant context you put in your chat, the faster you burn through your context window limits.

There's an interesting command you can use to see what's loaded in the context of your session. When I ran it, I could see the MCPs that are connected. MCPs are like a USB connection from Claude Code to any of the apps you're using. Think of it as a converter. The ones I have in my Claude AI account aren't on my machine, so I'll walk you through in the next module how to connect different tools. But you can already see there are some skills loaded in this context that aren't even present in my project — they're sitting at the global level for Claude Code.

The output also shows system prompts, tools, skills, and messages. And you can see how much of the context is free for that model. If you switch to Opus, more will be free because Opus has 1 million tokens — about five times the tokens in Sonnet — so it can hold a much larger context. Sometimes when you need a very big context in your session, it's better to use Opus, though it will be more expensive.

Now let me go back to the global and project level overview. Here's the structure: at the global level, you have a CLAUDE.md that is available to all of your projects. When Claude Code is running in a folder, it only has access to that folder. It doesn't look outside unless you explicitly tell it to. The global CLAUDE.md is the exception: it's accessible across all your projects and machines. Skills at the global level are also accessible across all projects. For example, I'll show you how to build a skill that converts any PDF to markdown and make it available globally so it works across all projects.

Memory lives at the global level and is automatically compiled by Claude. You can inspect it, but you rarely touch it manually. I'll explain it more in the advanced module. MCPs are also global and give Claude connections to different tools. All of these concepts exist at the project level as well: a project-specific CLAUDE.md, project-level skills, project-level memory, and project-level MCPs.

Now let's make it practical. I'm going to walk through building an agent to help me negotiate my salary. This is something useful for a lot of people. The old approach: go to ChatGPT and ask for generic advice. The new mental model: general advice is not good enough. I want curated context, I want to be confident about the sources, and I want something I can train to improve based on my specific circumstances.

So first I looked for experts on salary negotiation coaching. There's a website called Super Me where you can ask any question and it brings answers from thought leaders and credible people in that space. I asked how to negotiate my salary and it brought in 10 perspectives from different people who are top-notch in the industry. It crawled all their content and surfaced credible sources. Not general information, but specific insights from thought leaders and operators.

I collected two YouTube videos and two articles. I'll show you how to scrape an article as markdown. For YouTube, I transcribed the complete conversations. I'll teach you how to do that later — it requires connecting to a YouTube transcriber MCP. For now I'll bring in the transcripts and build the skill from them.

To capture the article text, I used a Chrome extension called MarkSnip. I navigated to the article, clicked the extension, and it grabbed all the content as markdown. I downloaded it and moved it into my project folder. I did the same for the other article and both YouTube transcripts, creating individual markdown files for each.

Now that I had all this content in the folder, I wanted to show you how to create the CLAUDE.md file. You don't need to create it by hand. You can run the `/init` command and Claude will read all the files, figure out your intention, and take the conversation history into account as well.

When I ran it, Claude initially resisted creating a CLAUDE.md because it said this isn't a code repository and there were only four standalone article files with no clear instructions to write. So here's what I did: I told Claude the intention of the folder and pasted a markdown copy of my LinkedIn profile so it could create a CLAUDE.md that knows my professional background.

I told it: this folder is for loading resources about professional topics at work, and I want it to serve as a career coach. I'm starting with salary negotiation, and from the LinkedIn text I'm about to paste, I want it to figure out my professional background and put that in CLAUDE.md because it will be relevant for most of the skills and conversations in this project.

Claude went ahead and created it.

To show you what a full CLAUDE.md looks like, I opened the one for my personal knowledge base in Obsidian. In this CLAUDE.md I have instructions for all my projects, all the people I know, meeting notes, anything from the web I've clipped, resources, bookmarks. Everything is there, organized and tagged. The CLAUDE.md explains what each folder is about, what templates exist for each file type. For example, a person entry has properties like phone number and all contact information. Meeting notes connect to those person files. When I have a meeting with my manager, it understands from the email who the person is, connects them, and I can look back at all meetings I had with that person.

Obsidian will get a deep dive in the advanced module. But keep in mind: your CLAUDE.md needs to stay concise and lean. The example I showed is quite long. You need to ask yourself with every piece of content: is this necessary in every conversation? If not, it probably doesn't belong in CLAUDE.md. There are commands to optimize its length and content, and you can move some content elsewhere and load it progressively. But everything in CLAUDE.md gets loaded into every single conversation in that project.

Now let's go back to creating the skill. First, let me show you what the structure of a skill looks like.

Skills are how you make agents specialized. Without them, agents are generalists: they can do everything at a surface level, but they won't be expert-quality at anything specific. Through skills you can teach them what output you're looking for, connect them to tools, and define workflows. Think of them as mini-apps: specialized capabilities for agents to do specific things. Write copy for your website, create presentations, synthesize research across sources.

I'm going to create a skill to help me negotiate my salary. The skill is basically a folder with a `skills.md` file as the main file. This gets loaded into every conversation so the agent knows what skills are in its arsenal. It has a name, a description of when the skill is useful, and a high-level description of what it does. The skill can also reference other files that get loaded when the skill is invoked: templates, examples, real samples of good and bad output. You can teach a skill what good looks like, and when you provide feedback, you say what you're not happy with and ask it to update the skill to improve for the future. Claude will figure out which file to update and likely add examples with input-output pairs.

The more you provide at the beginning when creating the skill, the better it performs at first. But you need to iterate to get it to the quality you want. Skills can also write code — especially when connecting to different tools — but you don't need to care about the code. You're communicating the instructions of the job to be done, and Claude figures out how to execute it.

One more thing before creating the skill: plugins are sometimes a combination of MCPs. MCPs are the connection between Claude and the apps you're using. When you install a plugin for a tool like Notion, it comes with both the connection and a package of skills for how the agent should work with those tools: how to search for pages, how to format updates, how to read and manage databases. These are specialized skills that tool companies build for agents to work with their products.

There is an important plugin for creating skills. It's the one that Anthropic built themselves, which provides best practices for skill creation. You want this available across all of your projects, so you install it at the user level. After installing, restart and reload the window in your editor (shift-command-P, then "reload window"). This reloads everything without closing and reopening.

Now before creating the skill, I want to bypass the permission prompts. You may have noticed that every time Claude makes changes or creates files, it asks for permission. Research shows developers accept these permissions 93% of the time. To stop getting blocked at every step, Claude has a mode that auto-accepts all safe commands (not destructive ones like deleting files, but safe operations). I'm going to enable that before creating the skill.

I asked Claude to enable auto permissions at the global level. It went to the settings file in the root Claude folder and updated it. The setting changed the default permission mode to auto. In that same settings file you can see the skill creator plugin listed, the default AI model effort level, and now the permission mode set to auto.

Now I'll create the skill. I switched to plan mode first so I could review the plan before executing. I asked Claude to create a skill to help me negotiate my salary, using all the files under the resources folder, at the project level.

Why project level? When I previously recorded this and it went to the global level, the skill appeared in the marketplace and was available across all projects. But this skill is specific to this demo project for career coaching. I don't want it globally available. If you build a skill that all your projects could benefit from, you create it at the global level. If it's project-specific, keep it at the project level. Another project folder won't have access to it unless you explicitly tell Claude to load it from the demo folder.

Claude created the skill plan: a `.claude/skills/salary-negotiation/` folder inside the project, with a `skills.md` as the main file. The skill has a name, description, trigger condition ("use this skill whenever the user asks anything related to salary"), coaching workflows, core principles, triage, and frameworks. It also pulled my context from the memory file and CLAUDE.md to know my professional background.

The reference files are particularly interesting. At the bottom of the skill it says: "read these on demand, do not load all three at once." Depending on the situation — phone interview, offer negotiation, internal raise — it loads the relevant framework. This is smart context management: it identifies which stage you're at, then loads only the tactic that's relevant rather than dumping all frameworks into context at once.

Once the skill creation finished, Claude gave a summary of what it built and what the skill can do. You can then start testing it on real scenarios. Imagine what you could do if you also had previous conversations with your manager about a raise, or real examples where you could coach this skill on how it would have handled those actual situations.

One last thing to point out: the context ring was at 50% after all this. If I wanted to continue this conversation, I'd run compact and then continue. In the next module I'll show you how to connect useful tools across all your projects, build skills to use those tools, and unlock the full power of Claude Code when it has access to Gmail, Google workspace, and other tools. We'll also sort out the permissions so you don't have to click yes for every future session. See you in the next module.
