Focused AI agent skills for things models don't already know

Models already know how to write React components, Kubernetes manifests, and PyTorch code. They don't need 300 lines of examples for that.

hyperskills provides skills for things that are genuinely hard to get right without guidance — procedural knowledge distilled from thousands of real sessions, decision trees for high-stakes operations, and multi-agent orchestration patterns that actually work in production.

10 skills. Zero bloat. Each one earned its place through real-world evidence.

/plugin install hyperskills

# Install all skills
npx skills add hyperbliss/hyperskills --all

# Or pick what you need
npx skills add hyperbliss/hyperskills --skill implement
npx skills add hyperbliss/hyperskills --skill orchestrate

git clone https://github.com/hyperb1iss/hyperskills.git
ln -s $(pwd)/hyperskills/skills ~/.claude/skills/hyperskills

The skills form a workflow pipeline. Each one handles a phase of the development lifecycle and hands off to the next:

 brainstorm ──→ research ──→ plan ──→ implement ──→ codex-review
     │              │           │          │
     │              │           │          └──→ git
     │              │           │
     │              │           └──→ orchestrate (parallel agents)
     │              │
     └──────────────┴──→ Any skill can loop back when new questions emerge

Typical flows:

You don't need to follow the full pipeline. Each skill has built-in scale selection — a typo fix doesn't need brainstorming, and a clear bug doesn't need research. Start wherever makes sense.

These encode how to approach a class of work — workflows, phases, and decision gates.

Double Diamond model for creative work: diverge on the problem, converge on a definition, diverge on solutions, converge on a decision. Grounded in persistent memory (Sibyl) so you never re-explore solved problems. Includes a Council pattern for complex architectural decisions using advocate/critic agents.

/hyperskills:brainstorm

Wave-based research with deferred synthesis. Deploy agents in waves across a research surface, run gap analysis between waves, then synthesize with the full picture. Covers technology evaluation, codebase archaeology, SOTA analysis, and competitive landscape patterns. Max 3 waves — if that's not enough, reframe the question.

/hyperskills:research

Verification-driven planning where every step has a concrete check. Decomposes work into 2-5 minute tasks ordered by dependency, marks parallelizable waves for orchestration, and tracks everything in Sibyl. Includes a trust gradient — full ceremony for early tasks, lighter review as patterns stabilize.

/hyperskills:plan

The core implementation skill, distilled from 21,321 tracked operations across 64+ projects. Encodes the patterns that consistently ship working code:

• 2-3 edits then verify — the sweet spot that prevents debugging spirals
• Scale selection — from trivial (1-5 edits) to epic (1000+), with the right strategy for each
• Dependency chains — build order for fullstack and Rust projects
• Error recovery — spiral prevention, the two-correction rule, when to /clear and restart
• Decision trees — read vs edit, subagents vs direct, bug fix vs feature vs refactor

/hyperskills:implement

Meta-orchestration patterns mined from 597+ real agent dispatches. Tells you which multi-agent strategy to use, how to structure prompts for parallel agents, and when to use background vs foreground. Six strategies: Research Swarm, Epic Parallel Build, Sequential Pipeline, Parallel Sweep, Multi-Dimensional Audit, and Full Lifecycle.

/hyperskills:orchestrate

Claude writes code, Codex reviews it — different architecture, different training distribution, no self-approval bias. Multi-pass review strategy (correctness → security → architecture → performance), 7 ready-to-use prompt templates, and integration with the Ralph Loop for iterative quality enforcement.

/hyperskills:codex-review

These encode specialized knowledge for specific technologies — reference material, decision trees, and hard-won patterns.

Frameworks and checklists for secure systems. STRIDE threat modeling, Zero Trust principles, OWASP Top 10, SLSA supply chain levels, incident response phases, and compliance framework reference (SOC 2, HIPAA, PCI DSS).

/hyperskills:security

Decision trees for the operations that actually cause problems. When to rebase vs merge, how to handle lock file conflicts, SOPS encrypted file resolution, undo operations by scenario, cherry-pick workflows, and repository archaeology commands.

/hyperskills:git

Complete Tilt operational reference. CLI commands for log viewing, resource management, and debugging. Tiltfile authoring with build strategy selectors, live update decision trees, and resource configuration. Full API catalog and power patterns in progressive disclosure references.

/hyperskills:tilt

Universal design patterns for building exceptional terminal user interfaces. Layout paradigm selector, interaction model decision trees, terminal color theory, visual hierarchy techniques, data visualization, and animation patterns. Framework-agnostic — works with Ratatui, Ink, Textual, Bubbletea, or any TUI toolkit. Includes a Unicode visual catalog and gallery of real TUI app design patterns.

/hyperskills:tui-design

Skills use progressive disclosure to manage context efficiently:

Level 1: Metadata (name + description)     ← Always in context (~100 words)
Level 2: SKILL.md body                     ← Loaded when skill triggers (~1,500-3,000 words)
Level 3: references/                       ← Loaded on demand (unlimited)

Four skills include reference files for deep-dive content:

git clone https://github.com/hyperb1iss/hyperskills.git
cd hyperskills

make lint       # Run linters
make format     # Format files
make check      # Validate plugin structure
make stats      # Show plugin statistics

See AGENTS.md for the full contributor guide on adding new skills.

Licensed under the MIT License. See LICENSE for details.

_{Built by Hyperbliss Technologies}