Claude Code ^{goblin mode}

[!CAUTION] 50% useful tool/teaching resource for agentic coding, 50% externalised temper tantrum.

Goblin Mode is a permanently-in-flux configuration system (skills¹, 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.

Table of Contents

• What's In Here
• Quick Start
• Directory Guide
  • CLAUDE.md: The Behaviour File
  • Skills: Commands and Domain Knowledge
  • Agents: Autonomous Workflows
  • Hooks: Automation
  • Docs: Documentation
• How It All Fits Together
• Key Concepts
• Documentation Index

What's In Here

Quick Start

If you've cloned this and want to understand what you're looking at:

1. Read CLAUDE.md: the main behaviour file — tells Claude how to write code, format commits, and communicate.
2. Browse skills/README.md: full index of available commands.
3. 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.

Directory Guide

CLAUDE.md: The Behaviour File

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/: Commands and Domain Knowledge

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:

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/: Autonomous Workflows

Agents are sub-processes that Claude spawns to handle multi-step work independently:

They run in their own context window, so they don't clutter your main conversation.

hooks/: Automation

Scripts that run automatically on git events and session lifecycle:

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.

docs/: Documentation

Guides for this repo. See the Documentation Index below.

How It All Fits Together

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.

Key Concepts

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

Documentation Index

Guides