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:

Scenario	Flow
New feature	brainstorm → plan → implement → cross-model-review
Greenfield project	brainstorm → research → plan → orchestrate → implement
Bug fix	implement (straight to it — scale selection handles this)
Architecture decision	brainstorm → research → decide
Large refactor	plan → orchestrate → implement → cross-model-review

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

agent-sandbox — Kubernetes Operator for AI Agent Runtimes

Full operational reference for the kubernetes-sigs/agent-sandbox operator. Covers the four CRDs (Sandbox, SandboxTemplate, SandboxClaim, SandboxWarmPool), install and upgrade hazards, warm pool HPA tuning, PDB scoping gotchas, isolation runtime selection (gVisor, Kata), network policy patterns, Karpenter integration, and the Python + Go SDK surface. Captures real-world scars from running the operator at scale. Includes detailed CRD field reference, production patterns, and client SDK deep-dive as progressive disclosure references.

/hyperskills:agent-sandbox

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:

Skill	Reference Files
implement	benchmarks.md — quantitative data from 21k operations
codex-review	prompts.md — 7 ready-to-use review prompt templates
cross-model-review	prompts.md — 7 ready-to-use review prompt templates
tilt	api-reference.md, patterns.md — full Tiltfile API + power patterns
agent-sandbox	crds.md, patterns.md, clients.md — CRD fields + production patterns + SDKs
tui-design	visual-catalog.md, app-patterns.md — Unicode catalog + app gallery

Compatibility

Platform	Installation
Claude Code	/plugin install hyperskills
Codex CLI	npx skills add hyperbliss/hyperskills -a codex
Cursor	npx skills add hyperbliss/hyperskills -a cursor
GitHub Copilot	npx skills add hyperbliss/hyperskills -a copilot
Gemini CLI	npx skills add hyperbliss/hyperskills -a gemini

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}