Skill rating

Registers external services with health checks, central config, and unified execution. Use when integrating multiple external services needing coordination.

Converts a specification into a phased, dependency-ordered implementation plan. Use after specification is complete and before execution begins.

Delegates tasks to Qwen CLI via delegation-core for Alibaba's models. Use when delegation-core selects Qwen or large-context batch processing is needed.

Detects codebase bloat via dead code, duplication, complexity, and doc bloat scans. Use when codebase feels large or before a release.

Selects optimal sources for tool calls, balancing accuracy with token cost. Use before research tasks or when deciding whether a claim needs verification.

Provides sem semantic-diff detection, install-on-first-use, and fallback patterns. Use when building skills that consume git diff output.

Improves code quality across duplication, efficiency, and architectural fit. Use when code passes tests but quality is poor or before a major release.

Review plugin quality with tiered checks and dependency scoping. Use for PR and pre-release audits.

Recovers broken agent state via crash recovery, context overflow, and merge conflict protocols. Use when an agent session fails or a worktree is corrupted.

Provides error classification, recovery, and graceful-degradation patterns. Use when implementing error handling or debugging resilience failures in any skill.

Converts a Claude Code session into a blog post, case study, or Reddit post. Use when publishing dev blog content or community posts from real sessions.

Records browser sessions via Playwright and converts video to GIF. Use when creating web UI tutorials or demos showing browser interactions.

Combines GIFs and videos into composite tutorials with vertical or grid layouts via ffmpeg. Use when assembling multi-part media into a single output.

Generates phased, dependency-ordered implementation tasks from specifications. Use after spec is complete and before starting implementation.

Configures GitHub Actions CI/CD workflows for testing, linting, and deployment. Use when setting up automation for a Python, Rust, or TypeScript project.

Orchestrates the QUALITY pipeline stage for egregore work items, running code review, unbloat, and test updates. Use when running quality checks before a PR.

Classifies and enforces constraints via soft vows, hard vows, and Nen Court layers. Use when designing or auditing enforcement mechanisms for project rules.

Provides standardized pytest config, reusable fixtures, and CI integration patterns. Use when setting up or auditing a Python plugin's test infrastructure.

Implements structured usage logging and audit trails for cost and session tracking. Use when adding audit trails, usage analytics, or cost tracking to a skill.

Computes DORA delivery-performance metrics from git and GitHub API. Use when assessing deployment frequency, lead time, or change failure rate.

Refreshes README structure favoring concision (an index, not a manual). Use when the README needs a structural update after significant project changes.

Converts a Claude Code session JSONL file into an animated GIF terminal replay. Use when creating demos or visual evidence from past sessions.

Generates text in a learned writing voice. Use when drafting content that must match a specific author's style profile extracted by voice-extract.

Detects git forge (GitHub/GitLab/Bitbucket) and maps CLI commands cross-platform. Use when writing skills that must run on any git hosting provider.

Initializes a stacked branch set from an ordered plan, one branch per slice with parent-child links. Use when a plan has 2+ sequentially dependent changes.

Cascades a rebase through an entire PR stack after a base PR merges or upstream changes. Use when a stack needs to incorporate new base branch commits.

Updates, generates, and validates tests using git-workspace context and TDD/BDD methodology. Use when code changes require new or updated test coverage.

Generates or remediates documentation with human-quality writing. Use when creating new docs, rewriting AI-generated content, or applying style profiles.

Extracts writing style patterns from exemplar text into a reusable profile. Use when creating a style guide or learning a specific author's voice.

Plans, drafts, and refines technical tutorials for developers. Use when writing step-by-step guides or getting-started walkthroughs backed by working code.

Extracts a user's writing voice from text samples via SICO comparative analysis. Use when building a voice profile for consistent generation.

Enforces validation and evidence before claiming work complete. Use before declaring implementation done, creating a PR, or submitting deliverables for review.

Runs parallel prose and craft review agents against a voice profile. Use when checking generated content for AI patterns and voice drift before publishing.

Converts webm/mp4 video files to optimized GIFs via ffmpeg with configurable quality settings. Use when post-processing recordings into shareable GIFs.

Detects shared stack membership and iterates a command across all PRs in base-to-tip order. Use when a command supports --stack flag for multi-PR iteration.

Pushes all branches in a stack and opens or updates one dependent PR per slice. Use after stack-create to publish the stack or after adding commits to a slice.

Improves a voice profile by learning from manual edits. Use after editing generated text to refine registers and close voice drift over time.

Generates terminal recordings using VHS tape scripts and produces GIF outputs. Use when creating demo GIFs or documenting CLI workflows for tutorials.

Provides review-workflow scaffolding for context, evidence, and output. Use at the start of any detailed review to ensure consistent, comparable findings.

Polishes working code through successive quality passes in fresh subagents. Use after tests pass when code needs multi-dimension refinement before release.

Implements GitHub or GitLab issues via parallel subagents with review gates between task batches. Use when resolving multi-step issues end-to-end.

Autonomous orchestrator for manifest work items through the development lifecycle. Use when running egregore to process a backlog automatically.

Scores agent actions by expected gain, cost, uncertainty, and redundancy. Use when deciding whether to dispatch an agent or invoke a tool.

Merges, dedupes, ranks, and formats research findings into a report. Use after research agents return results from multiple channels to produce a ranked report.

Searches the open web for docs, comparisons, and news via You.com MCP or WebSearch. Use when a topic needs knowledge beyond GitHub, forums, or academia.

Audits changes for additive bias and Iron Law compliance. Use when reviewing completed work before merging or after AI-assisted implementation.

Export a research session into knowledge-intake compatible markdown. Use after a research session to hand findings to memory-palace.

Applies KISS, YAGNI, and SOLID principles for clean code with reduced complexity. Use when refactoring or reviewing code for over-engineering.

Assess whether to escalate models. Use when evaluating reasoning depth.

Audits dependency supply chains for bad versions, lockfile drift, and artifact integrity. Use when adding deps, handling incidents, or releasing a plugin.