Skillshub skill-adapter

install

source · Clone the upstream repo

git clone https://github.com/ComeOnOliver/skillshub

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/ComeOnOliver/skillshub "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/jeremylongshore/claude-code-plugins-plus-skills/skill-adapter" ~/.claude/skills/comeonoliver-skillshub-skill-adapter-eaba9b && rm -rf "$T"

manifest: skills/jeremylongshore/claude-code-plugins-plus-skills/skill-adapter/SKILL.md

Skill Adapter

Overview

Analyzes existing plugins in the repository to extract their capabilities, then synthesizes and applies those learned patterns to the current task. Functions as a universal skill chameleon that discovers relevant plugins, extracts their approaches and methodologies, and adapts them to novel requests.

Prerequisites

Read access to the
```
plugins/
```
directory tree (community, packages, examples categories)
```
grep
```
and
```
find
```
available on PATH for plugin discovery

Familiarity with the plugin structure:

commands/*.md

agents/*.md

skills/*/SKILL.md

, and

scripts/

Instructions

Analyze the user's task to identify the core capability needed, the domain (security, devops, testing, documentation, etc.), and key requirements or constraints (see
```
${CLAUDE_SKILL_DIR}/references/how-it-works.md
```
).
Search existing plugins for relevant capabilities using file globbing across
```
plugins/community/
```
,
```
plugins/packages/
```
, and
```
plugins/examples/
```
directories. Match on
```
plugin.json
```
descriptions and keyword fields.
For each relevant plugin discovered, extract capabilities from its components:
- Commands (
```
commands/*.md
```
  ): read content, extract approach and input/output patterns.
- Agents (
```
agents/*.md
```
  ): understand roles, decision-making patterns, expertise areas.
- Skills (
```
skills/*/SKILL.md
```
  ): read instructions, extract core capability and tool usage.
- Scripts (
```
scripts/*.sh
```
  ,
```
*.py
```
  ): analyze logic, identify reusable patterns and error handling.
Synthesize extracted patterns by merging complementary approaches, simplifying where possible, and ensuring compatibility with the current environment.
Apply the adapted skill to the user's task, following the learned methodology while adjusting syntax, tools, and output format to match the current context.
Report which plugins were consulted, what patterns were extracted, and how they were adapted for the current task.

Output

A structured adaptation report containing:

List of plugins analyzed and capabilities extracted from each
The synthesized approach combining relevant patterns
The direct application of that approach to the user's task
Any caveats or limitations of the adapted skill

Error Handling

Error	Cause	Solution
No matching plugins found	Search terms too narrow or domain not represented	Broaden search keywords; check alternative categories; fall back to general-purpose approach
Plugin directory inaccessible	Missing read permissions or incorrect path	Verify `plugins/` directory exists and permissions allow traversal
Incompatible patterns	Extracted approaches conflict with current environment	Prioritize the most relevant plugin's approach; discard conflicting elements
Empty skill/command files	Plugin has stub content without real instructions	Skip that plugin and note it as incomplete; rely on other sources

Examples

Learning code analysis from security plugins: Task: "Analyze this codebase for issues." Process: Discover

owasp-top-10-scanner

code-quality-enforcer

, and

security-audit-agent

. Extract OWASP vulnerability checks, complexity/duplication metrics, and dependency scanning patterns. Synthesize a multi-layer analysis covering security, quality, and dependencies. Apply to the target codebase (see

${CLAUDE_SKILL_DIR}/references/example-workflows.md

Adopting documentation skills: Task: "Generate API documentation." Process: Find

api-documenter

openapi-generator

readme-builder

. Extract code parsing, OpenAPI spec generation, and hierarchical documentation structuring. Combine into an end-to-end pipeline: parse endpoints, generate spec, create interactive docs, build README.

Learning automation from DevOps plugins: Task: "Automate deployment process." Process: Search DevOps category for deployment, CI/CD, and Docker plugins. Extract build-test-deploy-verify workflows, parallel job patterns, and service orchestration. Adapt to the user's specific tech stack and infrastructure.

Resources

${CLAUDE_SKILL_DIR}/references/how-it-works.md

-- detailed five-phase adaptation process

${CLAUDE_SKILL_DIR}/references/example-workflows.md

-- end-to-end workflow examples

${CLAUDE_SKILL_DIR}/references/errors.md

-- error handling patterns