Your LLM's Context Window Is Not a Filing Cabinet

I'm currently in South Korea and Anthropic's had some great meetups here. I recently met one of the top Claude Code users at an event. His name is Jin Hyung Park (Sigrid Jin). He has three Claude Max plans and his token usage so far is 13.8 billion. That's insane. Anyways, he shared how he uses Claude everyday in his workflow and his insights are invaluable so I wanted to share the knowledge.

I've learned a lot by attending meetups, researching and talking to other heavy Claude Code users. So today I wanted to specifically talk about something that's been all over my news feed the past few weeks:

Claude Skills.

If you're new to Claude Code or using commands, agents, hooks and skills with coding agents, don't worry. I'll walk you through step by step and show you how to use the official Skills marketplace and create your first skill.

At the end of the day you only get really about ~176k of useful context to work with, anything above 200k and you'll noticeably see the model start to sweat. This is where Skills can really come in handy. They're either used by the model autonomously only when needed or called directly by the user i.e "hey Claude use the skill-creator to help me build a skill for [your task]"

This is another long, and comprehensive post with a walkthrough example sooo heres the:

TL;DR

Problem: Your LLM's context window is finite (~176k useful tokens). The old MCP method wastes it by preloading all your tools, eating 30k-40k tokens upfront, even if you don't use them.

Solution: Claude Skills. Skills use "progressive disclosure" - they load a tiny ~100 token description first, then load the full skill (~5k+ tokens) only when the model decides it's needed.

Benefit: You save ~98% on the "always-on" token cost. This leaves your context window free for the actual conversation and task, not just a list of potential tools. Less preload. More go.

How-to: We walk through creating your first skill, either using Anthropic's skill-creator or by manually setting up the .claude/skills/ folder, a good SKILL.md, and optional scripts/references with a fun example.

The Big Unlock: The community is already winning by converting old MCP servers to the Skill format and building reusable libraries (awesome-claude-skills). The fastest teams curate a living library of Skills and stop re-prompting the same work.

Core Principle: Stop re-prompting the same work. Promote what works into a Skill. Build a living toolbox that grows with you instead of bloating your context.

---

A Brief History Of MCP vs Skills

MCP (Model Context Protocol)

Think: a standard way to bolt Claude to GitHub/Slack/Salesforce/Postgres/etc. It works. But load ~15 servers and you're eating 30k–40k tokens before writing a single line of code. All those definitions sit in the context window, whether you use them or not. And again, if you take into account you only get about ~176k of useful context, that eats up roughly about 22% of your usable window even before you begin your task.

Skills

So a Skill is just a folder that explains how to do a thing: SKILL.md + examples, and optionally some runnable scripts like code/resources. It uses progressive disclosure:

• Initial load: name + short description (~100 tokens).
• Only when Claude decides it needs the Skill do you load the rest.

Concrete numbers:

• GitHub via MCP: ~8 tools → ~8,000 tokens always on. and if you're using all 93 of the tools, that's another 20,000 tokens used up just for loading tool descriptions.
• Same thing as a Skill: 100 tokens upfront; ~5,000 when actually used → you save ~3,000 tokens on a typical call path, and you don't context-bloat the whole convo before it starts.

Less preload. More go. Yay.

Note: I'm not against MCP at all by the way. I love using the Linear MCP so that Claude can create and update tickets for me. But it's important not to use them carelessly as your context window is precious. Long live MCP and Skills.

---

Let's create a Skill together

I'm a big fan of providing easy-to-follow along examples to help you learn by doing so let's create our first skill together.

1. First, it's helpful, but optional, to clone the official Skills from Anthropic because it also includes a helpful skill-creator skill you can use as a template to creates Skills more easily with Claude directly through the chat.
2. Git clone the official Anthropic Skills repo here
3. Add the skill-creator to your projects .claude/skills folder
4. Ask Claude to create a skill for you to do [your task]. For example, I asked Claude to use the skill-creator to create a new skill that takes a pdf file and creates a slide deck

If you're not using the 'skill-creator', you can create Skills manually:

5. Create a folder in .claude/skills/name-of-your-skill
6. Edit your SKILL.md first. This file is required and choose a good description

Bad example of SKILL.md description: "Helps with pdfs"

Good example: "Convert PDF documents into professional slide presentations. This skill should be used when users need to transform PDF content (research papers, reports, books, documentation) into PowerPoint presentations or other slide formats. It intelligently extracts, summarizes, and organizes PDF content into digestible slides with proper formatting, bullet points, and structure."

Example SKILL.md:

---
name: pdf-to-slides
description: [TODO: Complete and informative explanation of what the skill does
and when to use it. Include WHEN to use this skill - specific scenarios, 
file types, or tasks that trigger it.]

---

# Pdf To Slides

## Overview

[TODO: 1-2 sentences explaining what this skill enables]

7. Optionally add folders like references and scripts to enhance your Skills capabilities

.claude/skills/references/slide_design.md snippet:

# Slide Design Best Practices

## Overview

This reference guide provides comprehensive guidelines for creating effective, professional slide presentations from PDF content. Use these principles when converting PDFs to ensure the resulting slides are clear, engaging, and impactful.

## Core Design Principles

### 1. The 6x6 Rule
- Maximum 6 bullet points per slide
- Maximum 6 words per bullet point
- Prevents cognitive overload
- Ensures readability

### 2. Visual Hierarchy
- **Title**: 36-44pt font
- **Subtitles**: 28-32pt font
- **Body text**: 18-24pt font
- **Captions**: 14-16pt font

... and so on

.claude/skills/scripts/pdf_to_slides snippet:

"""
PDF to Slides Converter

Converts PDF documents into PowerPoint presentations by intelligently extracting
and organizing content into slides.

Usage:
    pdf_to_slides.py <pdf_file> <output_file> [--max-words-per-slide=150] [--extract-images]
    
Examples:
    pdf_to_slides.py report.pdf presentation.pptx
    pdf_to_slides.py document.pdf slides.pptx --max-words-per-slide=100
    pdf_to_slides.py paper.pdf output.pptx --extract-images
"""

# Import Libraries here

# Classes here
class PDFToSlidesConverter:
    """Converts PDF content to PowerPoint slides."""
    
    def __init__(self, max_words_per_slide=150, extract_images=False):
        self.max_words_per_slide = max_words_per_slide
        self.extract_images = extract_images
        self.presentation = Presentation()
        
    def extract_pdf_content(self, pdf_path):
        """Extract structured content from PDF."""
        doc = fitz.open(pdf_path)
        content = {
            'title': '',
            'sections': [],
            'metadata': {
                'pages': doc.page_count,
                'author': doc.metadata.get('author', ''),
                'subject': doc.metadata.get('subject', ''),
            }
        }

... and so on

Okay so now we've either 1) Created a new skill via the skill-creator or we've manually created one of our own. Here's what mine looks like now:

.claude/
  └── skills/
      └── pdf-to-slides/
          ├── references/
          │   └── slide_design.md
          ├── scripts/
          │   ├── pdf_to_slides.py
          │   └── smart_summarizer.py
          └── SKILL.md

8. Test out your new skill. Here's where the fun begins :)

Remember, the description in your SKILL.md is important. It should be descriptive enough so that Claude knows when to use that specific skill.

You'll know your new skill is being used when you see:

After a few minutes, looks like things are working as expected🤞

The final output from Claude:

And it works! We now have a powerpoint presentation created from our arbitrarily chosen Arxiv PDF. Amazing.

The slides are… ugly, boring and there are far too many (293 slides) but this is amazing considering I did not edit the SKILLS.md, scripts, or references at all and let Claude do all the work.

9. Edit your scripts and code until you're happy with your Skill and now Claude can reuse your Skill over and over without you needing to explicitly tell it to do so.

I can now go in and edit the references folder files like the slide_design.md to customize the slides in the future for any slide deck I want to create.

If you've found my content helpful so far and want to support more content like this, you can donate a coffee here ☕︎

---

Where the community is already winning with Skills

• skill-creator (from Anthropic): describe a job in plain Korean; it drafts the SKILL.md. Surprisingly accurate.
• Skill Seekers: point it at a docs site and it manufactures a Skill from the API surface + usage patterns. Presets for React, Vue, Django, Godot, FastAPI. People testing with Godot report the generated Skill outperforms "vanilla Claude" on domain depth.
• Official Skills packs: real .docx/.pptx/.xlsx/.pdf generation-layouts, charts, images, formulas. canvas-design renders layout to PNG/PDF; brand-guidelines applies your colors, fonts, tone.
• Internal comms Skills: standardized status reports and announcements that actually respect house style - without a human style cop.
• Awesome-claude-skills: CSV analyzers, research assistants, YouTube transcript extractors, EPUB parsers, git automations… and more are landing weekly. here and here

This is what maturity looks like as users of coding agents: we're not crafting bespoke prompts anymore; we're building repeatable operating procedures.

The fastest teams curate a living library of Skills and stop re-prompting the same work.

---

When to use what (rules of thumb)

Use Skills when:

• You have ~10+ tools and most aren't used every turn.
• Context space is tight or latency matters.
• Tools are independent and can be lazily revealed.

Stick with MCP when:

• You only need 1–5 tools.
• You require complex OAuth/device-code dances or persistent DB sockets.
• Cross-platform standardization is the priority.

Hybrid is healthy: core, always-needed tools via MCP; everything else as Skills.

---

Patterns that compound

SOP-as-Skill: if you generate the same doc/report repeatedly, encode the SOP in SKILL.md. Same quality, every time.

Tokenize sensitive fields before the model. Replace PII in logs with placeholders; restore only at the API boundary. Keys/creds via env vars, never into context.

Harvest & Promote: when an agent writes something useful, save it as a file and promote it into a Skill. Your toolbox grows; your future prompts shrink. Good.

Most Claude runtimes already ship with batteries: numpy, pandas, matplotlib, requests, bs4, Pillow, etc. Skills can import and go. That's how you turn "make a report" into "parse data → chart → export → attach," without round-tripping megabytes through the model.

And because Skills load incrementally, you preserve the context window for the conversation you're actually having, not the toolbox you might someday need.

---

If you only remember three things

1. Progressive disclosure beats preload. Don't pay for what you're not using.
2. Code owns control flow. Keep the model focused on reasoning, not babysitting loops.
3. Promote what works. The fastest teams curate a living library of Skills and stop re-prompting the same work.

---

Found my post helpful? Supporting my work helps keep these posts coming and unlocks your invitation to the Humaine Interface inner circle.

Thanks for reading xx
― Ashley

---

Links to explore

My last article on Mastering the Claude Code Interview where I talk about Claude Commands and Agents:

• I Mastered the Claude Code Workflow

Official Anthropic Documentation:

• Claude Skills Documentation

Simon Willison's notes on Claude Skills:

• Claude Skills are awesome, maybe a bigger deal than MCP
  • Anthropic this morning introduced Claude Skills, a new pattern for making new abilities available to their models…

Karo with Product with Attitudes write up:

• Claude Skills Guide

"Awesome Claude Skills" collections (general + enterprise):

• awesome-claude-skills by travisvn
• awesome-claude-skills by BehiSecc

Skill generators:

• skill-creator
• Skill Seekers

---

Follow me on the internet:

X.com
Github
Personal Website
LinkedIn
Humaine Interface: My Substack