Skip to content
Skills Library
AI & agents · Automation

codifying-tasks

/codifying-tasks

Turns recurring work into reusable skills. Use when a task being done now has been done before in this project, when the user says "make this repeatable", "turn this into a skill", "we'll be doing this again", or at the natural end of a multi-step task that will clearly recur. The rule of thumb - do it once by hand, codify it the second time.

Repository
dot-claude ↗
Licence
MIT
Last repository change
12.06.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Turns recurring work into reusable skills. Use when a task being done now has been done before in this project, when the user says "make this repeatable", "turn this into a skill", "we'll be doing this again", or at the natural end of a multi-step task that will clearly recur. The rule of thumb - do it once by hand, codify it the second time.

Triggers from the description

make this repeatableturn this into a skillll be doing this again
Original author description

Turns recurring work into reusable skills. Use when a task being done now has been done before in this project, when the user says "make this repeatable", "turn this into a skill", "we'll be doing this again", or at the natural end of a multi-step task that will clearly recur. The rule of thumb - do it once by hand, codify it the second time.

How it works

  1. When to fire
  2. When NOT to fire
  3. Workflow
  4. Principles
Original SKILL.md headings · 62 lines, 610 words
SKILL.md preview
---
name: codifying-tasks
description: Turns recurring work into reusable skills. Use when a task being done now has been done before in this project, when the user says "make this repeatable", "turn this into a skill", "we'll be doing this again", or at the natural end of a multi-step task that will clearly recur. The rule of thumb - do it once by hand, codify it the second time.
---

# Codifying Tasks

Any task done twice will be done a third time. The second occurrence is the signal to codify it: the procedure is proven, the gotchas are known, and the cost of writing it down is lower than the cost of re-deriving it.

## When to fire

- The task you just completed resembles one done earlier in this project (similar prompt, similar steps, similar output)
- The user signals it: "make this repeatable", "turn this into a skill", "we'll do this again", "same as last time"
- A multi-step workflow just succeeded after trial and error — the corrected path is fresh and worth preserving

## When NOT to fire

- First occurrence of a task — wait for the second; premature codification bakes in guesses
- One-off work that won't recur (a migration, a single deliverable)
- The task is already covered by an existing skill — improve that skill instead (see the correcting-mistakes skill)
- The "procedure" is a single prompt with no steps, decisions, or gotchas — a skill adds nothing over just asking again
- The procedure carries **secrets or one-account specifics** (API keys, tokens, internal hostnames, a particular customer's data) — either skip it, or codify only the generalized shape with those values as arguments; never bake a secret into a saved skill

## Workflow

### Step 1: Offer, Briefly

One sentence, not a ceremony: "This is the second time we've done X — want me to codify it as a skill so next time it's one command?" If the user declines, drop it without argument.

### Step 2: Extract the Procedure from the Session

Reconstruct what actually worked — not an idealized version:

- The steps in the order they actually succeeded
- Decisions made along the way and what drove them
- Gotchas hit and the working resolution (state the correct approach directly; don't narrate the failure)
- Validation used to confirm the output was right
- Inputs that varied between the two occurrences — these become the skill's arguments
- Any secrets or one-account specifics — redact these from the procedure now; they become arguments, never literals

### Step 3: Decide Scope

Pick where the skill lives before authoring, so the file is written in the right place:

- Task specific to this project → `.claude/skills/<name>/`
- Task that recurs across the user's projects → `~/.claude/skills/<name>/`

When unsure, default to the project; promotion to user scope is easy later.

### Step 4: Author via creating-skills

Invoke the **creating-skills** skill (`/compound:creating-skills`) with the extracted procedure as raw material **and the Step 3 scope/save-location**. It handles naming, frontmatter, structure, and quality validation. Keep the scoping dialog short — most answers (procedure, arguments, save location) are already known from the session.

### Step 5: Verify and Hand Off

1. Tell the user the invocation (`/<name>`) and what arguments it takes
2. **A brand-new skill may not appear until the session reloads** — if it doesn't show in the skills list on the next message, tell the user to restart the session (or run `/reload-plugins` for a plugin skill). Don't report failure on the strength of it not showing immediately.
3. Suggest running it on the next real occurrence rather than a synthetic test — and fixing anything it gets wrong via the correcting-mistakes skill

## Principles

- **Codify the proven path.** The skill records what worked, not what should have worked.
- **Gotchas become instructions.** "Use the v2 endpoint" — not "Warning: the v1 endpoint fails."
- **Modular over monolithic.** If the session contained two separable procedures, write two skills.
- **The loop closes.** correcting-mistakes maintains what codifying-tasks creates. Together they compound.

Versions

The database has no other skills named codifying-tasks.

Database snapshot: 13.11.2026 · package version 622aa0086fc6 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100make-repeatable
    Analyze recent work and propose how to make it repeatable. Use when the user says \"make this repeatable\", \"automate this\", \"I want to do this again\", \"turn this into a command\", or discusses creating reusable workflows.
  • 90skill-forge
    Promote a procedure that was worked out end-to-end and verified into a reusable skill file, so the next similar task starts from the solved path. Use when a hard-won procedure succeeds with evidence, when the same multi-step task appears a second time, or when the user says "make this repeatable".
  • 100tasks
    Claude Code task framework for reusable workflows. Use when user asks about "/task:run", "/task:list", "/task:new", "create a task", "global tasks", "local tasks", or needs to run structured multi-step workflows. Triggers on task-related questions or when creating reusable automation.
  • 90skill-distill
    Turns the workflow just completed in the current session into a reusable Agent Skill, capturing the steps that worked, the dead ends, the user's corrections and the verification into a new SKILL.md with supporting scripts. Use when the user says to save this as a skill, make a…
  • 100skill-builder
    Build agent skills for Amazon Quick following skill construction best practices. Use when the user asks to 'build a skill', 'create a skill', 'make a new skill', 'author a skill', 'convert this to a skill', 'save this as a skill', 'test a skill', 'run evals on a skill', 'audit a…
  • 100skill-architect
    Build agent skills for Amazon Quick following skill construction best practices. Use when the user asks to 'build a skill', 'create a skill', 'make a new skill', 'author a skill', 'convert this to a skill', 'save this as a skill', 'test a skill', 'run evals on a skill', 'audit a…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.