The most useful text in a long AI chat is not the answer at the bottom. It is the corrections you typed on the way there: not that tone, shorter, a customer has to understand this. Close the window and they are gone, so next week you type them all again.
Every argument you win is a brief you throw away
A project manager we know receives business cases where nobody has pinned down what they actually want. That is not a failure on their side. Customers describe what they hope for, and converting hopes into definitions a team can build from is what he is there to do.
His routine is to give the AI the business case plus every scrap of the owners' notes and ask for definitions. What comes back reads like a board presentation.
He needs "a new customer can open an account and place a first order without phoning support." He gets something closer to "deliver a best-in-class, customer-centric onboarding journey." So he objects, it redrafts, and the cycle repeats until the wording is plain.
He wins every time. Then the next project lands and the whole argument restarts from zero. He gives it a full day about once a week, which comes to roughly fifty working days a year spent winning the same fight.
Which AI he uses makes no difference, and everything below works in any of them. If you genuinely enjoy the fight, keep having it. But look at what he leaves behind each time: his corrections are a complete set of instructions for the job, written by the one person who knows what good looks like, and they get closed with the window.
A skill is that argument, saved where the AI reads it first
Most assistants can now store a set of instructions and apply them in a later chat. Claude calls them skills, and ChatGPT and Copilot offer the same idea under different names. Whatever the label, a skill is a written brief the AI reads before it starts work, so you stop explaining yourself from scratch.
It is not a program. When we opened up a public status report skill, it turned out to be a five-step procedure in plain English, with no code in it at all. If you can brief a new colleague by email, you can read a skill.
Where it lives depends on the tool. In Claude, Anthropic's help page Use skills in Claude shows where to add one. In other assistants, save the same text wherever that tool keeps instructions you can reuse.
Sentence one: turn the finished argument into a skill
Wait until the definitions are finally right. Then, while the whole argument is still sitting in the chat, send this:
Based on what we just discussed, write down my corrections and advice, and turn them into a skill.
Keep the file it produces. Next week, start the new conversation with that skill loaded. The whole change costs one sentence, typed into a conversation you were having anyway.
For the business case job, a first version might read something like this. Yours will come from your own corrections, which is the point.
Business case definitions
- Use this when I share a business case and the owners' notes and ask for requirement definitions.
- Write each definition so the customer could read it aloud and agree or disagree with it.
- One sentence for what the customer wants, then one for how we will know it is done.
- No phrases a customer would need translated: best-in-class, customer-centric, drive value, strategic alignment.
The first skill will be bad, and sentence two fixes that
Expect the first version to be poor, possibly dreadful. On its second outing you will still be correcting it, only less often, and that is how this is supposed to go.
That is why every chat that runs on the skill ends with a second sentence:
Summarise the lessons from this conversation, including every correction I gave you, and update the skill.
Replace the old version with the updated one. Now each argument leaves something behind instead of evaporating.
Do not judge the method on the first four versions, because none of them will give you exactly what you want. You have not studied skill writing, and the method does not ask you to.
For us, the reports started arriving close to right, with far fewer corrections, at roughly the tenth run. That is an impression from doing it, not a measurement.
This is what we mean by a self-improving system. Self-improving means the system keeps what it learns. Every run produces a correction, and the correction goes into the skill itself rather than into your head, so next month costs less effort than this month.
Nothing retrains itself while you are away: it improves because you end each run with sentence two.
One good example teaches more than a page of rules
Once a report comes out the way you like, have the AI strip it back into something reusable:
Turn this into a blank template I can reuse, with the same headings, order and length.
Store the template in the same folder as the skill, together with one report you would be happy to send exactly as it is. Start each new chat with all three attached: the skill, the template and the example.
The example does the work that paragraphs of instructions cannot. The AI sees the length, the tone and the headings you actually want, the same way a new colleague learns more from last month's best report than from a style guide. From that point, what used to take a day of back and forth is mostly small edits.
You do not need markdown, or anything else technical
Skills are usually written in something called markdown, and that is where some people stop. It is less exotic than it sounds.
A markdown file is an ordinary text file in which a handful of symbols do the formatting: a hash sign (#) at the start of a line marks a heading, and a hyphen (-) marks a list item. A file with no symbols in it at all will also do the job.
Learning the symbols is optional. Draft in ordinary sentences and let the AI do the conversion. Markdown has become the usual format for this job and gives the file some structure, and that is all it does.
Technical skill is not the barrier here. Familiarity with the buttons and the file formats speeds things up, but the change that matters happens in your head: you stop asking for an answer and start asking for a system. The question moves from what to type next to what the setup should deliver on every run.
Hand the steps that never change to a script
When the skills are behaving, turn to the parts of the job that never vary. Populating an identical document layout. Building the same table, column for column.
Work that must come out identical every time and needs no judgement is not a job for AI, because anything an AI redoes, it can also reinterpret.
The business case job splits cleanly. Deciding what a wish actually means is judgement, so it stays with the skill. The table the definitions go into, same columns in the same order every time, is not.
For that part, ask the AI to write a small program, one it runs itself rather than you:
Write me code that produces this template exactly, every time, without any analysis.
After that, the layout is produced the same way on every run, with no room for creative reinterpretation. When you cannot tell which steps qualify, put the question to the AI:
Which part of my process must be done exactly the same way every time, and could be code?
You never read the code, and it does not matter which programming language the AI chooses. You are the manager here, so you judge the output, not the code: a correct result means the language choice was fine. Some programming knowledge will take you further faster, but nothing here requires it.
The whole roadmap, in order
- Start in the chat and have the argument one last time.
- Before you close the window, turn the conversation into a skill with sentence one.
- Use the skill next time, and end every use with sentence two.
- Add a template and one really good example to the skill's folder.
- When the skill gives you what you want with only minor adjustments, move on to the next job and its skill.
- When your skills are dependable, pick out the steps that must never vary and have the AI turn them into code.
Anything that needs judgement lives in the skill. Anything that only needs repeating lives in a script. Built up a step at a time, that combination is the system: good work in your format, with no weekly fight attached.
Win the argument once, then keep it
Next week's argument is already scheduled. It arrives with the next business case, or the next report, and it will go the way it always goes.
Win it one more time, then type sentence one before you close the window. The skill will be rough. Keep it anyway: sentence two is how it gets better.
You need nothing more than that to start. If you want to build this properly, with a method instead of trial and error, AI Systems with Claude teaches it step by step. You build five working systems for real project work, a sprint report built from your board export and standup notes among them, and you keep them.


