Caution
50% useful tool/teaching resource for agentic coding, 50% externalised temper tantrum.
Goblin Mode is a permanently-in-flux configuration system (skills1, agents, hooks) built by one developer to solve problems they actually had. Every skill traces back to a specific friction point. Hooks enforce habits that were being skipped.
- Weakness-aware design: Testing is a known weakness, so a dedicated skill encodes the discipline. ADHD makes executive function unreliable, so hooks enforce it instead of relying on willpower.
- Context window discipline: CLAUDE.md loads every session. Skill descriptions load at start; bodies lazy-load on trigger. Agents run in sub-processes. Every layer has a deliberate cost.
- Model tier thinking: Skills specify whether they need Haiku (fast, cheap), Sonnet (balanced), or Opus (thorough). Not every task needs the biggest model.
- Friction-driven, not architecture-driven: This grew organically from actual work. The process of building it is what's transferable, not the specifics.
Note
This setup is specific to one developer's workflow (and brain). If you're building your own, the process is what's transferable; the specifics should be yours.
For the full story on how and why this was built, see How to Use This Repo.
- What's In Here
- Quick Start
- Directory Guide
- How It All Fits Together
- Key Concepts
- Documentation Index
| Component | Count | What it does |
|---|---|---|
| Skills (command) | 49 | Slash commands you invoke (e.g. /git:commit-one-delta) |
| Skills (knowledge) | 17 | Knowledge packs that load automatically when relevant |
| Agents | 10 | Autonomous sub-processes for multi-step work |
| Hooks | 7 | Scripts that run on git events and session lifecycle |
| Docs | 2 files | Guides for this repo |
If you've cloned this and want to understand what you're looking at:
- Read CLAUDE.md: the main behaviour file — tells Claude how to write code, format commits, and communicate.
- Browse skills/README.md: full index of available commands.
- Read How to Use This Repo: explains every directory and the thinking behind each one.
If you're new to Claude Code customisation entirely, start with the How to Use This Repo guide.
The single most important file. Loaded into every Claude Code session and defines:
- Technical profile: languages, frameworks, preferred tools
- Communication rules: British English, no sycophancy, direct answers
- Code conventions: tabs for indentation, naming patterns, TypeScript strict mode
- Git workflow: conventional commits, branch naming, PR structure
- Security defaults: no committed secrets, input validation, RLS
Think of it as "if I had to brief a new developer on how I work, what would I say?"
Skills serve two distinct roles:
Command skills (49) — you invoke these by typing /skill-name in Claude Code. Each has a model tier in its name:
| Tier | Model | Best for |
|---|---|---|
delta |
Haiku | Fast, routine tasks |
gamma |
Sonnet | Balanced reasoning |
omega |
Opus | Complex analysis |
Categories: git, PR, doc, linear, merge, repo, review, suggest-task, wip, config, do.
Knowledge skills (17) — Claude loads these automatically when it detects relevant keywords in your conversation. Mentioning "Svelte" triggers svelte-ninja; mentioning "Neo4j" triggers cypher-linguist. You never invoke them directly.
Only the skill's short description loads at session start (cheap on context). The full knowledge pack loads on demand.
Agents are sub-processes that Claude spawns to handle multi-step work independently:
| Agent | Purpose |
|---|---|
design-reviewer |
Review proposed features against design values before implementation |
implementation-planner |
Break vague development requests into actionable plans |
project-context-loader |
Rebuild mental context when switching between projects |
roadmap-maintainer |
Keep documentation and roadmaps in sync with code changes |
scope-guard |
Detect and flag scope creep before it becomes entrenched |
session-closer |
Capture session state, update task tracker, write handoff note |
session-orchestrator |
Build a work plan at session start from git history and priorities |
ship-checker |
Multi-dimensional quality check before creating a PR |
task-sync |
Keep Linear/GitHub Issues consistent with git and branch state |
test-gap-scanner |
Identify untested code using risk-based prioritisation |
They run in their own context window, so they don't clutter your main conversation.
Scripts that run automatically on git events and session lifecycle:
| Hook | Trigger | What it does |
|---|---|---|
pre-push.zsh |
Before push | Orchestrator; guards which repos run the full chain |
pre-push-tests.zsh |
Before push | Detects untested files; runs test suite |
pre-push-evidence.zsh |
Before push | Extracts apprenticeship KSB portfolio evidence from commits |
post-commit-docs.zsh |
After commit | Checks if changed files need documentation updates |
settings-sync.sh |
Session start | Strips JSONC comments from settings source of truth → settings.local.json |
session-start-worktree.sh |
Session start | Injects worktree context into the session environment |
stop-uncommitted-check.sh |
Stop | Warns about uncommitted changes when Claude finishes responding |
The pre-push.* hooks are specific to an apprenticeship workflow; they enforce habits that are easy to forget (running tests, tracking evidence, updating docs). The settings-sync.sh hook is what makes the .jsonc → .json source-of-truth approach work.
Guides for this repo. See the Documentation Index below.
You type something in Claude Code
│
├─ Keywords detected? ──→ Knowledge skill loads automatically
│
├─ You type /skill-name? ──→ Command skill runs a defined workflow
│
├─ Skill or Claude spawns agent? ──→ Agent works autonomously
│
└─ You push code? ──→ Hooks run checks and extraction
Meanwhile, CLAUDE.md shapes every response throughout.
The key insight: CLAUDE.md is always active, knowledge skills activate on context, command skills activate on demand, and hooks activate on git and session events. Each layer has a different trigger and a different cost to your context window.
Context window cost: Everything Claude reads uses up its working memory. This setup is designed to be efficient: only descriptions load upfront, full content loads on demand. If you're building your own, this matters more than you'd think.
Model tiers: Not every task needs the most powerful model. Haiku is fast and cheap for routine work. Opus is thorough but slower and more expensive. The tier system makes this choice explicit.
Organic growth: None of this was planned upfront. Every skill and hook traces back to a specific problem that came up during actual work. If you're building your own setup, start with one friction point and go from there.
For more on these ideas: How to Use This Repo
| File | Description |
|---|---|
| How to Use This Repo | Comprehensive guide to the entire setup; start here |
| Agent Workflow Design | Design notes for the agent-based workflow patterns |
Footnotes
-
Skills replaced slash commands after Anthropic merged the two systems. ↩