A skill is a workflow packaged in a special folder and triggered by a slash command — loaded on demand without bloating the context. The diagram below shows the skill becoming a reusable command and, on the right, the context budget with zones indicating when to give /compact and when to give /clear.
Illustrative diagram — conceptual recreation of skills and the context budget, not a real screenshot.
📦 What Skills Are
What it is: a skill is basically the same thing as a workflow (the W layer of WAT) — instructions in markdown — except stored in a special folder, the .claude/skills, with each skill in its own subfolder and a skill markdown file inside. The difference is in where it lives and in how it is triggered: the skill is exposed as a slash command, a reusable command you call by name. Under the hood, the skill can still invoke tools (Python scripts for search, scraping, and document generation), so the WAT framework remains intact.
💡 Why learn
Skills matter for four reasons: consistency (the same process every time, without re-explaining), token savings (load only when invoked), sharing (the same skill serves an entire team) and reliability (wrap up complex steps that are easy to forget, so you delegate and forget). Best of all, you don't need to know how to write skills — describe the workflow and ask the agent to turn it into a reusable slash command.
- •Consistency: the process doesn’t vary between runs.
- •Tokens: loaded on demand, not every session.
- •Shareable: distribute the folder, and the team uses the same skill.
- •Reliable: wraps the step that's hard to remember.
🗂️ Skill ≠ CLAUDE.md
CLAUDE.md stores only the rules for every session (project purpose, main objective, framework). Instructions per task belong in skills — that way, you avoid exceeding the context window. Having 20–50 skills doesn’t bloat the context the way one giant CLAUDE.md would, because skills are only loaded when called.
Key concepts
Same as a workflow.
One folder per skill.
Invoked by name.
Loads only when used.
⚖️ Skill vs. typing
What it is: not every request deserves to become a skill. The decision is simple: package it when the gains in reuse and consistency outweigh the effort of creating the skill; type it directly when the request is simple and one-off. Packaging too early is overkill; too late means tedious repetition.
✓ It's worth creating a skill
- ✓It's a repeated workflow — you do this every week.
- ✓A consistency matters — the result needs to be the same every time.
- ✓The instructions are complex or easy to forget.
- ✓Other people from the team will run the same process.
✗ Just Type It Instead
- ✗It's a one-off task, that you won't repeat.
- ✗You're still experimenting and the process changes.
- ✗The instruction fits in one sentence — a skill would be overkill.
- ✗There’s no reuse in sight—packaging it would only add friction.
🎯 Why learn
The practical rule: in the third time that you type nearly the same long instruction, stop and ask the agent to turn it into a skill. Before that, typing is faster; after that, the skill pays for itself in just a few uses.
Key concepts
Skill's #1 trigger.
Output is always the same.
Easy steps to forget.
One-off? Just type.
✉️ Skill in practice: /draft-email
What it is: a hands-on build of a draft an email — created, tested, refined, and invoked as a slash command. Its anatomy is a folder .claude/skills with a subfolder for each skill, each with a SKILL.md that defines name, description, the arguments expected and the steps. Arguments here might be bullet points with the key information, recipient, and tone. It becomes callable as /draft-email — slash commands were unified with skills, comparable to built-ins like /clear.
name: draft-email description: Rascunha um e-mail polido e conciso, sem enrolação. ## Argumentos - bullets: pontos-chave do conteúdo - destinatario: para quem é (ex.: cliente) - tom: profissional | amistoso | formal ## Comportamento 1. Se faltar algum argumento, pergunte antes de escrever. 2. Escreva um e-mail claro, direto e sem enchimento. 3. Salve o rascunho em temporary/outputs/email.md
🛠️ Why learn — the build workflow
Create in Plan Mode
Ask for a skill that follows the official format, describing inputs (bullets, recipient, tone), behavior, and where to save the output. Approve the plan.
Clear context and invoke
Clear the conversation and call /draft-email. Invoking it without arguments prompts the agent to ask for the missing information.
Reuse with new inputs
Clear again, call the slash command with a different recipient/tone, and get a fresh output following the same rules. To modify the skill, just ask the agent to change it.
🎯 Practical tip
Clear the context between uses for clean, consistent runs. The skill ensures the same rules (tone, concision, structure) on every invocation — that's exactly what makes delegate and forget different from having to re-explain everything.
Key concepts
name · description · args.
bullets · destination · tone.
Without args, it prompts you.
Clear and call again.
🖼️ Slide deck generator
What it is: another full build in the WAT framework — a workflow that takes a document and generates a professional presentation from it. Reuse the standard flow: CLAUDE.md (WAT) → workflow + tools → run → iterate. In Plan Mode, the agent asks setup questions (tool language, how to extract key points, presentation style). The workflow reads the document, extracts the points, and creates the presentation file.
# Workflow: documento → slides ## Entrada Documento em temporary/resources/ (10–16 páginas) ## Passos 1. Ler o documento e extrair os pontos-chave. 2. Estruturar em títulos + bullets por slide. 3. Gerar a apresentação via ferramenta Python. ## Saída Deck (ex.: 26 slides) em temporary/outputs/
🎨 Why learn — iteration and design
You don’t need to understand the Python tools—just check whether the workflow logic produces the desired output. There’s always room to improve the design: colors, fonts, corporate vs. casual style, a mix of text and bullets instead of bullets alone. And there’s a powerful shortcut for reuse: override a public slide design skill to the workflow elevates the visual design without you having to manually explain each design need.
- •Input: document in temporary/resources.
- •Output: professional deck in temporary/outputs.
- •Upgrade: a design skill built into the workflow.
🎯 Practical tip
Run the build with permission bypass only after approving the plan. And remember: once you’re comfortable with the basic workflow, plugging in a dedicated design skill is the cheapest way to improve the deck’s quality—the skill brings the design knowledge you don’t want to rewrite.
Key concepts
CLAUDE.md → wf+tools.
Extract and structure.
Color, font, style.
Overrides the workflow.
🗣️ 5 prompting patterns
What it is: five prompting patterns that produce consistent, high-quality results. They turn vague requests into instructions the agent can execute well—and shift your role from "operator" to "manager of a specialist."
Define the goal, not the steps
Describe the result you want; let the agent decide the sequence. You describe the “what,” not the “how.”
Be specific about the output
Format, structure, file names, and where to save them. The clearer the expected output, the less rework.
Plan Mode first, then execute
Approve the plan before letting the agent act; only then switch to execution mode (permission bypass).
Give feedback, not fixes
“I like the structure, but the tone is too formal” works better than “this is wrong.” The feedback updates the workflow behind the scenes.
Treat the agent as a specialist
You’re the manager; it’s the developer. Delegate the technical work and focus on clearly describing the goal and evaluating the result.
🎯 Why learn
Together, these five patterns connect the self-improvement loop: by giving feedback (not corrections) on a well-specified result, the agent adjusts the underlying workflow — and the next run already comes out better without you having to explain again.
Key concepts
What, not how.
Format and location.
Plan first.
Instead of fixing it.
📉 Context Rot & Thresholds
What it is: context rot is the gradual decline in quality as a single session gets longer. The root cause lies in how attention mechanisms work: errors tend to appear after ~60% of window usage, when it fills up with noisy history and recent messages (possibly irrelevant) push the core rules out of the model’s focus.
| Zone | Range | What to do |
|---|---|---|
| Green | 0–50% | Safe—keep working. |
| Yellow | 50–70% | Start thinking about compacting. |
| Orange | 70–85% | Run /compact proactively. |
| Red | 85%+ | Run /clear and start over. |
⚠️ Why learn — the warning sign
Context rot is real: after ~60% usage, expect more errors. Don’t reuse an overloaded conversation for unrelated work. If you’ve already corrected the agent about the same thing more than twice, the context is probably cluttered—clear it and start over with a better prompt.
Key concepts
Errors start here.
The window becomes noise.
Green to red.
Sign of dirty context.
🧹 /clear vs /compact
What it is: two commands for managing context, with different purposes. /clear é o full reset from the conversation; /compact is a smart summary that preserves the key information and compresses the rest. Knowing which one to use—and when—is what keeps quality high in a long session.
/compact — smart summary
- •Keeps the essentials and compresses the history.
- •Use in the middle of a task when the context grows.
- •Ideal in the orange zone (70–85%).
/clear — full reset
- •Clears the entire conversation — starts from scratch.
- •Use with switch tasks or when quality drops.
- •Ideal above 85% or after 2+ repeated corrections.
🎯 Why learn
Rule of thumb: compact when you’re still on the same task but the context has grown; clean up when you switch tasks or when quality has already degraded. Compacting too late won’t recover context that’s already gone stale—in that case, it’s better to clear it and start over with a better prompt.
Key concepts
Summarizes, doesn’t delete.
Complete reset.
Compact.
Clear.
💸 Token Savings
What it is: a set of strategies to minimize token usage and context waste. Since the agent rereads the entire conversation with every message, long sessions cost more per message—so keeping the context lean also keeps costs low.
🪙 Why learn — the 5 strategies
- •One task per session, then clean up — don't carry over old context.
- •Define "done" (e.g., "exactly 75 profiles") so the agent stops instead of getting stuck in a loop.
- •Use skills for specialized workflows, instead of bloating the CLAUDE.md.
- •Turn off unused MCPs — each one adds tool definitions to the context.
- •Keep CLAUDE.md concise (under ~500 lines, content from the entire session only).
⚠️ Common pitfall
Without a defined endpoint, the agent may search too much or get stuck in a loop, wasting tokens for no reason. And each active MCP server uses context through its tool definitions—leaving on the ones you don't use is silent waste.
Key concepts
Clear afterward.
For the loop.
Instead of CLAUDE.md.
Turn off idle ones.
✅ 12 final tips
What it is: a consolidated checklist of 12 best practices for building high-quality agentic workflows. It’s the operational summary of the entire track—use it as a checklist before and during each build.
- Always start in Plan Mode.
- Be clear about the goal (e.g., "75 profiles of tech CEOs," not "build a scraper").
- Define what it is “ready”.
- Treat the agent as specialist — you manage; it develops.
- Manage the context proactively (compact at ~70%, clear when switching/breaking, 1 task/session).
- Use the self-improvement loop through specific feedback.
- Store API keys in environment files.
- Test with different inputs.
- Save battle-tested skills.
- Start from scratch when freeze.
- Turn off Unused MCPs.
- Track the build early to learn and catch errors.
🏁 Why learn — the practical challenge
Put it all together in your own end-to-end build: meeting-notes-to-actions, a PDF generator, an email drafter, or a workflow for your job. Use WAT, start in Plan Mode, let the agent ask questions, approve the plan, then switch to permission bypass. Use at least one MCP and/or skill when it makes sense (don't force it). Test the output with 2–3 different inputs — a workflow that only works with one input is, in practice, a one-off script.
Key concepts
Always first.
Specific and measurable.
2–3 entries.
Never put a key in the chat.
🧠 Quick check
You’re in the middle of a task, the context has reached ~75%, and the agent is still focused on it. Which command should you use?
📌 Module Summary
Next Module:
3.1 — From Local to Always-On: GitHub & Trigger.dev