The problem with prompts: they're a snapshot
For years the method has always been the same: write a well-crafted prompt, copy it, reuse it, hope it works. And structured prompts do work, but they have one huge limit: they're a snapshot. Your work, though, is dynamic: style evolves, mistakes change, standards shift.
When Claude gives you back something that doesn't convince you (text too long, badly formatted links, too many bullet lists, inconsistent tone), the typical reaction is to add another corrective prompt. But that only fixes today's output, and tomorrow you start over from scratch.
- 1 It doesn't cover every exception in your real case.
- 2 It doesn't remember corrections from previous sessions.
- 3 It doesn't evolve when your style changes.
- 4 It grows long, fragile and hard to maintain.
A prompt is perfect for a one-off request. But when you want to repeat a process with consistent quality, you need something else.
From skill to self-evolving skill
A Claude Skill isn't a longer prompt: it's a reusable package of instructions. A folder containing a main file (usually SKILL.md), examples, operating rules, reference files and any scripts. It tells Claude the method, the format and the constraints of a task: it builds a reusable behavior, not a throwaway answer.
The self-evolving skill adds one piece: at the end of a session you tell Claude "take the mistakes that came up in this chat and update the skill so it doesn't repeat them next time." It's not magic: it's a routine of controlled improvement.
-
Prompt
A one-off request. When you need to do something once.
-
Prompt template
A reusable request. When you often repeat a similar request.
-
Skill
A codified process. When you want quality, consistency and method.
-
Self-evolving skill
A skill that improves after mistakes. When you want a system that grows.
The shift is mental: not "find the perfect prompt," but "build a skill that improves every time I use it."
The method: the Skill Evolution Loop
The cycle is always the same, and it fits in five steps. You don't need to run them all every time: you do it when a mistake repeats, when your standard changes or when you've given an important correction that needs to become permanent.
- 1
Create the first skill
Start from a working version, not the Bible. Define when to use it, what it should produce, what tone to keep, which mistakes to avoid, and what output format to follow. A few clear lines are enough: you refine it later.
- 2
Use it on a real case
No sterile examples. Throw real work at it and watch: did it respect the tone? Did it format the links right? Did it overdo the bullet lists? Did it pad things out? Did it make stuff up? Every slip-up is material.
- 3
Correct it in chat
When something's off, correct it explicitly on the spot. "No, I don't want the links separate: put them inside the words, as markdown hyperlinks." These corrections aren't venting, they're the fuel for the evolution.
- 4
Evolve the skill
At the end of the session, ask Claude to reread the whole conversation, pull out mistakes, corrections, preferences and anti-patterns, and rewrite the skill so those mistakes don't come back. Don't overhaul it: improve only what needs it.
- 5
Save the new version
Read and validate the proposal before saving it: you stay in control. Keep a mental version history (v1, v2, v3…). The skill is an asset that lives over time, not a chat message that gets lost.
The golden rule: fixing an output saves you time today, fixing the skill saves you time every time after.
The ready-made prompt to evolve it
This is the prompt you paste at the end of a session, inside Claude or in Claude Code where the skill lives as a file. It asks for a diagnosis of the mistakes and an updated version, changed surgically, not overhauled.
I want to evolve the skill we've used in this conversation.
Analyze all the work done and produce an update to the skill.
Focus on:
- mistakes you made;
- explicit corrections I gave you;
- style preferences that emerged;
- formats I always need respected;
- behaviors to avoid;
- useful examples to add;
- instructions that need to be made clearer.
Output required:
1. a short diagnosis of the mistakes;
2. new rules to add to the skill;
3. any rules to change;
4. any anti-patterns to include;
5. an updated version of the skill text.
Don't overhaul the skill.
Improve it surgically.Always read the proposal before saving it: you stay in control. The real value isn't the single skill, but a portfolio of operational skills (writing, analyzing, building guides, turning voice notes into text) that keep improving over time.
The limits to keep in mind
The prompt isn't obsolete: it's become the base layer. Stop searching for the magic phrase every time, and build a system that learns from your mistakes, your corrections and your standards. AI stops being «a tool you query» and becomes a workshop: you bring the real work, it produces, you correct, the process improves. That's the new way of working.
