Code that looks hand-built, not AI-generated.
-2ea44f){kind=icon}
The senior-engineer patterns behind the code people call "special" in top models like Fable 5 — packaged as a drop-in skill for Claude Code, so any model writes that way.
There's no secret model and no hidden architecture behind crafted-looking code. It comes from a handful of countable conventions plus care in the details. CraftCode writes those conventions down and makes your AI apply them every time.
What you usually get:
def process_order(order_id):
# get the order
order = db.get(order_id)
# try to charge and email, retry if it fails
for i in range(3):
try:
charge_card(order.amount)
send_receipt(order.email)
return True
except Exception as e:
time.sleep(1)
return FalseWhat CraftCode gets you:
def process_order(order_id: str) -> bool:
order = db.get(order_id)
# charge_card is NOT idempotent — a blind retry would double-charge. Retry only
# transient gateway errors; let permanent declines fail through to the caller.
charge = retry(
lambda: charge_card(order.amount),
should_retry=lambda e: isinstance(e, GatewayTimeout),
)
# Receipt email is a peripheral side effect: run it once, and never let it
# undo a successful charge (fail open, log, move on).
try:
send_receipt(order.email)
except EmailError:
log.warning("receipt email failed for order %s; charge already succeeded", order_id)
return charge.okSame behavior, senior texture: the double-charge bug is gone, the why is in the code, and the happy path reads straight through.
CraftCode teaches the model seven conventions:
- Mirror before you write — read the neighbors, match their style. (Consistency beats cleverness.)
- Intent comments — explain why, never what.
- Fail-open at the edges, fail-closed on money & auth.
- Idempotency awareness — never blindly retry an email/deploy/charge.
- Native over library — no dependency for three lines of work.
- Constraints baked in — security/privacy/market designed in, not bolted on.
- Defensive boundary, clean core — keep
try/exceptat the I/O edge.
Each comes with before/after code and a "watch for" list, plus an output checklist the model runs before it says "done." They're defaults, not dogma — the skill also spells out when a senior bends them (prototypes, house style, readability).
Every pattern is a real before / after pair you can open side by side, spread across
Python, Go, Rust, JavaScript, and HTML/CSS — because the ideas are language-agnostic:
The skill was checked with a small A/B recall probe before release, and the test is written down so you can reproduce it in a few minutes (no invented benchmarks):
→ PROOF.md
CraftCode started as an argument. People said a certain top model's code just felt special — like it had taste no other model could match. Pulling that texture apart, there was no secret model and no hidden architecture: it was a small set of countable conventions plus care in the details, every one reproducible. So we wrote them down. If the "magic" is countable, it isn't magic — it's a checklist, and any model can run it.
CraftCode is a single self-contained folder. Drop it into your skills directory:
# Claude Code (global skills)
cp -R craftcode ~/.claude/skills/craftcodeThen just ask: "write this the CraftCode way", "make this look senior", or "de-AI this code" — the skill triggers on its own when you're writing or refactoring code.
It's pure markdown — no scripts, nothing executable — so it's safe to audit in ten seconds.
Free to use, modify, and redistribute (including commercially) with attribution. See LICENSE.txt.
CraftCode came out of the day-to-day of shipping real AI systems at otonit — the same eye for detail, packaged so anyone's model can borrow it. If it saved you from a wall of AI boilerplate and you want the systems behind it (automation, agents, things that actually ship), that's what we build.
Built by otonit — automation and AI systems that ship.