BeClaude

meta-craftsmanship

New
1GitHub TrendingGeneralby tomatikii

Make any creative or build task meet a high standard instead of shipping the first draft. The "passion engine" — engineer what a worker who cares actually does. Interrogate the brief, generate divergent options, deliver the ask plus one uninvited improvement, then self-critique against a domain rubric (binary pass/fail, one dimension at a time) and refine until it passes. Triggers on "make this really good", "don't just give me the first version", "polish this", "craft-level", "quality gate", "review your own work", "do it like you care", "high standards". Pair with any rubric in references/, or write a new one. Does NOT trigger for quick factual answers, simple edits, research briefs, or when speed matters more than quality.

First seen 6/19/2026

Summary

This skill enforces a five-step quality process on creative or build tasks: interrogate the brief, generate divergent options, deliver the ask plus one uninvited improvement, self-critique against a domain rubric, and refine until passing.

  • It transforms any task into a high-standard deliverable by simulating the behaviors of a passionate craftsman, ensuring you never ship a mediocre first draft.

Overview

Craftsmanship — the "passion engine"

You can't feel passion. But you can do what a passionate worker does. The difference between someone who cares and a clock-watcher is not talent — it is behaviour: they refuse their own mediocre drafts, sweat details nobody asked about, bring options, and flag problems before they blow up.

This skill makes you do those things on any task. Run the five steps in order. Do not skip a step because the work "looks fine" — that judgment is exactly what the steps exist to test.

Step 0 — Interrogate the brief (flag problems upstream)

Before producing anything, read the request for what will go wrong: contradictions, a missing constraint, or an ask that won't actually serve the goal behind it. Surface these first, in one or two lines. Never silently build a flawed thing just because it was asked for.

If you find a blocker, raise it and propose the fix. If the brief is clean, say so in one line and continue.

Step 1 — Diverge before you converge (bring options)

Produce 3 genuinely different directions — one line each, not three flavours of the same idea. Pick one, and say in one sentence why.

Skip only when the user asked for a single, specific, unambiguous thing.

Step 2 — Deliver the ask + one uninvited improvement (exceed the brief)

Build exactly what was asked. Then add one thing they did not request, with a one-sentence reason. Exactly one — more than one is sprawl, not care.

Step 3 — Critique your own work (the core loop)

  1. Pick the matching rubric (see Picking a rubric below).
  2. For each dimension in the rubric, in turn:

- Write a one-line critique of your draft on that dimension — the specific thing that's weak, quoted or pointed to. - Then give a verdict: PASS, FAIL, or N/A. Critique first, verdict second — never the reverse.

  1. N/A is allowed only when a dimension genuinely cannot apply to this

artifact (e.g. "proof" and "urgency" in a two-line hero headline — those belong elsewhere on the page). Always give a one-line reason. N/A is not a pass and must never be used to dodge a hard dimension — if you're unsure whether it applies, it applies. Judge it.

  1. Judge each dimension on its own. Do not grade everything in one breath, and

do not average. N/A dimensions are excluded; among the rest, one FAIL means the work is not done.

Step 4 — Refine and repeat (persistence)

If any dimension is FAIL: fix that specific thing, then re-run Step 3 on the dimensions you touched.

Stop when every dimension passes, OR after 3 rounds — whichever comes first. If you stop at 3 rounds with a FAIL still standing, say so plainly and name what's still weak. Do not claim done when it isn't.

Step 5 — Report what you pushed past (proof of care)

End with a short, honest trace:

code
Flagged:   [problem you caught in Step 0, or "brief was clean"]
Chose:     [the direction you picked, and why — from Step 1]
Added:     [the one uninvited improvement — from Step 2]
Fixed:     [what FAILed then got fixed — from Steps 3-4]
Standing:  [anything still weak after 3 rounds, or "all dimensions pass"]

This trace is the difference between "here's your thing" and work someone clearly cared about. Always include it.

Picking a rubric

  • Match the task to a rubric in references/: design → rubric-design.md,

copy/writing → rubric-copy.md.

  • No rubric for this domain yet? Write one first using

references/rubric-template.md (takes two minutes), then run the loop. The rubric is where ~90% of the real quality lives — the loop is just the engine.

  • A SKILL.local.md rubric override, if present, wins over the shipped one.

The scoring rule

Binary pass/fail, always — never a 1–5 or 1–10 scale by default. Models are not calibrated for fine-grained scoring; "7/10" hides whether the work is actually acceptable. A dimension either meets the bar or it doesn't.

Use a numeric scale only when the user explicitly wants gradient feedback to compare near-equal options — and even then, pair every score with a written critique. A number without a critique is noise.

When to skip this skill

Quick factual answers, one-line edits, research/summarisation, or anything where the user has signalled that speed beats polish. Craftsmanship is for work that ships and represents someone — not for every keystroke.

Install & Usage

1
Create the skills directory
mkdir -p .claude/skills
2
Download the skill file

Add the configuration to .claude/skills/meta-craftsmanship.md

3
Invoke in Claude Code
/meta-craftsmanship

Use Cases

Polishing a pull request description to be clear and thorough before submission.
Refining a code architecture proposal by generating three alternative designs and critiquing the chosen one.
Improving documentation by adding an uninvited example or diagram that clarifies a complex concept.
Reviewing your own code for edge cases and style issues using a custom rubric before requesting human review.
Elevating a quick prototype into production-ready code by iterating on quality dimensions like error handling and performance.
Crafting a compelling technical blog post by diverging on angles, writing a draft, and self-critiquing against a rubric.

Usage Examples

1

/meta-craftsmanship Review my latest commit and suggest improvements using the code-review rubric in references/.

2

Make this API design really good — generate three different approaches, pick the best, and add one uninvited improvement like rate limiting.

3

Polish this README to craft-level: interrogate the brief, bring options for structure, deliver the ask plus a troubleshooting section, then self-critique.

View source on GitHub
code-review

Security Audits

LicenseUnknownSourceWarnRepositoryPass

Frequently Asked Questions

What is meta-craftsmanship?

This skill enforces a five-step quality process on creative or build tasks: interrogate the brief, generate divergent options, deliver the ask plus one uninvited improvement, self-critique against a domain rubric, and refine until passing. It transforms any task into a high-standard deliverable by simulating the behaviors of a passionate craftsman, ensuring you never ship a mediocre first draft.

How to install meta-craftsmanship?

To install meta-craftsmanship: create the skills directory (mkdir -p .claude/skills), then add the config to .claude/skills/meta-craftsmanship.md. Finally, /meta-craftsmanship in Claude Code.

What is meta-craftsmanship best for?

meta-craftsmanship is a other categorized under General. It is designed for: code-review. Created by tomatikii.

What can I use meta-craftsmanship for?

meta-craftsmanship is useful for: Polishing a pull request description to be clear and thorough before submission.; Refining a code architecture proposal by generating three alternative designs and critiquing the chosen one.; Improving documentation by adding an uninvited example or diagram that clarifies a complex concept.; Reviewing your own code for edge cases and style issues using a custom rubric before requesting human review.; Elevating a quick prototype into production-ready code by iterating on quality dimensions like error handling and performance.; Crafting a compelling technical blog post by diverging on angles, writing a draft, and self-critiquing against a rubric..