Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
Use proactively when a logical chunk of implementation is complete and needs review against plan, spec, or coding standards. Triggers: step completed from an implementation plan, feature implementation finished, significant code changes committed, pre-merge review needed, PR preparation, architecture compliance check. Also use when reviewing code quality, test coverage, or design pattern adherence after any non-trivial implementation work.
Use proactively when working with dependencies — package.json, Cargo.toml, go.mod, pyproject.toml, requirements.txt, pom.xml, build.gradle. Triggers: vulnerability scanning, CVE remediation, version conflict resolution, dependency audit, bundle size optimization, lock file issues, breaking upgrades, peer dependency errors, unused dependency detection, license compliance, supply chain security review, npm/yarn/pnpm/pip/poetry/uv/cargo/maven/gradle issues.
Use when creating or improving documentation — API docs, tutorials, architecture guides, README files, getting-started guides, migration guides. Triggers: API documentation with code examples, tutorial creation, documentation audit for staleness or gaps, architecture decision records, changelog writing, SDK/library documentation, inline documentation review, doc structure planning.
Use when designing or improving Git workflows — branching strategies, merge policies, release automation, repository maintenance. Triggers: branching strategy design, merge conflict reduction, release process automation, semantic versioning setup, changelog generation, commit convention enforcement, monorepo management, Git hooks configuration, CI/CD integration with Git, history cleanup, branch protection rules, PR workflow optimization.
Use proactively when working on Rust code — .rs files, Cargo.toml, cargo commands. Triggers: borrow checker errors, lifetime annotations, ownership/borrowing design, trait system design (object safety, async traits, HRTBs), async patterns (tokio, select!, cancellation safety), unsafe code review, performance optimization (allocations, iterator chains, zero-cost abstractions), macro development, workspace/feature-flag configuration, clippy/rustfmt issues, FFI bindings. Also use when reviewing or debugging Rust code, not just implementing.
You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
Use when you have a written implementation plan to execute in a separate session with review checkpoints
Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A collection of plugins for agentic AI assistants, built on top of composable "skills" and instructions that make sure your agent uses them.
Create, review, customize, and manage plugins and reusable agent artifacts. Includes workflows for scaffolding plugins, writing skills against a shared standard, reviewing skill bundles and subagents, and adapting distributable plugins for your organization.
A complete software engineering workflow: brainstorming, planning, TDD, debugging, code review, and more. Built on composable skills that trigger automatically when your agent encounters relevant tasks.
A collection of skills that enhance AI agents with specialized capabilities for developing on the Moonbeam parachain: adding pallets, precompiles, XCM messaging, runtime development, testing, migrations, and more.
Note: Installation differs by platform. Claude Code and Cursor have built-in plugin marketplaces. Codex and OpenCode require manual setup.
In Claude Code, register the marketplace first:
/plugin marketplace add Moonsong-Labs/knowledge-work-plugins
Then install the plugin from this marketplace:
/plugin install core-engineering@moonsong-labs
Cursor automatically detects plugins installed by Claude Code. Install via Claude Code first, then restart Cursor.
Tell Codex:
Fetch and follow instructions from https://raw.githubusercontent.com/Moonsong-Labs/knowledge-work-plugins/refs/heads/main/core-engineering/.codex/INSTALL.md
Detailed docs: core-engineering/docs/README.codex.md
Tell OpenCode:
Fetch and follow instructions from https://raw.githubusercontent.com/Moonsong-Labs/knowledge-work-plugins/refs/heads/main/core-engineering/.opencode/INSTALL.md
Detailed docs: core-engineering/docs/README.opencode.md
Start a new session in your chosen platform and ask for something that should trigger a skill (for example, "help me plan this feature" or "let's debug this issue"). The agent should automatically invoke the relevant skill.
To run the root just check and just test recipes locally, install these CLIs and make sure they are on your PATH:
justbun (provides bunx for markdownlint-cli2 and shellcheck)go (used via go run for shfmt and actionlint)yamllinttyposskills-refclaude (Claude Code CLI)jqnode and npmpython3gittimeout (coreutils; on macOS you may need to install it separately so timeout is available in PATH)You do not need to install markdownlint-cli2, shellcheck, shfmt, or actionlint separately because the root justfile runs them through bunx and go run.
The Claude-based test suites also expect the local plugin to be enabled. This can be most easily be enabled via the --plugin-dir command line option.
The writing-skills skill in the plugin-management plugin guides you through creating and testing new skills.
Fork and clone the repository
Start Claude Code with the plugin-management plugin loaded:
claude --plugin-dir ./plugin-management
Ask your agent to create a new skill:
I want to add a new skill to [plugin name] for [describe what it does]
The writing-skills skill will activate and guide you through the TDD process: write failing tests (baseline behavior), write the skill, verify it works, and refactor.
Submit a PR with your new skill.
Plugins are self-contained directories at the root of this repository. The plugin-management plugin provides a guided workflow for creating new plugins.
Fork and clone the repository
Start Claude Code with the plugin-management plugin loaded:
claude --plugin-dir ./plugin-management
Ask your agent to create a new plugin:
I want to create a new plugin for [describe what it does]
The create-plugin skill will activate and walk you through a 5-phase process: discovery, component planning, designing your first component, generating all files, and validation.
Submit a PR with your new plugin.
Skills update automatically when you update the plugin:
/plugin update core-engineering
Inspired by:
npx claudepluginhub moonsong-labs/knowledge-work-plugins --plugin core-engineeringA collection of skills that enhance AI agents with specialized capabilities for developing on the Moonbeam parachain. Each skill provides actionable instructions that enable agents to perform specific development tasks effectively.
Create, review, customize, and manage plugins and reusable agent artifacts
Core skills library for Claude Code: TDD, debugging, collaboration patterns, and proven techniques
Verification-first engineering toolkit for Claude Code. 15 skills across a 5-phase spine (Investigate → Design → Implement → Verify → Ship), 8 specialist agents, an interactive setup wizard. Every skill has rationalizations + evidence requirements. Built for senior ICs and tech leads.
Production-grade engineering skills for AI coding agents — covering the full software development lifecycle from spec to ship.
52 agent skills for systematic software development. Covers design, planning, TDD, code review, debugging, quality gates, and adversarial testing. 12 core skills are eval-tested with measured A/B deltas using Anthropic's skill evaluation framework.
Superpowers Plus core skills library for Claude Code: planning, execution routing, TDD, debugging, and collaboration workflows
Harness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses