Welcome Contribution 中文 English

This repository is a comprehensive, reusable, task-oriented Skills collection designed to support software engineering activities across the entire development lifecycle, including:

Requirement understanding, system design, implementation, testing, verification, deployment, and maintenance.

We provide:

🌐 Skills Manager Web Interface

🚀 Visit Skills Manager

You can also deploy the website locally. 👉 Guideline

Browse, search, and install skills through our interactive web interface. The Skills Manager provides:

  • 📦 One-click installation of all skills
  • ✅ Selective installation of specific skills
  • 🔍 Search and filter by category
  • 📖 Bilingual help documentation (English/中文)
  • 🎨 Modern, responsive interface

📦 Skill Packs

Organized collections of related skills for common software engineering workflows. Instead of installing skills individually, you can install curated skill packs that bundle related capabilities together.

🚀 Available Skill Packs (8 Total)

Quick Installation

# Install a single pack
cd skill-packs/formal-verification-toolkit
./install.sh

# Install multiple packs
cd skill-packs
./install-packs.sh formal-verification-toolkit security-scanner-suite

# Install all packs
cd skill-packs
./install-all-packs.sh

👉 Learn more about Skill Packs

✨ Why Skills (not just prompts)?

Modern LLMs are powerful, but raw prompting is fragile:

  • Hard to reproduce
  • Hard to evaluate
  • Hard to integrate into real workflows

We treat Skills as first-class engineering artifacts, in preparation for the future metaprogramming.

A Skill in this repo is more than a prompt:

  • It encodes procedural knowledge
  • It specifies expected inputs / outputs
  • It documents failure modes
  • It can be evaluated, composed, and reused

🤗 Think of this repo as a standard library of software engineering capabilities for LLM-powered systems.

List of Skills

Skills by Category

Code Generation

Function/Class Generator

  • Generates functions and classes from specifications
  • Supports multiple programming languages
  • Includes type hints, documentation, and error handling

Module/Component Generator

  • Builds complete modules from interface contracts
  • Generates layered architectures (model, repository, service)
  • Supports Python and Java with design patterns

Template Code Generator

  • Creates boilerplate code from templates
  • Supports common patterns and frameworks
  • Customizable templates for different use cases

Specification-Driven Generation

  • Generates code from formal specifications
  • Ensures specification compliance
  • Validates generated code against requirements

Test-Driven Generation

  • Generates implementation from test cases
  • Follows TDD principles
  • Ensures test coverage

Incremental Python Programmer

  • Implements new features in Python repositories from natural language descriptions
  • Generates comprehensive unit and integration tests
  • Ensures all tests pass and follows existing code patterns

Incremental Java Programmer

  • Implements new features in Java repositories from natural language descriptions
  • Supports Maven and Gradle build systems
  • Generates JUnit tests and ensures all tests pass successfully

Pseudocode Extractor

  • Extracts programming-language-agnostic pseudocode from source code
  • Preserves control flow and logical structure
  • Filters out implementation details for clarity

Module-Level Code Translator

  • Translates source code between programming languages at module level
  • Preserves behavior and adapts to target language idioms
  • Generates verification tests for translated code

Pseudocode to Java Code

  • Converts pseudocode descriptions into complete, executable Java programs
  • Preserves original logic and control flow
  • Applies appropriate Java idioms and best practices

Pseudocode to Python Code

  • Converts pseudocode and algorithm descriptions into executable Python code
  • Provides proper structure, documentation, and tests
  • Maintains algorithmic logic while following Python conventions

Testing

Unit Test Generator

  • Generates unit tests for functions and classes
  • Supports multiple testing frameworks
  • Includes edge cases and assertions

Integration Test Generator

  • Creates integration tests for system components
  • Tests component interactions
  • Includes setup and teardown logic

Java Test Updater

  • Updates Java tests to work with new code versions after refactoring
  • Handles signature changes, refactoring, and behavior modifications
  • Updates method calls, assertions, mocks, and ensures tests pass

Flaky Test Detector

  • Identifies non-deterministic tests
  • Analyzes test execution patterns
  • Suggests fixes for common flaky patterns

Test Oracle Generator

  • Generates expected outputs for test cases
  • Creates assertions and validation logic
  • Supports property-based testing

Edge Case Generator

  • Identifies and generates edge case tests
  • Covers boundary conditions
  • Includes corner cases and error scenarios

Directed Test Input Generator

  • Generates targeted test inputs
  • Focuses on specific code paths
  • Uses symbolic execution techniques

Fuzzing Input Generator

  • Creates randomized test inputs
  • Discovers unexpected behaviors
  • Supports mutation-based fuzzing

Test Suite Prioritizer

  • Prioritizes test execution order
  • Optimizes for early failure detection
  • Considers test dependencies and coverage

Coverage Enhancer

  • Identifies uncovered code paths
  • Generates tests to improve coverage
  • Reports coverage metrics

Test Case Documentation

  • Documents test cases and their purposes
  • Explains test scenarios and expected outcomes
  • Maintains test documentation

Python Test Updater

  • Updates Python tests to work with new code versions
  • Fixes broken tests due to signature and behavior changes
  • Analyzes code diffs and updates assertions accordingly

Bug Reproduction Test Generator

  • Automatically generates tests that reproduce reported bugs from issue reports
  • Analyzes bug symptoms, stack traces, and triggering conditions
  • Creates minimal, focused tests that reliably trigger the bug
  • Supports Python, Java, and JavaScript test frameworks

Interval-Guided Regression Test Update

  • Updates regression tests based on interval analysis

Requirement to Test

  • Converts requirements to test cases
  • Ensures requirement coverage
  • Traces tests back to requirements

Test Case Reducer

  • Reduces test cases to minimal form using delta debugging

Java Regression Test Generator

  • Automatically generates regression tests for Java codebases
  • Analyzes changes between old and new code versions
  • Ensures tests cover refactored or modified functionality

Python Regression Test Generator

  • Automatically generates regression tests for Python codebases
  • Analyzes changes between code versions and migrates existing tests
  • Generates tests for new functionality

Mocking Test Generator

  • Generates unit tests with proper mocking for Python and Java
  • Supports unittest.mock/pytest for Python and Mockito/JUnit for Java
  • Handles external dependencies and complex interactions

Test-Guided Bug Detector

  • Analyzes failing tests to detect functional bugs in code
  • Examines execution behavior, assertions, and stack traces
  • Identifies suspicious code regions causing test failures

Behavioral Mutation Analyzer

  • Systematically analyzes surviving mutants from mutation testing
  • Identifies test suite weaknesses and generates improvements
  • Categorizes why mutants survived and suggests test enhancements

Metamorphic Property Extractor

  • Automatically identifies metamorphic properties from programs
  • Enables metamorphic testing without explicit test oracles
  • Discovers input-output relationships for test generation

Metamorphic Test Generator

  • Generates test cases using metamorphic testing principles
  • Applies transformations based on metamorphic properties
  • Expands test suites and detects bugs through input-output relationships

Counterexample to Test Generator

  • Converts formal verification counterexamples into executable test cases
  • Transforms model checker outputs into unit or integration tests
  • Bridges formal verification and testing workflows

Mutation Test Suite Optimizer

  • Optimizes test suites using mutation testing analysis
  • Selects minimal subset of tests maximizing mutation kill rate
  • Reduces execution time and eliminates redundancy

Test Deduplicator

  • Analyzes test suites to identify redundant or duplicate tests
  • Examines code coverage, semantic similarity, and execution behavior
  • Groups equivalent tests and explains deduplication rationale

Java API Consistency Validator

  • Validates API consistency between two versions of Java libraries
  • Compares signatures, behavior, and exceptions
  • Identifies breaking changes and incompatible modifications

Python API Consistency Validator

  • Validates API consistency between two versions of Python libraries
  • Compares signatures, behavior, and exceptions
  • Identifies breaking changes and provides migration guidance

Code Quality & Analysis

Code Review Assistant

  • Performs automated code reviews
  • Identifies issues and suggests improvements
  • Checks coding standards compliance

Code Smell Detector

  • Detects code smells and anti-patterns
  • Suggests refactoring opportunities
  • Categorizes smells by severity

Design Smell Detector

  • Identifies architectural and design issues
  • Detects violations of design principles
  • Suggests design improvements

Code Optimizer

  • Optimizes code for performance
  • Identifies bottlenecks
  • Suggests algorithmic improvements

Dead Code Eliminator

  • Identifies unused code
  • Safely removes dead code
  • Reports elimination opportunities

Technical Debt Analyzer

  • Identifies technical debt
  • Quantifies debt impact
  • Prioritizes debt reduction

Code Pattern Extractor

  • Analyzes codebases to identify reusable code patterns and duplications
  • Generates pattern catalogs with refactoring suggestions
  • Creates reusable template code for high-value patterns

Code Search Assistant

  • Searches repositories for code related to given snippets
  • Ranks results by call chain, textual, and functional similarity
  • Outputs ranked file lists with matching code snippets

Component Boundary Identifier

  • Identifies module/component boundaries
  • Detects boundary violations
  • Analyzes architectural separation

Code Summarizer

  • Generates concise summaries of source code at multiple scales
  • Explains code functionality from functions to entire codebases
  • Helps understand complex code structures quickly

Static Bug Detector

  • Analyzes source code statically to detect potential functional bugs
  • Identifies null dereferences, incorrect conditions, unreachable code
  • Detects logic errors, resource leaks, and inconsistent state updates

Static Vulnerability Detector

  • Statically analyzes code to detect security vulnerabilities
  • Identifies buffer overflows, injection risks, insecure deserialization
  • Detects improper authentication and unsafe cryptographic usage

Vulnerability Pattern Matcher

  • Detects security vulnerabilities by matching known patterns
  • Identifies insecure coding idioms and CVE-style patterns
  • Explains why patterns are risky and conditions for exploitation

Vulnerability Root Cause Analyzer

  • Analyzes vulnerable code to identify underlying root causes
  • Identifies violated assumptions, incorrect invariants, missing validation
  • Detects unsafe component interactions

Exploitability Analyzer

  • Assesses realistic exploitability of detected vulnerabilities
  • Examines control flow, input sources, and sanitization logic
  • Determines if vulnerabilities are practically exploitable

Security Patch Advisor

  • Proposes secure remediation strategies for security vulnerabilities
  • Addresses buffer overflows, injection risks, insecure deserialization
  • Provides fixes for improper authentication and unsafe cryptographic usage

CVE Reachability Analyzer

  • Analyzes whether CVE vulnerabilities in dependencies are reachable from application code
  • Performs static and dynamic reachability analysis
  • Prioritizes CVE remediation based on actual exploitability

CVE Watchlist Action Recommendation Generator

  • Generates actionable recommendations for CVEs in dependency watchlists
  • Prioritizes CVEs based on severity, exploitability, and impact
  • Suggests patching, mitigation, or monitoring strategies

Time-Aware Dependency CVE Scanner

  • Scans dependencies for CVEs with temporal context awareness
  • Tracks CVE disclosure timelines and patch availability
  • Provides time-sensitive vulnerability management recommendations

Semantic Bug Detector

  • Detects semantic-level bugs by analyzing code behavior vs. intent
  • Infers intended purpose from names, comments, and documentation
  • Identifies mismatches between implementation and expected behavior

Behavior Preservation Checker

  • Validates that migrated or refactored codebase preserves original behavior
  • Compares runtime behavior, test results, and execution traces
  • Identifies behavioral divergences between code versions

Semantic Equivalence Verifier

  • Analyzes semantic equivalence between two code artifacts
  • Compares control flow, data flow, and observable behavior
  • Provides rigorous equivalence analysis for functions, classes, or modules

Multi-Version Behavior Comparator

  • Compares behavior across multiple versions of programs
  • Identifies functional changes, regressions, and behavioral divergences
  • Guides safe upgrades and validation processes

Regression Consistency Checker

  • Checks whether new version preserves behavior observed by tests on old version
  • Validates behavioral consistency across versions
  • Identifies unexpected behavioral changes

Interval Difference Analyzer

  • Analyzes differences in program intervals (variable value ranges) between versions
  • Detects behavioral changes and identifies potential bugs
  • Guides testing efforts based on interval analysis

Interval Profiling Performance Analyzer

  • Profiles programs to identify performance bottlenecks
  • Generates optimization recommendations with visualizations
  • Uses interval analysis for performance insights

Modular Code Enforcement (Inspired by oh-my-opencode)

  • Enforces strict modular architecture with SRP and 200 LOC limits
  • Bans catch-all files (utils.ts, helpers.ts) in favor of focused modules
  • Detects and splits files with multiple responsibilities

Dead Code Removal (Inspired by oh-my-opencode)

  • Systematic dead code removal with LSP-verified safety
  • Parallel batch processing with conflict-free execution
  • Atomic commits per batch with automatic rollback on failure

Documentation

API Documentation Generator

  • Generates API documentation
  • Creates reference documentation
  • Includes usage examples

Code Comment Generator

  • Generates inline code comments
  • Explains complex logic
  • Follows documentation standards

Markdown Document Structurer

  • Reorganizes markdown documents into well-structured format
  • Fixes heading hierarchy and generates table of contents
  • Standardizes formatting and improves readability

README Generator

  • Generates comprehensive, user-friendly README.md files
  • Includes project introduction, prerequisites, and setup instructions
  • Provides executable usage examples and repository structure overview

Change Log Generator

  • Creates change logs from commits
  • Categorizes changes by type
  • Follows semantic versioning

Code Change Summarizer

  • Generates structured pull request descriptions from code changes
  • Documents breaking changes with migration guides
  • Adds testing instructions and context enhancements

Release Notes Writer

  • Writes release notes
  • Highlights new features and fixes
  • Targets end users

Legacy Code Summarizer

  • Summarizes legacy codebases
  • Explains code functionality
  • Aids in understanding old code

Python Repository Quick Start

  • Quickly analyzes Python repositories
  • Identifies project type, entry points, and dependencies
  • Generates setup and execution instructions

Error Explanation Generator

  • Explains error messages
  • Provides context and solutions
  • Helps with debugging

Init Deep (Inspired by oh-my-opencode)

  • Generates hierarchical AGENTS.md context files throughout a project tree
  • Provides AI agents with directory-specific knowledge automatically
  • Supports max-depth control and incremental generation

Session Handoff (Inspired by oh-my-opencode)

  • Creates structured context summaries for cross-session continuation
  • Captures completed work, remaining tasks, key files, and gotchas
  • Enables seamless handoff between AI sessions or teammates

Architecture & Design

API Design Assistant

  • Assists in API design
  • Suggests RESTful patterns
  • Validates API consistency

Design Pattern Suggestor

  • Suggests appropriate design patterns
  • Explains pattern applicability
  • Provides implementation guidance

Configuration Generator

  • Generates configuration files
  • Supports multiple formats (YAML, JSON, XML)
  • Validates configuration schemas

Dependency Resolver

  • Resolves dependency conflicts
  • Suggests compatible versions
  • Analyzes dependency trees

Requirements & Specifications

Requirement Summarizer

  • Summarizes requirements documents
  • Extracts key requirements
  • Organizes by priority

Requirement Coverage Checker

  • Checks requirement coverage
  • Identifies gaps in implementation
  • Traces requirements to code and test

Requirement Comparison Reporter

  • Compares old and new requirement documents
  • Maps requirement changes to code components
  • Generates detailed modification plans in Markdown format

Ambiguity Detector

  • Detects ambiguous requirements
  • Highlights unclear specifications
  • Suggests clarifications

Scenario Generator

  • Generates usage scenarios
  • Creates user stories
  • Develops test scenarios

Specification Generator

  • Generates formal specifications
  • Converts natural language to specs
  • Validates specification completeness

Natural Language to Constraints

  • Converts NL requirements to formal constraints
  • Supports constraint languages
  • Validates constraint consistency

Strategic Planner (Inspired by oh-my-opencode)

  • Interview-based strategic planning for complex software tasks
  • Conducts gap analysis to catch hidden intentions and ambiguities
  • Generates detailed work plans with acceptance criteria and test strategy

DevOps & Deployment

Build/CI Migration Assistant

  • Migrates build systems and CI/CD configurations

CD Pipeline Generator

  • Creates CD pipeline configurations for automated deployment
  • Supports AWS, GCP, and Azure cloud platforms
  • Includes environment separation, approval gates, and rollback capabilities

CI Pipeline Synthesizer

  • Generates CI pipeline configurations for automated building and testing
  • Supports GitHub Actions with dependency caching and matrix testing
  • Includes templates for Node.js, Python, Go, and Rust projects

Config Consistency Checker

  • Detects configuration inconsistencies across environments

Containerization Assistant

  • Creates Dockerfiles and container configs
  • Optimizes container images
  • Supports multi-stage builds

Environment Setup Assistant

  • Generates environment setup scripts
  • Manages dependencies and configurations
  • Supports multiple platforms

Rollback Strategy Advisor

  • Suggests rollback strategies
  • Plans deployment reversions
  • Minimizes downtime

Docker Hub Automation

  • Automates Docker Hub tasks via Rube MCP (Composio)
  • Manages repositories, images, tags, and container registry
  • Supports Docker Hub operations

Code Instrumentation Generator

  • Automatically instruments source code to collect runtime information
  • Preserves program semantics while adding instrumentation
  • Supports various instrumentation strategies for debugging and analysis

Security-Sensitive Path Instrumenter

  • Adds structured logging instrumentation to security-critical code paths
  • Monitors authentication, authorization, input validation, and session management
  • Enables runtime monitoring of security-relevant events

Taint Instrumentation Assistant

  • Instruments code to track untrusted and sensitive data flow
  • Detects security vulnerabilities through taint analysis
  • Identifies potential injection points and data leaks

Critical Interval Security Checker

  • Analyzes code to identify security-critical time intervals
  • Detects timing vulnerabilities that could compromise security
  • Identifies race conditions and time-of-check-time-of-use issues

Release Change Analyzer (Inspired by oh-my-opencode)

  • Compares HEAD with latest published version to analyze real changes
  • Groups changes by type (feat/fix/refactor) with actual diff descriptions
  • Recommends version bump (major/minor/patch) with reasoning

Debugging & Error Handling

Bug Localization

  • Localizes bugs in code
  • Analyzes stack traces and logs
  • Suggests likely bug locations

Bug to Patch Generator

  • Generates patches for identified bugs
  • Creates minimal fixes
  • Includes test cases for fixes

Conflict Analyzer

  • Analyzes merge conflicts
  • Suggests conflict resolutions
  • Explains conflicting changes

Failure-Oriented Instrumentation

  • Selectively instruments code to capture runtime data for debugging

Git Bisect Assistant

  • Automates git bisect to find the first bad commit

Regression Root Cause Analyzer

  • Analyzes regression failures
  • Identifies root causes
  • Suggests fixes

Replay-Oriented Instrumentation

  • Records execution for deterministic replay debugging

Runtime Error Explainer

  • Explains runtime errors
  • Provides debugging guidance
  • Suggests fixes

Issue Report Generator

  • Automatically generates clear, actionable issue reports from failing tests
  • Analyzes test failures to understand expected vs. actual behavior
  • Identifies affected code components and suggests fixes

Bug History Summarizer

  • Traces and summarizes the complete lifecycle of a bug across code versions
  • Provides historical context for bug evolution
  • Helps understand bug patterns and resolution strategies

Bisect-Aware Instrumentation

  • Instruments code to support efficient git bisect operations
  • Produces deterministic pass/fail signals and concise runtime summaries
  • Creates robust test scripts for bisect workflows

Reproduction Trace Instrumenter

  • Instruments source code to capture detailed execution traces for bug reproduction
  • Records function calls, variable values, control flow, and program state
  • Generates replay scripts for deterministic bug reproduction

State Snapshot Instrumenter

  • Instruments programs to capture snapshots of key program states at runtime
  • Includes variable values, memory state, call stacks, and execution context
  • Saves snapshots in structured JSON format for analysis

Trace Collection Assistant

  • Collects, normalizes, and structures execution traces from instrumented programs
  • Processes strace, ltrace, and custom trace formats
  • Makes traces suitable for debugging, reproduction, or performance analysis

SZZ Bug Identifier

  • Performs SZZ algorithm analysis to identify bug-introducing commits
  • Traces modified lines back through version history
  • Links bug fixes to their originating changes

Semantic SZZ Analyzer

  • Extends traditional SZZ algorithm with semantic analysis
  • Distinguishes actual bug-introducing changes from refactoring
  • Provides more accurate identification of bug origins

Formal Methods & Verification

ACSL Annotation Assistant

  • Assists with ACSL annotations
  • Generates function contracts
  • Validates annotation correctness

Assertion Synthesizer

  • Synthesizes program assertions
  • Generates invariants and pre/post-conditions
  • Validates assertion correctness

Invariant Inference

  • Infers loop and program invariants
  • Uses static and dynamic analysis
  • Validates inferred invariants

Static Reasoning Verifier

  • Verifies code using static analysis
  • Checks co