> ## Content Index > Fetch the complete content index at: https://jonathancanales.com/llms.txt > Use this file to discover other available public pages before exploring further. # Claude Skills: Skills vs Repeated Prompts - URL: https://jonathancanales.com/en/claude-skills-vs-repeated-prompts/ - Published: 2026-08-07T14:00:00.000Z - Updated: 2026-10-25T20:29:13.000Z - Description: The repeated prompt and the skill compared: drift, context, discovery and activation versus direct invocation, automatic loading and supporting files. - Author: Jonathan Canales - Tags: #en, Technology and tools Everyone who works with Claude Code for a few weeks accumulates the same gesture: open the note where they saved that instruction they already wrote, copy it, paste it into the session. The code review checklist, the commit format, the deploy recipe, the way a report gets prepared. The repeated prompt is the oldest tool in the kit, and it works. The question worth asking in August 2026 is when that gesture should turn into a skill, because the two pieces solve the same problem with different economics. This guide compares both paths with practical judgment: what each one does well, where repetition starts to cost, what a skill buys exactly, and how to migrate a mature prompt into one while keeping what already works. ![Doodle of a photocopier stacking identical sheets, the folded corner of the top sheet orange](https://jonathancanales.com/content/images/2026/10/pair15-doodle1.png) ## What the repeated prompt does well The hand-pasted prompt has real virtues. It is immediate: zero preparation, zero structure, zero files. It is flexible: every time you paste it you can adjust it for the case at hand, drop a section, add a caveat, shift the emphasis. And it is disposable, which is an advantage when the task itself is disposable. For one-time work, the manual prompt always wins. Exploring a new library, asking for an analysis you will likely run once, trying a format idea to see whether it convinces you. Building infrastructure for something that happens once is overengineering, and overengineering costs too: files to maintain, names to remember, premature decisions about how a task that is still changing will get done. There is also a social virtue to the manual prompt: it circulates easily. You paste it into a team message, someone tries it, comments, proposes a change, and the improvement travels through the conversation. During the exploration phase that lightness speeds up collective learning, even though the same lightness is what later produces drift when everyone keeps their own copy. The repeated prompt is also the natural laboratory of the future skill. The first five times you do a task, the procedure is still moving: you discover which step is extra, which detail is missing, which order works best. That exploration phase belongs to the prompt, and freezing it early produces skills that get in the way rather than help. ## Where repetition starts to cost The cost of the repeated prompt grows in four directions, and all four are quiet. The first is drift. Every copy of the prompt lives its own life: you improve the version in one note, forget to update the other, and three months later you have four variants of the review checklist asking for slightly different things. Consistency, the whole reason for having the checklist, erodes exactly where it mattered most. The second is context cost in every session. A long procedure pasted by hand occupies full context each time, whether you use all of it or only part. Multiplied by several runs a day, that context is capacity you take away from the real conversation. The third is discovery. A prompt saved in your notes exists only for you and only when you remember to look for it. The teammate who could use it hardly ever sees it; you yourself, six months later, may have forgotten you had it. The fourth is activation. With the manual prompt, the burden of recognizing "this is task X, prompt X applies" is yours on every occasion. On fast days, the checklist stays in the drawer precisely when it was most needed. ## What a skill buys exactly A skill packages that same procedure into a piece Claude Code loads and runs as part of its toolkit. The minimal piece is a directory with a SKILL.md file: a YAML header between markers carrying the name and description, and below it the markdown body with the instructions. The guide on [what skills are and how to create one](https://jonathancanales.com/en/claude-skills-what-they-are-how-to-create) covers the full anatomy; what matters here is what the format buys over the repeated prompt. It buys direct invocation: the directory name becomes a command, and typing /review-pr runs your procedure like any built-in command. The find-copy-paste gesture disappears. It buys automatic invocation: the description in the header tells Claude when the skill applies, and Claude loads it on its own when the task matches. You ask "review this diff for me" and your review checklist comes into play even when you forgot to think of it. The burden of recognizing the occasion moves from you to the tool. It buys cheap context: the name and description stay visible to Claude at all times, but the full body of the skill loads only when used. A library of ten detailed procedures at rest occupies a minimal fraction of what a single one would occupy pasted by hand every day. It buys supporting files: a skill is a directory, so it can carry templates, helper scripts and reference documents that load when the procedure needs them. The output format now fits in a template file instead of living inside the prompt. And it buys real sharing: project skills live in .claude/skills inside the repository, so they reach the team with the same clone. The procedure stops being a personal good and becomes a piece of the project, versioned alongside the code it describes. ![Doodle of a box on a shelf with a spark above it, the spark orange](https://jonathancanales.com/content/images/2026/10/pair15-doodle2.png) ## The migration signal: the third repetition The Claude Code documentation itself gives the criterion in one sentence: create a skill when you keep pasting the same instructions, checklist or multi-step procedure into chat, or when a section of your CLAUDE.md has grown into a procedure rather than a fact. A skill body loads only when used, so long reference material costs very little until you need it. Translated into an operating rule: the third time you reach for the same prompt, the task is already a candidate. The first time is exploration; the second, coincidence; the third, a pattern. By then the procedure has stabilized enough to be worth freezing, and the savings from every future run start to accumulate. Three quick tests confirm the candidacy. The frequency test: the task comes back at least weekly. The stability test: the steps vary little between runs. The length test: the instructions span more than a paragraph or include a checklist. A prompt that passes all three and still lives in your notes is paying too much rent. ## How to migrate a mature prompt into a skill A well-run migration takes under an hour and follows a concrete order. Start from the best version of the prompt, usually the most recent. Compare it with the old variants and keep what each one contributed; migration is the natural moment to close the drift. Then separate instructions from reference. What Claude must do on every run goes into the SKILL.md body; the formats, long examples and lookup documents go to supporting files in the same directory. That separation is what keeps context cheap. The most delicate step is writing the header description, because that sentence governs automatic invocation. A good description says what the skill does and when it applies, in the vocabulary you would use to ask for the task: "Summarizes uncommitted changes and prepares a commit message. Use when the user asks what changed or wants a commit." A generic description leaves the skill asleep; a well-aimed one turns it into a reflex of the tool. Test both activation paths before calling the migration done: invoke the skill by hand with its command and confirm it runs the full procedure, then ask for the task in natural language and watch whether Claude loads it on its own. When automatic loading falls short, the description is the first place to look. Close the loop with a real iteration: use the skill for a week and adjust. The first freeze is rarely the final one, and editing one file is far cheaper than editing four notes. To see finished skills solving everyday work, the collection of [useful examples for daily work](https://jonathancanales.com/en/claude-skills-useful-examples-daily-work) shows several patterns in action. ## The prompt as a stage, the system as the destination Seen from a distance, the repeated prompt and the skill are stages of the same lifecycle: the task is born as exploration, matures as a stable prompt, and graduates as a skill when repetition confirms it is worth it. Skipping the prompt stage freezes immature procedures; staying in it forever pays the repetition tax indefinitely. The ecosystem pushes in the same direction. Anthropic introduced Agent Skills on October 16, 2025 as a common format for Claude and Claude Code, and the December 18, 2025 update added organization-wide management, a directory of partner-built skills and the publication of the format as an open standard portable across tools. A skill you package today is an asset that travels with you, shares with your team and works on more than one surface. It is worth underlining what the format adds to team memory: a project skill reviewed in the same flow as the code receives the same care as any piece of the repository. Changes to the procedure go through review, the history of adjustments stays recorded, and the current version is the same for everyone. The loose prompt in a personal note lives outside that circuit, with everything that implies for shared quality. The final rule stays simple: the prompt for discovering how the task gets done, the skill for running it the twentieth time with the same quality as the first. The third repetition is the signal, the description is the delicate piece, and a week of real use is the test that closes the loop. ## Sources - ["Extend Claude with skills", Claude Code documentation](https://docs.anthropic.com/en/docs/claude-code/skills?ref=jonathancanales.com) - ["Introducing Agent Skills", Anthropic](https://www.anthropic.com/news/skills?ref=jonathancanales.com)