hyperskills

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

What This Is

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.

Installation

Claude Code

/plugin install hyperskills

Vercel Skills (skills.sh)

# 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

Manual

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

How the Skills Work Together

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 ──→ cross-model-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.

Skills

Process Skills

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

brainstorm — Structured Ideation

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

research — Multi-Agent Knowledge Gathering

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

plan — Task Decomposition

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

implement — Verification-Driven Coding

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

orchestrate — Multi-Agent Coordination

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

cross-model-review — Bidirectional Cross-Model Code Review

The authoring model writes code, a different model reviews it — different architecture, different training distribution, no self-approval bias. Detects your host (Claude Code or Codex) and invokes the other model's CLI automatically. Covers both directions: Claude → Codex via codex review, and Codex → Claude via claude -p. Includes multi-pass strategy, piped-diff vs tool-access modes, and 7 ready-to-use prompt templates.

/hyperskills:cross-model-review

codex-review — Codex-Specific Code Review

The Claude → Codex direction in depth. Full Codex CLI reference including codex review (structured diff review) and codex exec (freeform deep-dive), multi-pass review strategy (correctness → security → architecture → performance), and integration with the Ralph Loop for iterative quality enforcement. Use cross-model-review if you want bidirectional host detection; use this one when you specifically want Codex as the reviewer from a Claude session.

/hyperskills:codex-review

Domain Skills

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

security — Security Operations

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

git — Advanced Git Operations

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

tilt — Kubernetes Development

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

tui-design — Terminal UI Design System

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

Architecture

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)

Skills with reference files for deep-dive content:

Compatibility

Development

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.

License

Licensed under the MIT License. See LICENSE for details.

_{Built by Hyperbliss Technologies}