Coding Skills: Making Repeated Work Reusable

The moment you notice you are re-explaining the same judgment call, it is time to extract. That is the basic rule. Not “I have these skills” but “this particular decision keeps coming back, and re-explaining it every session is a Wiederholungstäter—a repeat offender.”

Skills are not decorative prompt fragments. They are the reusable unit of Handwerk—craftsmanship—that captures judgment, workflow, and environment knowledge which keeps showing up in real work.

The Skill Rule

The point is not to have many skills.

The point is to capture repeated patterns like:

• how implementation should be reviewed
• how UI work should be judged
• how documentation should be structured
• how change notes should start for normal humans
• how local tools or APIs should be used safely

The Core Coding Skills

Some skills are generic enough to share. Others are tightly bound to your repos, your branching model, or your internal infrastructure. The core layer in my setup includes things like:

• implementation orchestration
• architecture review
• change notes
• documentation writing
• UI development guardrails

Some of those are clean public starters already. Some are still too entangled with my local setup and need cleanup before they should be shared.

Documentation Is A Coding Skill Too

That is why doc-write lives in this layer for me.

Documentation is part of development:

• READMEs
• setup guides
• reference docs
• internal notes
• prompt and context files

Good engineering communication needs structure just as much as code needs structure. Docs are not a side quest after the real work is done — they are engineering output. If the model keeps producing fuzzy READMEs or hard-to-scan reference pages, the fix is not “write better prose.” The fix is a skill that encodes what good structure looks like.

Tool And Environment Helpers

These are the least glamorous skills, but often the most useful.

Examples from my stack:

• how to pull logs from Grafana Loki
• how to inspect Kubernetes
• how to run GraphQL queries against our API
• how to generate or retrieve a token from locally available secrets

Those are exactly the kinds of things I do not want to explain manually over and over again.

They are not public because they depend on my environment. But the pattern is very reusable.

What Others Do

Anthropic made skills a first-class concept

Anthropic’s Claude Code skills system is now an explicit product surface, not just community folklore. Skills are discoverable, on-demand instruction bundles. That validates the general approach, even if Keeper Runtime pushes the layering further. Source: Claude Code Skills.

OpenAI pushes explicit execution contracts

OpenAI’s GPT-5.4 guidance is not about “be smarter.” It is about explicit structure: output contracts, dependency checks, tool persistence, completeness accounting, and verification loops. That maps directly to the coding-skill layer and is one reason the provider overlays are worth keeping (full source linked on the root page and in the work-mode deep dive).

Community practice keeps converging on modular skill bundles

Across the field, teams are increasingly packaging engineering standards, debugging heuristics, and review expectations as reusable prompt modules instead of re-explaining them in every task. That is the same pressure I feel locally: once a pattern repeats, it wants a durable home.

Download

If you want the public starter files one by one instead of the full bundle, start here:

• dev-review
• dev-ui
• dev-change-notes
• doc-write