PTENES
MODULE 3.7 · WRAP-UP

⚙️ Optimization: from a skill that works to one that works well

Your `gerar-ata` is already running. This module wraps up Track 3 by showing you how to make a skill leaner and more reliable—and connects everything you learned with the WAT framework from Track 1: a skill is literally a workflow packaged with its own tools.

6
Topics
30
Minutes
Advanced
Level
Wrap-up
Type
0 of 60%
1

📌 Pin IDs

New here? Set an ID means giving a section, file, or step in the skill a stable name instead of referring to it by position (“the second rule,” “the third step”). If someone reorders `skill.md` later, a positional reference breaks; a named reference still works.

✓ With a fixed ID

  • ✓"See section `#formato-saida`" — stays correct even if `skill.md` grows

✗ Reference by position

  • ✗"See step 3" — silently breaks if someone inserts a new step before it

💡 Practical Tip

In `gerar-ata`, instead of "see the section above," use a Markdown heading like `## Output format` and refer to it by that title — it's easier to maintain as the skill grows.

2

📚 Preloading documentation

Remember module 3.2: level 3 (references) is only read when `skill.md` says to read it. But sometimes it’s worth bringing a short summary directly into level 2 (the body of `skill.md`) instead of always saying “go fetch it”— if the data is small and used every time, each “trip to fetch it” is one more round that costs time and tokens for nothing.

Example: a preloaded list of fixed participants

## Participantes frequentes (já sei quem são, não precisa perguntar)
- João (financeiro), Marcela (produto), você

## Formato de nomes desconhecidos
Se aparecer nome que não está na lista acima, pergunte o
cargo/área antes de fechar a ata.

💡 Practical Tip

Practical rule: if a piece of information is small (a few lines) and used in almost every run, preload it. If it’s large or rarely used, keep it in a separate reference.

3

🤝 Delegate to sub-agents

New here? One subagent it’s a “helper agent” that the main conversation can call on to handle part of the work on its own, in parallel, and return only the result—without filling up the main conversation with every intermediate step. More advanced skills delegate steps like these when a task is large or can run in parallel with another.

Example — a skill.md excerpt that delegates

## Passo 3 — revisar o texto longo
Se as anotações passarem de 2 páginas, delegue a revisão de
consistência a um sub-agente dedicado, e só incorpore o
resultado final na ata — não processe o texto inteiro na
conversa principal.

⚠️ Attention

Delegating everything, even small tasks, is overkill — each subagent has its own startup cost. Save delegation for truly large or parallelizable pieces.

4

🔁 The honest cycle: invoke → observe → fix → repeat

The unvarnished truth: no skill is perfect from the start. The `gerar-ata` you tested in module 3.6 probably still gets something wrong in some cases—a misspelled name, an ambiguous decision, an empty section. That’s normal. What separates a good skill from an abandoned one is going through the cycle several times: invoke it again, see where it went wrong, fix a line in `skill.md`, repeat. In practice, most skills only become truly reliable after about the tenth run.

1. Invoke 2. Observe 3. Fix 4. Repeat ~10 rounds until it becomes reliable

Caption: the four steps repeat in a circle — the skill gets more reliable with each round, not on the first try.

5

🔗 Skill = workflow + WAT tools

Closing the loop with Track 1: the framework WAT (Workflow, Agent, Tools) describes any automation as a workflow (what to do, and in what order) carried out by an agent, using tools (what to do it with). A skill is exactly this workflow+tools pair, packaged in a reusable format: the entire `skill.md` é the written workflow; the scripts and reference files are the tools this workflow triggers.

skill.md = Workflow (what to do) Agent follow the step-by-step instructions and triggers the tools when needed scripts/ + referências/ = Tools (what to do things with)

Caption: skill = packaged WAT workflow; scripts and references = the tools that workflow uses; the agent is what runs both together.

6

🏁 Wrapping up Track 3

You’ve gone through seven modules: the anatomy of a skill (3.1), why 3 loading levels keep 20 skills from weighing you down (3.2), the 6-step framework for writing a good one (3.3), how the description triggers the right use (3.4), when to choose a project folder or a global folder (3.5), built `gerar-ata` from scratch (3.6), and now you know how to optimize and be honest about the improvement cycle (3.7).

✅ Copy-run—a quick audit of one of your skills

Objective: asking Claude Code to review an existing skill against everything you’ve learned in this track.

Leia a skill em ~/.claude/skills//skill.md e me
diga: a description é específica o bastante? o corpo tem
passo a passo claro? há algo que deveria virar referência
separada? sugira 3 melhorias objetivas.

How to verify: suggestions should cite specific passages from your `skill.md`, not give generic advice.

Final checklist for Track 3

  • ☐ I can explain what a skill is to a nontechnical person without jargon
  • ☐ I understand why 20 installed skills don't weigh down the context
  • ☐ I wrote and tested my first skill
  • ☐ I know when to use a project folder vs. a global folder
  • ☐ I know what pinning IDs, preloading, and delegating to subagents mean

Review exercise: choose one of your repetitive tasks outside this course and sketch its `skill.md` following the 6-step framework in module 3.3 — you don’t need to implement it now, just write the outline.

✅ Module Summary

✓
Optimization: Fixed IDs, selective preloading, deliberate delegation to sub-agents.
✓
Honest cycle: invoke → observe → fix → repeat, with no shortcuts.
✓
Skill = packaged WAT: skill.md is the workflow; scripts/references are the tools.

Next learning path:

Track 4 — Deployment: moving off your laptop