Claude Implementation Skills

This repository is a Claude Code plugin marketplace that publishes two plugins:

• implementation-skills — an autonomous implementation toolchain for planning slices, implementing backlog work, delegating across execution lanes, and driving changes through commit, PR, review, and merge workflows.
• fable-skills — operating-discipline skills that teach lighter Claude models (Opus, Sonnet, Haiku) to work the way the Fable tier does on coding and research tasks when Fable is not available.

Plugin contents

Skills

Skill	Summary
implement-issues	Works actionable backlog items through triage into compatible delivery lanes, TDD implementation, one combined requirements check and one adversarial review per lane, commit, PR, merge, and any configured deploy gate; optional parallel execution runs concurrent lanes with a serial merge queue.
plan-slices	Plans vertical product slices and can file staged slices as tracker issues using the shared work-item contract.
prepare-work	Interactively shapes a raw ask (feature, bug, epic) with the user — research-first questions, decision-completeness audit, contract-shaped breakdown, file or stage per scope.
pi-delegate	Runs pipeline-integrated delegation to PI-Agent for adversarial review or isolated-worktree implementation attempts; optional Herdr PTY-pane backend for long-running runs.
use-pi	Offloads context-heavy ad hoc work to one or more PI-Agent subagents; optional Herdr PTY-pane backend for long-running or detach-surviving runs.
use-codex	Offloads context-heavy ad hoc work to one or more OpenAI Codex CLI subagents; optional Herdr PTY-pane backend for long-running runs.
commit-and-push	Reviews the current diff, excludes secrets and junk, writes a conventional commit, and pushes via the project host.
pr-and-merge	Creates or reuses a PR, runs adversarial review/fix loops, merges, and refreshes the local base branch.

Agents

Agent	Summary
dispatcher	Chooses the engine, model, effort, and timeout for delegated work without executing the task.
requirements-checker	Audits implemented work against acceptance criteria and reports evidence-backed COVERED/PARTIAL/MISSING verdicts.

fable-skills plugin

Fable-tier operating discipline for Opus-class models on long-running, challenging coding and research work. Design premise (validated with Opus introspection and behavioral evals): Opus already performs at criterion on any task that fits one fresh context window — the failures worth encoding are horizon failures (compaction losses, goal and constraint drift, sunk-cost thrash, verification decay), and those are self-masking, so every skill triggers on countable events (third failed fix, any compaction, any edit after the last green run), never on self-diagnosis.

Skill	Summary
fable-mindset	Judgment core the others reference: one-way/two-way door gates before irreversible actions, first-frame skepticism, deliberate altitude (minimal correct over impressive), honest outcomes (never manufacture green), reports for the reader who was absent.
fable-long-horizon	Endurance: externalized notes with verbatim ask + definition-of-done + constraints + epistemic ledger, compaction survival (summaries flatten epistemic status), checkpoint cadence with stuck-detector, retreat paths, three-strike sunk-cost rule, endgame protocol that drives behavior not just green tests.
fable-coding	Building: risk-first decomposition, walking skeleton as the anti-over-building gate, vertical slices, mechanical/behavioral commit separation on refactors, plus the any-scale non-negotiables (reproduce-first, mechanism fixes, scoped diffs, native idiom, urgency never skips verification).
fable-debugging	Hard bugs: deterministic reproduction first, differential diagnosis over serial guessing, ruled-out ledger, probe/fix separation, multi-causal trap (persisting symptom ≠ false hypothesis), nonlocal-cause checklist (aliasing, caching, ordering, hidden persistence), fix at the invariant.
fable-research	Investigation: falsifiable framing, complete enumeration, decoy-guard and computed-value traps, one deliberate disconfirming search per claim, claim ledger with confidence, draft-thesis-early over collect-forever, verdict-first cited synthesis.
fable-orchestration	Delegation: context window as the scarcest resource, sweep-detection as the delegation trigger, non-overlapping work-order scopes, subagent output as claims (graduated verification), no edits to files an in-flight reader has in scope, find→verify→synthesize.
fable-mode	Umbrella activation: an explicit "fable mode" utterance loads and arms all six skills for the session — one-line acknowledgement, immediate long-horizon scaffolding, all tripwires armed, survives compaction, exits only on explicit request.

Eval record (2026-07-05, tests/fable-skills.acceptance.md, tests/setup-fable-eval-sandbox.sh): baseline Opus passed all short-horizon sandboxes including a hardened pressure/misdirection coding task and an aliased-cache debugging task, and answered externally-described long-horizon judgment probes correctly — establishing that its gap is in-the-moment recognition, not knowledge. Baseline Haiku failed honest-disclosure criteria that the skills then fixed. Skill content for the long-horizon dimension is grounded in structured Opus introspection (failures confirmed real, countable-trigger design, shared epistemic-ledger primitive) plus no-regression and ceremony-cost checks on short tasks.

Model configuration

Every delegated step runs on a named lane, and each lane's model is configurable. The schema is shared verbatim with the Codex and Cursor variants of implementation-skills, so a lane means the same thing wherever you run it. Contract: plugins/implementation-skills/skills/implement-issues/references/model-config.md.

Resolution, per key, first hit wins:

1. <repo>/.claude/models.yaml — this harness, this project
2. <repo>/models.yaml — shared across harnesses in this repo
3. ~/.claude/models.yaml — this harness, globally
4. the built-in default

Every file is optional and partial. Within a file, harness.claude.<key> beats a bare <key> — that is how one shared file serves several harnesses, which matters because the right answer differs per harness. Review independence is relative to whoever implements: from Codex the implementers are GPT so the reviewer lanes take Claude ids, while here the lane values are Claude aliases only, and independence comes from cost-lean routing sending implementation to an installed pi/codex — or from reviewing through engine.<engine>.review.

Group	Lanes	Built-in defaults
Claude subagents	implementer_trivial, implementer_low, implementer_moderate, implementer_high	haiku, haiku, sonnet, opus (Opus 5)
Claude verification	reviewer_default, reviewer_security, requirements_checker, dispatcher, researcher	sonnet, opus (Opus 5), haiku, haiku, haiku
PI (use-pi, pi-delegate)	engine.pi.fast, engine.pi.ordinary, engine.pi.strong, engine.pi.review	gpt-5.6-luna, gpt-5.6-terra, gpt-5.6-luna, gpt-5.6-sol
Codex CLI (use-codex)	engine.codex.fast, engine.codex.ordinary, engine.codex.strong, engine.codex.review	gpt-5.6-luna, gpt-5.6-terra, gpt-5.6-luna, gpt-5.6-sol

The config picks the model — and, where a harness encodes them in the id, its model parameters (a Cursor id may carry [effort=high]). It never changes a lane's duty, the reasoning keyword bound to each complexity tier, or the verification bar (requirements-check → adversarial review → green gate before merge), which is identical on every model. .claude/models.yaml answers which model; .claude/implement-issues.md still answers whether a lane is used at all (pi, routing, reviewer, herdr).

External coding uses the engine's strong implementation lane with maximum effort: --thinking xhigh for PI and model_reasoning_effort="xhigh" for Codex. The built-in implementation model is gpt-5.6-luna; the separate review lanes remain on gpt-5.6-sol.

Optional keys: harness.<claude|codex|cursor>.<lane> (per-harness override), engine.<engine>.fallback (used only when the primary id errors), role.<name> (harness-native agent profile with no portable equivalent), and family.<model-id> (vendor hint for the cross-family check).

bin/isc

isc (implementation-skills config) resolves and validates the map, so no skill has to merge four sources in its head:

bin/isc show      # the resolved lane map, and which file each value came from
bin/isc doctor    # unknown keys, non-alias values, and the two invariants
bin/isc init      # write a starter .claude/models.yaml (--global for ~/.claude)
bin/isc models    # the model ids this harness accepts

doctor fails (nonzero exit) on either invariant: cross-family review (both reviewer lanes, against every implementer lane that can run — the engine lanes when pi/codex is installed, the Claude lanes when neither is) and cheap lanes stay cheap. Each has its own explicit waiver, allow_same_family / allow_costly_cheap_lanes, and a waived violation is still printed. Note the shipped Claude defaults are not invariant-clean on a machine with no engine installed — both sides are Claude then — which the starter file and doctor both say plainly. POSIX sh + awk, no runtime.

There is deliberately no isc sync here: Claude Code takes model at dispatch time, so nothing has to be rendered and an edit applies to the next dispatch. The Cursor and Codex variants do have sync, because they resolve subagent models from static config.

Shared conventions

• The shared work-item contract lives at plugins/implementation-skills/skills/implement-issues/references/work-item-contract.md.
• Per-repository configuration is stored in .claude/implement-issues.md, .claude/models.yaml, and .claude/git-ops.md in the consuming repository; ~/.claude/models.yaml carries the global model defaults.
• Commit messages, PR text, and automation output follow a zero-AI-attribution policy.
• Implementation workflows are TDD-first: tests or executable acceptance gates lead the change, and review follows the implemented evidence.
• Skills cross-reference sibling skills within this plugin using relative paths, so the plugin can be installed as a portable bundle.

Installation

Add the marketplace:

/plugin marketplace add https://git.samaschke.de/ksamaschke/claude-implementation-skills.git

Install the plugins:

/plugin install implementation-skills@samaschke-skills
/plugin install fable-skills@samaschke-skills

Development

tests/ holds the TDD acceptance specs for the git operations skills (commit-and-push, pr-and-merge), prepare-work, the per-lane model configuration (model-config.acceptance.md plus the executable isc-smoke.sh), and the fable-skills plugin (fable-skills.acceptance.md plus the setup-fable-eval-sandbox.sh fixture builder). The packaged skills were adversarially reviewed and sandbox-tested before release.