An engineering showcase. This repository documents eight custom Claude Code skills — small, composable programs that extend an AI coding agent with new procedures, memory, and orchestration capability. They are not prompts. They are engineering artifacts: shell daemons with re-entrancy guards, a Windows batch state machine that coordinates parallel AI agents without a single fixed
sleep, a Blender script that manipulates a shader graph in code, and a 55-test pytest suite guarding a learning system's parser. What follows is a faithful, redacted account of how each was built and why.
Author: Nick Siegel · Status: active, in daily personal use · License: MIT (this showcase)
Claude Code ships with a "skills" extension mechanism: a folder of markdown and scripts that teaches the agent a new procedure on demand. Most people who use it write a handful of one-off prompts. This repository is eight skills built as real software — with state machines, security guards, test suites, and documented production incidents — that together form a personal agent-orchestration platform: one layer decides what an AI agent should be allowed to load and remember, one layer coordinates teams of agents on work too large for one context window, and a domain layer does specific jobs (repository understanding, structured requirements-gathering, knowledge-base synthesis, even 3D art pipeline automation) inside that harness.
Across the eight skills: ~6,800 lines, spanning Bash, Python, Windows batch, and Blender's Python API, with a 55-function pytest suite, two documented production incidents with numbered fixes, and one real 8-agent, ~30–40-hour production run used as a worked example throughout.
An AI coding agent with no structure around it fails in three predictable ways as work gets bigger and more repeated:
- It re-learns nothing. Every session starts cold; a correction you gave yesterday has to be given again today.
- It doesn't scale past one context window. A project with eight specialist roles and real dependencies between them either gets crammed into one session (thrashing) or coordinated by hand with fixed timers and hope.
- It loads everything, all the time. Without discipline, an agent with hundreds of available tools and skills pays a token tax on every single session just for tools it never uses that day.
These eight skills are the direct, working answer to each of those three failure modes — built, broken, fixed, and hardened through actual use rather than designed once on a whiteboard.
Most people's "custom AI workflows" are prompt templates. These are systems with the properties you'd expect from production software:
- Event-driven coordination instead of timers.
SE-dream-team's Windows launcher advances a multi-agent pipeline by polling a shared log for unique sentinel lines each agent must append — never a fixedsleep N. Parallel phases snapshot two sentinels and block on both. See ADR 0001. - A learning system hardened by real incidents, not hypotheticals.
continuous-learning-v2's background observer carries fix comments tied to actual numbered issues — a re-entrancy/cooldown fix for a runaway-process memory explosion, a Windows-hang guard — plus five independent self-observation guards so the learning system can't get stuck watching itself. Backed by a 55-test pytest suite. - Config as a diffable, machine-written artifact.
project-kickoffwrites a structured "setup profile" block into every project's config specifically so a later run can diff against it instead of re-guessing — turning a one-shot interview into an idempotent, re-runnable procedure. - A context-budget discipline layer for multi-skill agent harnesses.
brain-routerclassifies a task into one of nine classes before loading anything, with a hard "≤3 skills per task, never load everything" rule — the same instinct that shows up independently in this author's separate optimization of a 277-skill marketplace plugin down to a 179-skill, 8.7%-token-lighter variant (see Evidence). - Honest attribution, including for the skill that isn't 100% original.
continuous-learning-v2starts from an open-source base (origin: ECC, credited inspiration: the "Homunculus" community project) — the showcase says so explicitly and scopes the claimed contribution to what was actually added: a project-scoped-instinct layer plus the production hardening above. See ADR 0004.
| Skill | Layer | What it does | Scale |
|---|---|---|---|
project-kickoff |
Platform | Interviews the user, detects the stack, writes a diffable per-project Claude Code config | 97 lines |
continuous-learning-v2 |
Platform | Hook-captured, project-scoped instinct learning system with an evolve-to-skill pipeline | 4,313 lines / 10 files |
SE-dream-team |
Orchestration | Generates a multi-agent team package with a sentinel-paced Windows DAG launcher | 869 lines / 8 files |
brain-router |
Orchestration | Task-classifying controller enforcing a load-only-what's-needed discipline across a personal agent harness | 492 lines / 4 files |
graphify-wrapper |
Domain | AST + graph-clustering wrapper for cheap, structural codebase understanding | 60 lines |
intake |
Domain | Bounded, structured-options elicitation that turns vague intent into an immutable artifact | 215 lines |
llm-wiki-maintainer |
Domain | Karpathy-style wiki ingest/query/lint layer with multi-gate promotion thresholds | 316 lines / 4 files |
psx-character-pipeline |
Domain | Six-stage Blender pipeline that scripts a PS1-style shader/material setup | 443 lines / 4 files |
brain-router, graphify-wrapper, intake, and llm-wiki-maintainer are four pieces of a single
personal agent-harness pattern this author calls claude-brain — a controller plus three domain
skills it dispatches to. They're presented individually because each is independently useful, and
together in Architecture because the way they compose is the interesting part.
new project ──▶ project-kickoff (interview + stack detection) ──▶ diffable per-project config
│
large multi-role job ──▶ SE-dream-team (plan + briefs + sentinel launcher) ─┤
│
every session ──▶ continuous-learning-v2 (hooks capture, observer learns) ─┤
▼
claude-brain harness (brain-router
classifies ──▶ loads only graphify-wrapper /
intake / llm-wiki-maintainer as needed)
Full detail: Architecture documentation →
| Concern | Choice | Why |
|---|---|---|
| Skill packaging | Claude Code's native skill format (SKILL.md + scripts) |
The distribution unit these all had to fit — markdown-as-instructions plus real scripts underneath |
| Multi-agent coordination | Windows batch + a shared JSONL/markdown hand-off log | No message broker available in this environment; a poll-a-shared-log pattern needed zero new infrastructure |
| Learning capture | Bash hooks (PreToolUse/PostToolUse) + a background Haiku analysis agent |
Hooks are deterministic (100% capture); a skill-based approach would be probabilistic (~50–80%) |
| Instinct storage/CLI | Python | Needed real data structures (dedup, clustering, promotion) and a real test suite — bash wasn't going to cut it |
| Codebase structure | graphify (tree-sitter + Leiden clustering), wrapped |
Reused a purpose-built OSS tool rather than reinventing AST parsing |
| 3D art automation | Blender's Python API (bpy) |
The only way to script node-graph materials and Geometry Nodes reproducibly |
| Document | What it covers |
|---|---|
| Engineering Story | The narrative: problem → research → constraints → decisions → failures → iterations → what works |
| Architecture | How the eight skills compose into three layers, with data-flow and state diagrams |
| Architecture Decision Records | Six load-bearing decisions, each with options, tradeoffs, and reasoning |
| Evidence | Real line counts, real test counts, a real production run, real token-savings numbers |
| Timeline | How the collection grew over ~2.5 months |
| Interview Prep | Likely questions a reviewer would ask, answered from the engineer's POV |
| Portfolio Summary | A concise, factual summary for a resume, LinkedIn, or application |
| Repository Audit | A self-scored hiring-manager review of this repository, with the fixes already applied |
| Code snippets | One representative, sanitized excerpt per skill |
This showcase follows one rule strictly: nothing here is fabricated. Every line count, test count,
and incident reference is read directly from the actual skill files. Where a fact is inferred rather
than confirmed by the text (why a design choice was made, an approximate date), it's marked as such.
Four of these skills (brain-router, graphify-wrapper, intake, llm-wiki-maintainer) are used
inside a private, unreleased AI-assistant project; this showcase presents the general-purpose
harness pattern they implement and omits every file:line reference and tuned numeric threshold
that was ported from that project's private internals — the engineering pattern is shown in full,
the proprietary specifics are not. Personal filesystem paths have been genericized throughout.