9arm-skills: The Repo That Turns Claude Code Into a Disciplined Agent

A skill store, a refusal engine, and a set of workflows that teach an LLM how to debug, review, and report with more rigor than a normal chat prompt ever could.

8 min read • View on GitHub • More from thananon

A ritual workspace where a carved mantra tablet is placed beside a terminal, while a mechanical assistant stands before a sequence of four stations. The scene explains that the repo installs procedure before it allows solution-seeking. — The repo’s sharpest idea is not a smarter prompt. It is a behavioral ritual that forces Claude Code to re-anchor on rules before it improvises.

Key Takeaways

`9arm-skills` treats Claude Code less like a chat window and more like a runtime that can be governed by installed behavior.
The `debug-mantra` skill is the repo’s clearest trick: it forces a verbatim recital before any reasoning, which functions like a cognitive lock-in.
Refusal is not a bug here. It is the quality-control mechanism that keeps the agent from skipping reproduction, root cause, or evidence.
The repository matters beyond debugging because it also translates engineering facts into management language without sanding off the truth.

The Mantra Is the Point

The most revealing file in `thananon/9arm-skills` is not a feature list. It is `debug-mantra`, a skill that makes Claude Code recite rules verbatim before it is allowed to proceed. That sounds ceremonial because it is ceremonial. The ceremony is the mechanism.

This is the repo’s core move: not “ask better questions,” but “install a state change.” The mantra forces the model to re-anchor on the workflow, then walk through reproduction, tracing, falsification, and breadcrumbing in order. The point is not flavor. The point is to make skipping steps harder.

รวม Skills ต่างๆ ที่ผม (9ARM) สอนหรือแชร์ไว้ เพื่อให้ง่ายต่อการค้นหาและนำไปใช้งานต่อได้ครับ

Thananon Pataranawat, Project Creator / Maintainer · thananon/9arm-skills Repository Readme

The mantra behaves like a gated workflow. Claude Code does not get to jump to the fix until it has earned the right to propose one.

From Chat to Installed Behavior

The project’s deeper thesis is that Claude Code should be treated like an agent runtime. Skills are not just prompts stored in folders. They are installed modules with triggers, operating rules, and lifecycle scripts.

Ordinary prompting	`9arm-skills`
One-off text in a chat window	A directory-backed skill system loaded into Claude Code
Depends on the user remembering the ritual	The ritual is encoded as a workflow
Helpful by default	Selective, sometimes refusing until evidence exists
Easy to drift off spec	Guardrails are repeated, scripted, and linked from disk
Lives in the moment	Persists as a maintained skill store

How the Skill Store Is Organized

The repository is structured like a small platform. `skills/` holds the actual behaviors, `.claude-plugin/` defines what Claude loads, `scripts/` maintains the plumbing, and `CLAUDE.md` acts like a meta-skill for the repository itself.

skills/
  engineering/
    debug-mantra/
      SKILL.md
    scrutinize/
      SKILL.md
    post-mortem/
      SKILL.md
  productivity/
  personal/

.claude-plugin/
  plugin.json

scripts/
  link-skills.sh
  list-skills.sh

CLAUDE.md

That shape matters. A loose collection of Markdown notes would be easy to browse and easy to ignore. A governed skill store creates expectations about naming, placement, activation, and reuse. In other words, it behaves like software, not content.

Two adjacent desks are connected by a narrow bridge carrying the same facts from one side to the other. One desk is covered in stack traces, file paths, and SHAs, while the other is organized around impact, risk, and next steps. The image explains the repo’s translation layer between engineering truth and management language. — `management-talk` shows that the repo is not only about debugging. It is also about translating evidence into language different teams can act on.

Why Refusal Is a Feature

The most mature skills in the repo do not optimize for cheerfulness. They optimize for correctness under uncertainty. `scrutinize` wants an outsider read. `post-mortem` refuses to draft until the evidence is there. That is a deliberate anti-hallucination stance.

Helpful-at-all-costs	Evidence-first skills
Moves quickly to an answer	Stops for reproduction, root cause, or proof
Treats hesitation as failure	Treats hesitation as discipline
Can produce polished nonsense	Can refuse to overclaim
Useful for ideation	Useful for post-incident rigor
Optimizes for momentum	Optimizes for trust

The Shell That Keeps the System Honest

The enforcement layer lives in shell. `scripts/link-skills.sh` discovers `SKILL.md` files with `find`, excludes buckets the repo does not want linked yet, and creates symlinks into the Claude skills directory. It also guards against recursive linking, which is the kind of boring safeguard that usually separates a clever repo from a reliable one.

#!/usr/bin/env bash
set -euo pipefail

repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
dest_dir="${HOME}/.claude/skills"

find "$repo_root/skills" \
  -path '*/deprecated/*' -prune -o \
  -path '*/in-progress/*' -prune -o \
  -path '*/personal/*' -prune -o \
  -name 'SKILL.md' -print0 | while IFS= read -r -d '' skill; do
    # link skill into Claude's runtime directory
    :
done

The important part is not the syntax. It is the posture. This repo assumes skills should be discoverable, linkable, and safe to refresh. That makes it feel closer to infrastructure than to documentation.

`management-talk` and the Translation Layer

`management-talk` broadens the project’s value. It takes the same engineering evidence a developer trusts, then renders it in the language of status, risk, and priority without erasing the underlying facts. That is a rare kind of AI use case: not generation, but translation.

Engineering view	Management view
Repro steps, traces, commits, SHAs	Impact, risk, status, next steps
Diagnostic density	Decision-ready summary
Evidence is preserved	Audience changes
Explains what broke	Explains what matters now
Technical truth first	Organizational clarity first

Where This Fits in the AI Tooling Landscape

Compared with prompt snippets, courses, or GitHub “awesome” lists, `9arm-skills` is operational. It is meant to be loaded, triggered, and reused inside an actual agent workflow. That shifts it from learning material into behavioral middleware.

Category	What it offers	What `9arm-skills` adds
Prompt library	Reusable text	Persistent activation and refusal logic
Course content	Instructional depth	Direct execution inside Claude Code
Awesome list	Curated links	Runnable skills and loading scripts
Generic assistant chat	Flexible conversation	A disciplined workflow with gates and order

Why It Matters

The interesting part of `9arm-skills` is not that it helps Claude Code answer questions. It is that it shows how to encode engineering standards into the agent itself. If you care about debugging discipline, review quality, or translating technical reality across teams, that is a meaningful step.

The bigger lesson is simple. As agents get more capable, the value shifts from asking for better outputs to defining better conduct. This repo is an early, opinionated answer to that problem.