One command
for any lonely
technical decision.

The generic chatbot produces generic chatbot output.

Senior engineers make a specific class of decision alone.

Design review the week before the design review meeting. Postmortem at 11pm because the all-hands is tomorrow. Decision memo for a build-vs-buy call that doesn't warrant an offsite but does warrant a shared doc that survives the meeting.

These decisions are too small for a full consultation and too consequential to guess at. The default alternative is a blank chat window and a generic helpful assistant. That produces output that reads like "have you considered the tradeoffs?" — which is not what the situation needs.

A skill in this collection is what happens when you take the specific expert you'd want in the room, encode their voice and questioning discipline and structured output format, and give them one command each.

Not pair-programming tools. Not chatbot wrappers with a clever preamble. Not generic productivity skills dressed up in engineer voice. Five distinct personas, each calibrated to one decision type.

What makes each skill unique.

Every skill shares the same underlying discipline (see Shared discipline). What makes each one load-bearing is the specific lens — the specific expert — the specific questioning protocol. Five characters, not one chatbot five times.

Same discipline underneath every persona.

Each skill has its own voice. The underlying discipline is identical — same questioning pattern, same grounding rule, same banned words, same structural ceiling. That discipline is what makes the output forwardable.

• → Progressive questioning. One question per message. Acknowledgment of the prior answer first. An adaptive middle question that branches from 6 distinct options per skill.
• → Structured verdict. A specific markdown template with tables, severity ratings, action items. Not a prose dump.
• → Grounded output. Every finding references something you said. No inventions. When data is missing, the output says "Assessment limited — [specific thing not named]" rather than speculating.
• → Distinct voice per skill. The Reviewer, The Chief of Staff, The Investigator, The Interrogator, The Triage Operator — five characters, each calibrated to the task.
• → Banned hedges. "Likely", "approximately", "might", "perhaps", "sort of", "I'd recommend". Gone. If unknown, labeled unknown. If known, stated directly.
• → 500-1200 word ceiling. The discipline of the brief. Long means the thinking wasn't clear enough yet.

How the eval scores were measured.

Each skill was built using the same 10-phase recipe and evaluated by two independent simulated evaluators applying a 5-dimension rubric.

The dual-evaluator pattern

• → Russian Judge (RJ). Cold-War Olympic-judge persona. Brutal. Weights specificity and shareability higher.
• → Grumpy Staff Engineer (GSE). 18-years-production persona. Weights actionability and clarity higher; allergic to padding and marketing-disguised-as-engineering.

The 5-dimension rubric

SHIP bars

• → Content skills (4): overall ≥ 8.75, no dimension below 8.0.
• → Router (/tacit): overall ≥ 9.0, no dimension below 8.5. Stricter because it gates every interaction.
• → Hard ceiling on revisions: 3 rounds. Round 3 fail = the design is structurally wrong, not promptable. Escalate to redesign rather than patch.

Pre-bakes carried forward

The first skill (/scrutiny) discovered four systemic failure modes in Round 1. They were patched and pre-baked into every subsequent skill's initial draft:

1. Voice must carry into the verdict — frame fixes as consequences ("If you don't fix X, Y will happen"), not recommendations.
2. Banned hedge words baked into voice rules.
3. Scale-only fixes (bumping a plan, adding resources) trigger a Q6 probe — they're capacity management, not prevention.
4. The "Lessons / 10x / What We're Giving Up" section must surface NEW material — never restate earlier findings.

Result: every subsequent skill (/verdict, /autopsy, /fracture, /tacit) shipped at Round 1 — the discovered bugs became prevented bugs.

Seven more skills planned.

The collection is designed as twelve skills. Five are installed (four content skills plus the router). Seven are on the roadmap — designed, specified, not yet built. When you ask /tacit for one of them, it says so honestly and offers the closest installed partial fit.

Release order is signal-driven — whichever Case A decline the router gets asked for most often gets built first.

Install. Run. Forward the output.

Each skill is a single markdown file. Drop it into ~/.claude/commands/ and the command is live. No subscription. No cloud. No login. Works in Claude Code out of the box.

all five (recommended)

curl -fsSL https://tacit.sh/install.sh | bash

specific skills only

curl -fsSL https://tacit.sh/install.sh | bash -s tacit
curl -fsSL https://tacit.sh/install.sh | bash -s scrutiny verdict

update later

curl -fsSL https://tacit.sh/install.sh | bash

Same command — the installer overwrites existing files.

audit before running (recommended for any curl | bash)

curl -fsSL https://tacit.sh/install.sh | less
curl -fsSL https://tacit.sh/install.sh -o install.sh && bash install.sh

manual — clone and copy

git clone https://github.com/ketankhairnar/tacit-skills
cp tacit-skills/skills/*.md ~/.claude/commands/

use it in Claude Code

/tacit had a 34-min outage last night, need the postmortem before all-hands
/tacit deciding between Mixpanel, Amplitude, and building on ClickHouse
/tacit                       # bare invocation → "What are you working on?"

The skills are portable.

The skills are pure prompts — no tool-use, no MCP calls, no Claude Code-specific APIs. Only the install path and slash-command invocation are Claude Code-specific. The SKILL.md content works as a system prompt in any LLM agent that takes one.

OpenAI Codex CLI

Drops in ~/.codex/prompts/. Strip the YAML frontmatter:

mkdir -p ~/.codex/prompts
for skill in scrutiny verdict autopsy fracture tacit; do
  curl -fsSL "https://raw.githubusercontent.com/ketankhairnar/tacit-skills/main/skills/${skill}.md" \
    | sed '1,/^---$/d' | sed '1,/^---$/d' \
    > ~/.codex/prompts/${skill}.md
done

OpenCode

Drops in ~/.config/opencode/command/ (global) or .opencode/command/ (per-project):

mkdir -p ~/.config/opencode/command
for skill in scrutiny verdict autopsy fracture tacit; do
  curl -fsSL "https://raw.githubusercontent.com/ketankhairnar/tacit-skills/main/skills/${skill}.md" \
    -o ~/.config/opencode/command/${skill}.md
done

Generic ChatGPT / Claude / Gemini chat

Paste the contents of any SKILL.md as the system prompt (or first message). The skill follows its protocol from there.

v0.2 and beyond.

• → Next skill build: driven by which Case A decline the router gets asked for most often. Most-requested planned skill ships first.
• → Multi-target installer: if there's signal that engineers want first-class Codex / OpenCode install, the installer grows a --target flag.
• → R2-hosted skills: if GitHub raw rate limits or latency become an issue, the installer flips to a Cloudflare R2 bucket. End-user one-liner stays the same.
• → Versioned skill paths: for users who pin a specific skill version (e.g., if a skill update regresses a behavior they relied on).

No subscription. No login. No cloud. Install the markdown file. Run the command. Get an artifact you can forward.