Skills

A world-class, vendor-neutral library of agent skills. Each skill is a directory with a SKILL.md — plain YAML frontmatter (name + description) per the agentskills.io spec, no framework lock-in, usable with any AI agent.

Agent-Agnostic by Design

Skills are not tied to Claude Code or any specific agent. The installer shim links this repo into whatever agent toolchains you use — one canonical source, many consumers.

Install with bin/skills

./bin/skills list                              # list every skill
./bin/skills install                           # symlink → Claude Code + Codex (default)
./bin/skills install --claude                  # just ~/.claude/skills
./bin/skills install --codex                   # just ~/.agents/skills
./bin/skills install --target ~/.cursor/skills # any agent / Cursor / custom dir
./bin/skills install --all                     # every known target
./bin/skills install --all --copy              # copy instead of symlink (sandboxes)
./bin/skills install --dry-run                 # preview, change nothing
./bin/skills uninstall --codex                 # remove from a specific target
./bin/skills manifest                          # (re)generate skills.json

• Default targets: ~/.claude/skills (Claude Code) and ~/.agents/skills (Codex).
• Override with CLAUDE_SKILLS_DIR / CODEX_SKILLS_DIR env vars.
• Symlinks mean edits here are live everywhere; re-run install only after adding new skill dirs.

skills.json — a generated, agent-neutral index (name · path · description). Regenerate with ./bin/skills manifest.

---

Splunk — Log Analysis, Detections & Dashboards

A deep, interlocking suite. Foundation skills (authoring, optimization, CIM) are referenced by the rest.

Skill	Use when…
splunk-spl-authoring	Writing/fixing SPL — pipeline, commands, field extraction, idioms. Foundation.
splunk-spl-optimization	Search is slow, times out, or costs too much.
splunk-cim-normalization	Normalizing fields to CIM so dashboards/detections work across sources.
splunk-log-investigation	Investigating an incident/outage from symptom → root cause.
splunk-detection-engineering	Building correlation searches, RBA, MITRE ATT&CK mapping.
splunk-threat-hunting	Proactive, hypothesis-driven hunting for threats alerts missed.
splunk-dashboards	Dashboards, KPIs, fast panels, drilldowns, visualization choices.

---

Clean Architecture — Layered Code Design

Technology-agnostic. All six skills share one "place an order" example so they interlock.

Skill	Use when…
clean-architecture	Deciding which layer code belongs in; enforcing the dependency rule. Overview.
api-controller	Writing the API/controller layer; killing fat controllers.
service-layer	Application/use-case orchestration, transactions; avoiding God services.
domain-model	Entities, value objects, aggregates, invariants; avoiding anemic domain.
dto-mapping	DTOs, commands, boundary mapping; stopping entity leaks & mass assignment.
persistence-repository	Repository interfaces/impls, ORM↔domain mapping; keeping DB out of domain.

---

React + Next.js

Skill	Use when…
react-internals	Understanding why React works — Fiber, hooks model, Concurrent Mode, RSC.
react-patterns	Component design, custom hooks, compound components, state colocation.
react-performance	Excessive re-renders, slow lists, large bundle — profiling first, then fixes.
nextjs-app-router	Server Components, data fetching, caching model, Server Actions, streaming.
nextjs-patterns	Route structure, auth/middleware, providers, env vars, error boundaries.

---

Famous Engineering Philosophies

Folder prefix: person's last name (e.g. beck-, fowler-, karpathy-). Philosophy as operating principles — not biography, actionable technique. Skills that are also productivity tools appear in both this section and the Productivity section.

Kent Beck (2 skills)

Skill	Teaches
beck-tdd	Red/Green/Refactor, YAGNI, baby steps, four simple design rules, forcing questions.
beck-xp	XP practices: pair programming, collective ownership, sustainable pace, CI, planning game.

Martin Fowler (3 skills)

Skill	Teaches
fowler-refactoring	Code smells catalog, refactoring moves, safe mechanics, sequencing.
fowler-microservices	MonolithFirst, service boundary design, strangler fig, inter-service communication.
fowler-enterprise-patterns	PoEAA: Active Record vs Data Mapper, Repository, Service Layer, Transaction Script.

Robert C. Martin — Uncle Bob (2 skills)

Skill	Teaches
martin-solid	SOLID principles — original formulations, failure modes, over-application traps.
martin-clean-arch	Concentric rings, Dependency Rule, use-case layer, policy vs mechanism, Humble Object.

Rich Hickey (2 skills)

Skill	Teaches
hickey-simplicity	Simple vs easy, complect vs compose, information vs place, simplicity questions.
hickey-data-oriented	Data vs objects, open systems, immutable values, generic operations, spec at boundaries.

Andrej Karpathy (4 skills)

Skill	Teaches
karpathy-neural-nets	Recipe for training NNs, build-from-scratch for understanding, debugging discipline.
karpathy-llm-intuitions	How LLMs work intuitively: token prediction, context window, temperature, hallucination.
karpathy-software-2	Software 2.0 thesis: neural nets as software, what changes about engineering.
karpathy-vibe-coding	Vibe coding philosophy: intent over syntax, when to trust generated code, limitations.

Matt Pocock (7 skills — also in Productivity)

Skill	Teaches
pocock-typescript	Inference over annotation, generics with constraints, discriminated unions, Zod.
pocock-typescript-generics	Generic constraints, conditional types, infer, mapped types, template literals.
pocock-tsconfig	tsconfig options that matter: strict flags, module resolution, paths, composite.
pocock-grill-me	Stress-test a plan before coding — resolve every branch of the decision tree first.
pocock-teach	Mission-first stateful teaching: lessons, reference docs, storage strength over fluency.
pocock-handoff	Compact a conversation into a clean handoff doc for the next agent session.
pocock-write-a-skill	CSO: description-as-trigger, progressive disclosure, when to split reference files.

Boris Cherny (2 skills — also in Loop Engineering)

Skill	Teaches
cherny-loop	Loop engineering: the three stages, 6 components, why loops replace prompts, progressive trust escalation.
cherny-maker-checker	Splitting the agent that writes from the agent that checks — the most important structural move in any loop.

Garry Tan (3 skills)

Skill	Teaches
tan-product	Founder mode, talking to users, design+engineering integration, when to build vs buy.
tan-design	Design as product thinking — clarity, hierarchy, when design is a competitive moat.
tan-startup	Early-stage decisions: hiring bar, fundraising timing, focus vs optionality.

---

100k+ Repo Design Philosophies

Folder prefix: 100k- (e.g. 100k-react, 100k-linux). What the teams behind famous repos decided and why — design principles, not usage guides. Duplicates with language skills are intentional (different angle).

Skill	Repo	Stars
100k-react	facebook/react	220k — decision-making philosophy, RFC process, stability contract
100k-linux	torvalds/linux	170k — engineering values, patch culture, commit conventions
100k-kubernetes	kubernetes/kubernetes	110k — declarative APIs, reconciliation loop, operator pattern
100k-typescript	microsoft/TypeScript	100k — structural typing rationale, soundness trade-offs

---

Engineering Personas

How senior engineers in specific roles think about problems — mindset, strategy, and the practices that matter most in that role.

Skill	Persona
qa-engineer	Test strategy, shift-left, test pyramid, testability as design signal, CI gates.
devops-engineer	CI/CD design, IaC, observability, SLOs, incident response, toil reduction.
ml-engineer	Problem framing, data leakage, evaluation design, experiment tracking, model monitoring.
developer-productivity	DORA metrics, small PRs, fast feedback loops, async communication, toil automation.

---

Productivity & Learning Modes

Interactive modes and session tools. Skills from famous engineers appear in both this section and their personality suite — same skill, different discovery path.

Planning & Design

Skill	Use when…
grill-me	Stress-testing a plan before writing code — one question at a time.
handoff	Compacting a long conversation into a handoff doc for a fresh agent session.
write-a-skill	Creating a new agent skill with proper description format and structure.

Learning

Skill	Use when…
teach	Learning a new concept over multiple sessions with missions, lessons, and reference docs.

Caveman Suite — Token Compression (by JuliusBrussee)

Skill	Use when…
caveman	Responses are too verbose — cuts ~65% output tokens, full technical accuracy.
caveman-commit	Writing git commit messages — terse Conventional Commits format.
caveman-review	Reviewing a PR — one-line-per-finding comments with severity prefix.
caveman-compress	Compressing a CLAUDE.md or memory file to save input tokens.

---

Loop Engineering

Agent loops — the paradigm Boris Cherny described as the next wave after prompt engineering. Skills that appear in the personality section (cherny-*) are mirrored here for discoverability.

Philosophy (also in Personality)

Skill	Use when…
cherny-loop	Deciding whether to build a loop, understanding the three stages, designing the full loop architecture.
cherny-maker-checker	An agent self-certifying its own work, or needing an independent quality gate inside a loop.

Loop Design Patterns

Skill	Use when…
loop-design	Building a loop from scratch — trigger, goal, actions, verification, memory, structural skeleton.
loop-maker-checker	Implementing the checker agent: prompt design, verdict contract, escalation on repeated failure.
loop-stopping-conditions	A loop doesn't terminate, burns budget, or needs a reliable halt strategy — four-part goal contract.

---

Roadmap

Planned suites — same depth-first approach.

Language Suites (queued)

• Java + Spring Boot — DI, JPA, REST, testing, security
• Rust — ownership, lifetimes, async, error handling, idiomatic patterns
• Go — goroutines, interfaces, errors, idiomatic patterns, performance
• TypeScript (deep) — advanced types, generics, utility types, module patterns

More Famous Philosophies (queued)

• carmack-optimization — game dev, fast math, profiling discipline
• dhh-convention — convention over configuration, Shape Up methodology
• graham-simplicity — startup thinking, simple solutions, taste in software

More 100k+ Repos (queued)

• 100k-vue — Vue 3's reactivity system vs React's model
• 100k-postgresql — MVCC, query planner, extension design

SDLC

• requirements-to-spec, code-review-discipline, release-management, incident-postmortem, observability-design

InfoSec

• threat-modeling, secure-coding, secrets-management, incident-response, cloud-security

---

Authoring Conventions

• Description = when, not what. Triggers and symptoms only; never summarize the workflow.
• Keyword-rich — error messages, symptoms, tool/command names aid discovery.
• Active, verb-first names — splunk-log-investigation, not splunk-investigation-helper.
• One excellent example over many mediocre ones; real, runnable, commented for why.
• Heavy reference → separate file (e.g., command references, templates).
• Cross-reference with REQUIRED COMPANION: markers — never @-link (force-loads and burns context).
• Duplicates are intentional — personality skills and productivity skills can coexist for the same concept (different discovery path, same quality).