How to Use Claude Code & Skills: A Complete Guide

How to Use Claude Code and Its Skills: The Complete Guide for Power Users

Stop treating Claude Code like a chatbot. The developers running 1,000+ ML experiments per day aren't copy-pasting prompts—they've built a system where Claude remembers what the team learned last Tuesday, warns you before you repeat failed experiments, and writes up its own documentation. That system is built on skills, and if you're not using them yet, you're leaving most of Claude Code's value on the table.

Since Anthropic launched skills as a formal feature, the gap between casual users and power users has widened dramatically. This isn't about typing faster prompts. It's about transforming Claude from a conversational assistant into a persistent, team-aware execution engine that encodes your organization's hard-won knowledge and deploys it on demand.

Let's break down exactly how skills work, how to build them, and how teams at companies like Sionic AI are using them to eliminate redundant work.

---

What Are Claude Code Skills? (And Why They Replace Your Old Workflow)

Skills in Claude Code are self-contained instruction packages that extend what Claude can do beyond its base capabilities. Think of them as upgrade modules you install into Claude's working memory—except unlike the ephemeral context of a single chat session, skills persist, can be shared across teams, and trigger automatically when relevant.

According to Anthropic's official documentation, skills follow the open Agent Skills standard, which means they work across multiple AI tools, not just Claude. Each skill lives in its own directory with a SKILL.md file at its center. That file contains two critical components:

• YAML frontmatter that tells Claude when to use the skill (via a description that Claude pattern-matches against your requests)
• Markdown instructions that tell Claude how to execute when the skill activates

Here's the key architectural insight: skills load on-demand rather than cluttering every conversation. Unlike dumping everything into your global CLAUDE.md (which Claude reads every single session), a skill's body only enters context when Claude decides it's relevant—or when you explicitly invoke it with /skill-name.

This matters because context window management is everything in modern AI workflows. Claude Code already gives you powerful context control through project-level CLAUDE.md files and global preferences. Skills add a third layer: procedural knowledge that activates situationally.

For detailed comparisons of how different AI coding assistants handle context management, check out our reviews on Cloudy Unicorn.

---

The Anatomy of a Working Skill: Build Your First One in 5 Minutes

Let's look at a concrete example from Anthropic's own documentation—a skill that summarizes uncommitted git changes and flags risks:

---
description: Summarizes uncommitted changes and flags anything risky. Use when the user asks what changed, wants a commit message, or asks to review their diff.
---

## Current changes

!`git diff HEAD`

## Instructions

Summarize the changes above in two or three bullet points, then list any risks you notice such as missing error handling, hardcoded values, or tests that need updating. If the diff is empty, say there are no uncommitted changes.

Notice the ! prefix before the git command? That's dynamic context injection—Claude Code runs the command and inlines its output before Claude ever sees the prompt. This means the skill always works with live data, not stale assumptions.

To create this skill:

1. Make the directory: mkdir -p ~/.claude/skills/summarize-changes
2. Save the above as ~/.claude/skills/summarize-changes/SKILL.md
3. Invoke with /summarize-changes or simply ask "what did I change?"

The directory name becomes the command. The description field is your prompt engineering surface—this is where you compete for Claude's attention when multiple skills might apply.

---

Skills vs. Slash Commands vs. CLAUDE.md: When to Use What

Claude Code's feature set has grown dense enough that even experienced users confuse these three mechanisms. Here's the definitive breakdown:

The evolution is clear: custom commands have been merged into skills. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy and function identically. But skills add crucial capabilities that commands lack:

• Directory of supporting files (templates, reference data, sub-prompts)
• Frontmatter control over who/what can invoke them
• Subagent execution for isolating complex work
• Dynamic context injection for live data

If your "command" has grown beyond a simple prompt—if it needs to reference templates, run git operations, or delegate to specialized subagents—promote it to a skill.

---

Real-World Skill Architecture: How Sionic AI Runs 1,000+ ML Experiments Daily

The most illuminating skills case study comes from Sionic AI's engineering team, documented in their Hugging Face community post. Their problem is familiar to any research-heavy team: knowledge lives in Slack threads and disappears within weeks.

A teammate spends three days testing ColBERT parameter configurations. They discover that 4,000-character text chunks make FDE (Fixed Dimensional Encoding) outperform MaxSim for retrieval. Genuine breakthrough—saves weeks of work. Buried in a Slack thread. Two months later, someone else runs the same experiments from scratch.

Sionic AI's solution encodes exactly how sophisticated skills infrastructure should work:

The /retrospective Skill

After an experiment session, you type /retrospective. Claude Code:

1. Reads through your entire conversation history
2. Extracts what you tried, what failed, what worked, and the final parameters
3. Structures this into a formal SKILL.md with working code, environment details, and—critically—the mistakes made along the way
4. Opens a pull request to the team's shared skills registry

The /advise Skill

Before starting new work, you type /advise. Claude Code:

1. Queries the team's skill registry
2. Finds relevant historical experiments (e.g., "someone ran pruning experiments on Ministral3 last month")
3. Surfaces warnings about approaches that failed and hyperparameters that succeeded

This is collective memory as infrastructure. Not "Claude remembers our last chat" but "Claude knows what the team learned, even from conversations it wasn't present for."

The skill files they generate follow rigorous structure:

---
name: grpo-external-vllm-server
description: "GRPO training skill based on external vLLM server using ms-swift. Usage scenarios: (1) When performing GRPO training with the vLLM server running on a separate GPU, (2) When encountering errors related to vllm_skip_weight_sync, (3) When encountering OpenAI API response parsing errors. Verified on gemma-3-12b-it."
author: Hojin Yang
date: 2025-12-08
---

# grpo-external-vllm-server - Research Notes

## Experiment Overview

| Item | Details |
|------|---------|
| **Date** | 2025-12-08 |
| **Researcher** | Hojin Yang |
| **Goal** | Setup GRPO training using external vLLM server in ms-swift and fix bugs |
| **Model** | google/gemma-3-12b-it |
| **Environment** | NVIDIA A100-SXM4-80GB x 8, ms-swift, vLLM, DeepSpeed ZeRO2 |

The frontmatter's description field is doing heavy lifting here—it's the prompt that determines whether this skill activates for relevant queries. The more precise your description, the better Claude's routing.

---

Advanced Skill Patterns: Beyond the Basics

Controlled Invocation: Who Decides When Skills Fire?

By default, Claude automatically decides when to load a skill based on its description. But you can constrain this:

• auto: true — Claude can invoke without asking (use for low-risk, well-scoped skills)
• auto: false — Requires explicit /skill-name invocation (safer for destructive operations)
• user: true, claude: false — Only you can trigger it, not Claude's automatic routing

This matters for team settings where you don't want Claude accidentally running expensive operations or making assumptions about which skill applies.

Subagent Isolation: The /explore Pattern

Complex skills can delegate to subagents—specialized Claude instances that work in parallel. Anthropic's documentation shows this with a research skill:

---
description: Research a topic thoroughly using the Explore agent
subagent: explore
---

The subagent gets its own context window and tool access, preventing the main conversation from getting polluted by intermediate research steps. When it finishes, only the synthesized result returns to your main session.

Dynamic Context Injection: Live Data Without Manual Updates

The ! prefix in skill files triggers command execution at skill-load time:

## Current context

!`git log --oneline -10`
!`cat package.json | grep version`

This means skills self-update. A deployment skill always sees the latest commit history. A code review skill always analyzes the actual current diff, not what you remember about it.

---

Team Skills: Installation, Sharing, and Governance

For individual users on Free, Pro, and Max plans, skills live in ~/.claude/skills/ and are private to your account. But the real power emerges with team features:

Organization-Provisioned Skills

Team and Enterprise plan owners can push skills organization-wide from Organization Settings > Skills. Once provisioned, every team member sees these in their skills list with a team indicator. Members can toggle them on/off but can't modify them—ensuring consistency.

Sharing Custom Skills

Individual skills can be shared:

1. Navigate to Customize > Skills
2. Select a skill you created
3. Click "Share" → choose specific colleagues or "Entire organization"

Shared skills appear in recipients' "Shared with you" section, grayed out until enabled. They're view-only—recipients use them but can't edit. When you update the original, everyone automatically gets the new version.

Installation from ZIP

For skills not in your organization directory:

1. Package your skill folder as a ZIP file
2. In Customize > Skills, click "+" then "Upload a skill"
3. Select your ZIP

This is how you distribute skills across organizations, or install third-party skills from community repositories.

---

Built-in Skills You Already Have (But Might Not Know About)

Claude Code ships with several bundled skills that work via prompt-based orchestration rather than fixed logic:

These activate automatically when Claude detects relevant intent, or you can invoke them directly. Unlike hardcoded commands, they're instruction templates that Claude interprets with full access to its tools—meaning they adapt to your specific context rather than running rigid scripts.

---

Skills in Practice: The 15-Minute Setup That Changes Everything

If you're currently using Claude Code without skills, here's the fastest path to catching up:

Step 1: Audit your repeated work

What do you paste into Claude repeatedly? Status report formats? Debugging procedures? Analysis frameworks? Each of these is a skill candidate.

Step 2: Create your first skill

mkdir -p ~/.claude/skills/my-first-skill
cat > ~/.claude/skills/my-first-skill/SKILL.md << 'EOF'
---
description: "Your description here"
---

Your instructions here.
EOF

Step 3: Test, refine, share

Use it for a week. Refine the description based on whether it triggers when expected. Then package and share with your team.

The Claude How To repository by community contributor luongnv89 provides an excellent structured learning path—from slash commands through memory, checkpoints, skills, hooks, MCP, subagents, and advanced features. It includes copy-paste templates and Mermaid diagrams showing how features connect. For teams serious about Claude Code adoption, this fills the gap between "feature exists in documentation" and "we know how to combine features into production workflows."

---

The Strategic Case: Why Skills Beat Documentation

Traditional documentation rots. The Sionic AI team identified the core failure mode: "The hard part of knowledge management has never been storage. It's getting people to write things down."

Skills solve this by making Claude do the writing. The /retrospective command turns the natural endpoint of a work session—"I'm done, let me close this"—into knowledge capture. No additional doc tool. No context switching. The conversation you already had becomes the structured documentation.

More critically, skills create actionable knowledge. A Confluence page about ColBERT parameters is something you read. A skill about ColBERT parameters is something Claude applies—automatically routing relevant queries, suggesting configurations, warning about pitfalls. The same information, but embedded in your workflow rather than parked in a wiki.

---

Conclusion: The Skill-First Organization

The teams getting the most from Claude Code in 2025 share a common pattern: they've stopped thinking of it as a better search engine or faster code writer, and started treating it as an organizational memory system that encodes, distributes, and activates expertise on demand.

Skills are the mechanism that makes this possible. They're not a feature to check off your list—they're an infrastructure layer that compounds in value as your team grows and learns. The first skill you build saves you minutes. The hundredth skill your organization shares saves you from repeating three days of failed experiments that someone else already figured out.

Start with one skill that captures something you explain repeatedly. Iterate on its description until it triggers reliably. Share it with one colleague. That small investment creates the foundation for everything else—subagents that delegate to specialized skills, hooks that trigger skills automatically, and eventually a team memory that outlasts any individual's tenure.

The future of AI-assisted development isn't smarter models alone. It's smaller, composable, shareable units of expertise that make every team member as capable as your best performer on their best day. Skills are how you build that future—one SKILL.md at a time.