Stats
Actions
Tags
From copilot-cli-toolkit
Analyzes any input to recommend existing Claude Code skills, improve them, or create new ones via triage, 11 thinking models, and multi-agent synthesis. Avoids duplicates.
How this skill is triggered — by the user, by Claude, or both
Slash command
/copilot-cli-toolkit:SkillForgeclaude-opus-4-6This skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
Analyzes ANY input to find, improve, or create the right skill.
TRANSFORMATION_NOTES.mdassets/images/04-four-phase-architecture.pngassets/images/05-phase1-thinking-lenses.pngassets/images/06-phases-2-3.pngassets/images/07-phase4-synthesis.pngassets/images/08-evolution-mandate.pngassets/images/09-core-principles.pngassets/images/11-directory-structure.pngassets/images/12-installation.pngassets/templates/script-template.pyassets/templates/skill-md-template.mdassets/templates/skill-spec-template.xmlreferences/architecture-patterns.mdreferences/configuration.mdreferences/degrees-of-freedom.mdreferences/evolution-scoring.mdreferences/evolution-timelessness.mdreferences/iteration-guide.mdreferences/modularity-guidelines.mdreferences/multi-lens-framework.mdAnalyzes ANY input to find, improve, or create the right skill.
Any input works. SkillForge will intelligently route to the right action:
# These all work - SkillForge figures out what you need:
SkillForge: create a skill for automated code review
→ Creates new skill (after checking no duplicates exist)
help me debug this TypeError
→ Recommends ErrorExplainer skill (existing)
improve the testgen skill to handle React components better
→ Enters improvement mode for TestGen
do I have a skill for database migrations?
→ Recommends DBSchema, database-migration skills
TypeError: Cannot read property 'map' of undefined
→ Routes to debugging skills (error detected)
SkillForge: {goal} - Full autonomous skill creationcreate skill - Natural language activationdesign skill for {purpose} - Purpose-first creationultimate skill - Emphasize maximum qualityskillforge --plan-only - Generate specification without execution{any input} - Analyzes and routes automaticallydo I have a skill for - Searches existing skillswhich skill / what skill - Recommends matching skillsimprove {skill-name} skill - Enters improvement modehelp me with / I need to - Detects task and routes| Input | Output | Quality Gate |
|---|---|---|
| Any input | Triage → Route → Action | Phase 0 analysis |
| Explicit create | New skill | Unanimous panel approval |
| Task/question | Skill recommendation | Match confidence ≥60% |
ANY USER INPUT
(prompt, error, code, URL, question, task request)
│
▼
┌─────────────────────────────────────────────────────┐
│ Phase 0: SKILL TRIAGE (NEW) │
│ • Classify input type (create/improve/question/task)│
│ • Scan 250+ skills in ecosystem │
│ • Match against existing skills with confidence % │
│ • Route to: USE | IMPROVE | CREATE | COMPOSE │
├─────────────────────────────────────────────────────┤
│ ↓ USE_EXISTING ↓ IMPROVE ↓ CREATE │
│ [Recommend] [Load & Enhance] [Continue] │
└─────────────────────────────────────────────────────┘
│ (if CREATE_NEW or IMPROVE_EXISTING)
▼
┌─────────────────────────────────────────────────────┐
│ Phase 1: DEEP ANALYSIS │
│ • Expand requirements (explicit, implicit, unknown) │
│ • Apply 11 thinking models + Automation Lens │
│ • Question until no new insights (3 empty rounds) │
│ • Identify automation/script opportunities │
├─────────────────────────────────────────────────────┤
│ Phase 2: SPECIFICATION │
│ • Generate XML spec with all decisions + WHY │
│ • Include scripts section (if applicable) │
│ • Validate timelessness score ≥ 7 │
├─────────────────────────────────────────────────────┤
│ Phase 3: GENERATION │
│ • Write SKILL.md with fresh context │
│ • Generate references/, assets/, and scripts/ │
├─────────────────────────────────────────────────────┤
│ Phase 4: SYNTHESIS PANEL │
│ • 3-4 Opus agents review independently │
│ • Script Agent added when scripts present │
│ • All agents must approve (unanimous) │
│ • If rejected → loop back with feedback │
└─────────────────────────────────────────────────────┘
│
▼
Production-Ready Agentic Skill
Key principles:
Start with least privilege (Read, Glob, Grep, Write, Edit).
Only add higher-risk tools when explicitly required:
Bash for deterministic local scripts that cannot be replaced with file editsWebFetch / WebSearch only when external facts are requiredTask only for true parallel sub-agent orchestration| Command | Action |
|---|---|
SkillForge: {goal} | Full autonomous execution |
SkillForge --plan-only {goal} | Generate specification only |
SkillForge --quick {goal} | Reduced depth (not recommended) |
SkillForge --triage {input} | Run Phase 0 triage only |
SkillForge --improve {skill} | Enter improvement mode for existing skill |
Before creating anything, SkillForge intelligently analyzes your input to determine the best action.
┌────────────────────────────────────────────────────────────────────┐
│ ANY USER INPUT │
│ (prompt, error, code, URL, question, task request, anything) │
└────────────────────────────────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────┐
│ Step 1: INPUT CLASSIFICATION │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ explicit_create │ │ explicit_improve│ │ skill_question │ │
│ │ "create skill" │ │ "improve skill" │ │ "do I have..." │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ task_request │ │ error_message │ │ code_snippet │ │
│ │ "help me with" │ │ "TypeError..." │ │ [pasted code] │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
└────────────────────────────────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────┐
│ Step 2: SKILL ECOSYSTEM SCAN │
│ • Load index of 250+ skills (discover_skills.py) │
│ • Match input against all skills with confidence scoring │
│ • Identify top matches with reasons │
└────────────────────────────────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────┐
│ Step 3: DECISION MATRIX │
│ │
│ Match ≥80% + explicit create → CLARIFY (duplicate warning) │
│ Match ≥80% + other input → USE_EXISTING (recommend skill) │
│ Match 50-79% → IMPROVE_EXISTING (enhance match) │
│ Match <50% + explicit create → CREATE_NEW (proceed to Phase 1) │
│ Multi-domain detected → COMPOSE (suggest skill chain) │
│ Ambiguous input → CLARIFY (ask for more info) │
└────────────────────────────────────────────────────────────────────┘
| Action | When | Result |
|---|---|---|
| USE_EXISTING | Match ≥80% | Recommends existing skill(s) to invoke |
| IMPROVE_EXISTING | Match 50-79% | Loads skill and enters enhancement mode |
| CREATE_NEW | Match <50% | Proceeds to Phase 1 (Deep Analysis) |
| COMPOSE | Multi-domain | Suggests skill chain via SkillComposer |
| CLARIFY | Ambiguous or duplicate | Asks user to clarify intent |
# Run triage on any input
python scripts/triage_skill_request.py "help me debug this error"
# JSON output for automation
python scripts/triage_skill_request.py "create a skill for payments" --json
# Examples:
python scripts/triage_skill_request.py "TypeError: Cannot read property 'map'"
# → USE_EXISTING: Recommends ErrorExplainer (92%)
python scripts/triage_skill_request.py "create a skill for code review"
# → CLARIFY: CodeReview skill exists (85%), create anyway?
python scripts/triage_skill_request.py "help me with API and auth and testing"
# → COMPOSE: Multi-domain, suggests APIDesign + AuthSystem + TestGen chain
Phase 0 uses a pre-built index of all skills:
# Rebuild skill index (run periodically or after installing new skills)
python scripts/discover_skills.py
# Index location: ~/.cache/skillrecommender/skill_index.json
# Scans: ~/.claude/skills/, plugins/marketplaces/*, plugins/cache/*
Before distribution, validate your skill:
# Quick validation (required for packaging)
python scripts/quick_validate.py ~/.claude/skills/my-skill/
# Full structural validation
python scripts/validate-skill.py ~/.claude/skills/my-skill/
# Package for distribution
python scripts/package_skill.py ~/.claude/skills/my-skill/ ./dist
Skills must use only these allowed frontmatter properties:
| Property | Required | Description |
|---|---|---|
name | Yes | Hyphen-case, max 64 chars |
description | Yes | Max 1024 chars, no angle brackets |
license | No | MIT, Apache-2.0, etc. |
allowed-tools | No | Restrict tool access (comma-separated or YAML list) |
model | No | Specific Claude model (e.g., claude-sonnet-4-20250514) |
context | No | Set to fork for isolated sub-agent context |
agent | No | Agent type when context: fork (Explore, Plan, general-purpose) |
hooks | No | Lifecycle hooks (PreToolUse, PostToolUse, Stop) |
user-invocable | No | Show in slash menu (default: true) |
metadata | No | Custom fields (version, author, domains, etc.) |
Basic Example:
---
name: my-skill
description: What this skill does and when to use it
license: MIT
model: claude-opus-4-6
user-invocable: true
metadata:
version: 1.0.0
author: your-name
---
Advanced Example (with forked context and hooks):
---
name: isolated-analyzer
description: Runs analysis in isolated context with validation hooks
license: MIT
model: claude-opus-4-6
context: fork
agent: Explore
user-invocable: true
allowed-tools:
- Read
- Glob
- Grep
hooks:
PreToolUse:
- matcher: "Bash"
hooks:
- type: command
command: "./scripts/validate.sh"
metadata:
version: 1.0.0
---
Field Details:
| Field | Values | Notes |
|---|---|---|
context | fork | Creates isolated sub-agent with separate conversation history |
agent | Explore, Plan, general-purpose | Only valid when context: fork |
user-invocable | true, false | false hides from slash menu but Claude can still auto-invoke |
hooks | Object | See Hooks Integration section |
~/.claude/skills/{skill-name}/
├── SKILL.md # Main entry point (required)
├── references/ # Deep documentation (optional)
│ ├── patterns.md
│ └── examples.md
├── assets/ # Templates (optional)
│ └── templates/
└── scripts/ # Automation scripts (optional)
├── validate.py # Validation/verification
├── generate.py # Artifact generation
└── state.py # State management
Scripts enable skills to be agentic - capable of autonomous operation with self-verification.
| Category | Purpose | When to Include |
|---|---|---|
| Validation | Verify outputs meet standards | Skill produces artifacts |
| Generation | Create artifacts from templates | Repeatable artifact creation |
| State Management | Track progress across sessions | Long-running operations |
| Transformation | Convert/process data | Data processing tasks |
| Calculation | Compute metrics/scores | Scoring or analysis |
Script Requirements:
Result dataclass pattern for structured returnsSee: references/script-integration-framework.md
Skills can define lifecycle hooks for validation, logging, and safety:
---
name: secure-skill
hooks:
PreToolUse:
- matcher: "Bash"
hooks:
- type: command
command: "./scripts/validate-input.sh"
PostToolUse:
- matcher: "Write"
hooks:
- type: command
command: "./scripts/log-output.sh"
once: true
Stop:
- hooks:
- type: command
command: "./scripts/cleanup.sh"
---
Hook Types:
| Hook | When Triggered | Use Case |
|---|---|---|
PreToolUse | Before tool execution | Input validation, security checks |
PostToolUse | After tool execution | Output logging, verification |
Stop | When skill completes | Cleanup, state persistence |
Hook Configuration:
| Field | Description |
|---|---|
matcher | Tool name pattern to match (e.g., "Bash", "Write", "Bash(python:*)") |
type | Hook type: command (shell) or prompt (Claude evaluation) |
command | Shell command to execute (for type: command) |
once | If true, run only once per session (default: false) |
Read $TOOL_INPUT / $TOOL_OUTPUT inside hook scripts from environment variables.
Do not interpolate untrusted tool payloads directly into shell command strings.
When to Use Hooks:
| Scenario | Hook Type | Example |
|---|---|---|
| Validate script inputs | PreToolUse | Check parameters before python scripts/*.py |
| Log generated artifacts | PostToolUse | Record files created by Write tool |
| Security gate | PreToolUse | Block dangerous bash commands |
| Cleanup temp files | Stop | Remove intermediate artifacts |
Example: Script Validation Hook
For skills with scripts, add input validation:
hooks:
PreToolUse:
- matcher: "Bash(python:scripts/*)"
hooks:
- type: command
command: "python scripts/quick_validate.py . 2>/dev/null || true"
once: true
| Avoid | Why | Instead |
|---|---|---|
| Duplicate skills | Bloats registry | Check existing first |
| Single trigger | Hard to discover | 3-5 varied phrases |
| No verification | Can't confirm success | Measurable outcomes |
| Over-engineering | Complexity without value | Start simple |
| Missing WHY | Can't evolve | Document rationale |
| Invalid frontmatter | Can't package | Use allowed properties only |
After creation:
< or >python scripts/quick_validate.py passespython scripts/check_docs_safety.py passesTransform user's goal into comprehensive requirements:
USER INPUT: "Create a skill for X"
│
▼
┌─────────────────────────────────────────────────────────┐
│ EXPLICIT REQUIREMENTS │
│ • What the user literally asked for │
│ • Direct functionality stated │
├─────────────────────────────────────────────────────────┤
│ IMPLICIT REQUIREMENTS │
│ • What they probably expect but didn't say │
│ • Standard quality expectations │
│ • Integration with existing patterns │
├─────────────────────────────────────────────────────────┤
│ UNKNOWN UNKNOWNS │
│ • What they don't know they need │
│ • Expert-level considerations they'd miss │
│ • Future needs they haven't anticipated │
├─────────────────────────────────────────────────────────┤
│ DOMAIN CONTEXT │
│ • Related skills that exist │
│ • Patterns from similar skills │
│ • Lessons from skill failures │
└─────────────────────────────────────────────────────────┘
Check for overlap with existing skills:
ls ~/.claude/skills/
# Grep for similar triggers in existing SKILL.md files
| Match Score | Action |
|---|---|
| >7/10 | Use existing skill instead |
| 5-7/10 | Clarify distinction before proceeding |
| <5/10 | Proceed with new skill |
Apply all 11 thinking models systematically:
| Lens | Core Question | Application |
|---|---|---|
| First Principles | What's fundamentally needed? | Strip convention, find core |
| Inversion | What guarantees failure? | Build anti-patterns |
| Second-Order | What happens after the obvious? | Map downstream effects |
| Pre-Mortem | Why did this fail? | Proactive risk mitigation |
| Systems Thinking | How do parts interact? | Integration mapping |
| Devil's Advocate | Strongest counter-argument? | Challenge every decision |
| Constraints | What's truly fixed? | Separate real from assumed |
| Pareto | Which 20% delivers 80%? | Focus on high-value features |
| Root Cause | Why is this needed? (5 Whys) | Address cause not symptom |
| Comparative | How do options compare? | Weighted decision matrix |
| Opportunity Cost | What are we giving up? | Explicit trade-offs |
Minimum requirement: All 11 lenses scanned, at least 5 applied in depth.
See: references/multi-lens-framework.md
Iterative self-questioning until no new insights emerge:
ROUND N:
│
├── "What am I missing?"
├── "What would an expert in {domain} add?"
├── "What would make this fail?"
├── "What will this look like in 2 years?"
├── "What's the weakest part of this design?"
└── "Which thinking model haven't I applied?"
│
└── New insights > 0?
│
├── YES → Incorporate and loop
└── NO → Check termination criteria
Termination Criteria:
See: references/regression-questions.md
Identify opportunities for scripts that enable agentic operation:
FOR EACH operation in the skill:
│
├── Is this operation repeatable?
│ └── YES → Consider generation script
│
├── Does this produce verifiable output?
│ └── YES → Consider validation script
│
├── Does this need state across sessions?
│ └── YES → Consider state management script
│
├── Does this involve external tools?
│ └── YES → Consider integration script
│
└── Can Claude verify success autonomously?
└── NO → Add self-verification script
Automation Lens Questions:
| Question | Script Category if YES |
|---|---|
| What operations will be repeated identically? | Generation |
| What outputs require validation? | Validation |
| What state needs to persist? | State Management |
| Can the skill run overnight autonomously? | All categories |
| How will Claude verify correct execution? | Verification |
Decision: Script vs No Script
| Create Script When | Skip Script When |
|---|---|
| Operation is deterministic | Requires human judgment |
| Output can be validated | One-time setup |
| Will be reused across invocations | Simple text output |
| Enables autonomous operation | No verification needed |
| External tool integration | Pure Claude reasoning |
The specification captures all analysis insights in XML format:
<skill_specification>
<metadata>
<name>skill-name</name>
<analysis_iterations>N</analysis_iterations>
<timelessness_score>X/10</timelessness_score>
</metadata>
<context>
<problem_statement>What + Why + Who</problem_statement>
<existing_landscape>Related skills, distinctiveness</existing_landscape>
</context>
<requirements>
<explicit>What user asked for</explicit>
<implicit>Expected but unstated</implicit>
<discovered>Found through analysis</discovered>
</requirements>
<architecture>
<pattern>Selected pattern with WHY</pattern>
<phases>Ordered phases with verification</phases>
<decision_points>Branches and defaults</decision_points>
</architecture>
<scripts>
<decision_summary>needs_scripts + rationale</decision_summary>
<script_inventory>name, category, purpose, patterns</script_inventory>
<agentic_capabilities>autonomous, self-verify, recovery</agentic_capabilities>
</scripts>
<evolution_analysis>
<timelessness_score>X/10</timelessness_score>
<extension_points>Where skill can grow</extension_points>
<obsolescence_triggers>What would break it</obsolescence_triggers>
</evolution_analysis>
<anti_patterns>
<pattern>What to avoid + WHY + alternative</pattern>
</anti_patterns>
<success_criteria>
<criterion>Measurable + verification method</criterion>
</success_criteria>
</skill_specification>
See: references/specification-template.md
Before proceeding to Phase 3:
Context: Fresh, clean (no analysis artifacts polluting) Standard: Zero errors—every section verified before proceeding
1. Create directory structure
mkdir -p ~/.claude/skills/{skill-name}/references
mkdir -p ~/.claude/skills/{skill-name}/assets/templates
mkdir -p ~/.claude/skills/{skill-name}/scripts # if scripts needed
2. Write SKILL.md
• Frontmatter (YAML - allowed properties only)
• Title and brief intro
• Quick Start section
• Triggers (3-5 varied phrases)
• Quick Reference table
• How It Works overview
• Commands
• Scripts section (if applicable)
• Validation section
• Anti-Patterns
• Verification criteria
• Deep Dive sections (in <details> tags)
3. Generate reference documents (if needed)
• Deep documentation for complex topics
• Templates for generated artifacts
• Checklists for validation
4. Create assets (if needed)
• Templates for skill outputs
5. Create scripts (if needed)
• Use script-template.py as base
• Include Result dataclass pattern
• Add self-verification
• Document exit codes
• Test before finalizing
| Check | Requirement |
|---|---|
| Frontmatter | Only allowed properties (name, description, license, allowed-tools, metadata) |
| Name | Hyphen-case, ≤64 chars |
| Description | ≤1024 chars, no angle brackets |
| Triggers | 3-5 distinct, natural language |
| Phases | 1-3 max, not over-engineered |
| Verification | Concrete, measurable |
| Tables over prose | Structured information in tables |
| No placeholder text | Every section fully written |
| Scripts (if present) | Shebang, docstring, argparse, exit codes, Result pattern |
| Script docs | Scripts section in SKILL.md with usage examples |
Panel: 3-4 Opus agents with distinct evaluative lenses Requirement: Unanimous approval (all agents) Fallback: Return to Phase 1 with feedback (max 5 iterations)
| Agent | Focus | Key Criteria | When Active |
|---|---|---|---|
| Design/Architecture | Structure, patterns, correctness | Pattern appropriate, phases logical, no circular deps | Always |
| Audience/Usability | Clarity, discoverability, completeness | Triggers natural, steps unambiguous, no assumed knowledge | Always |
| Evolution/Timelessness | Future-proofing, extension, ecosystem | Score ≥7, extension points clear, ecosystem fit | Always |
| Script/Automation | Agentic capability, verification, quality | Scripts follow patterns, self-verify, documented | When scripts present |
The Script Agent is activated when the skill includes a scripts/ directory. Focus areas:
| Criterion | Checks |
|---|---|
| Pattern Compliance | Result dataclass, argparse, exit codes |
| Self-Verification | Scripts can verify their own output |
| Error Handling | Graceful failures, actionable messages |
| Documentation | Usage examples in SKILL.md |
| Agentic Capability | Scripts complete cleanly without interactive prompts during scoped, user-approved invocations |
Script Agent Scoring:
| Score | Meaning |
|---|---|
| 8-10 | Fully agentic, self-verifying, production-ready |
| 6-7 | Functional but missing some agentic capabilities |
| <6 | Requires revision - insufficient automation quality |
Each agent produces:
## [Agent] Review
### Verdict: APPROVED / CHANGES_REQUIRED
### Scores
| Criterion | Score (1-10) | Notes |
|-----------|--------------|-------|
### Strengths
1. [Specific with evidence]
### Issues (if CHANGES_REQUIRED)
| Issue | Severity | Required Change |
|-------|----------|-----------------|
### Recommendations
1. [Even if approved]
IF all agents APPROVED (3/3 or 4/4):
→ Finalize skill
→ Run validate-skill.py
→ Update registry
→ Complete
ELSE:
→ Collect all issues (including script issues)
→ Return to Phase 1 with issues as input
→ Re-apply targeted questioning
→ Regenerate skill and scripts
→ Re-submit to panel
IF 5 iterations without consensus:
→ Flag for human review
→ Present all agent perspectives
→ User makes final decision
Every skill is evaluated through the evolution lens:
| Timeframe | Key Question |
|---|---|
| 6 months | How will usage patterns evolve? |
| 1 year | What ecosystem changes are likely? |
| 2 years | What new capabilities might obsolete this? |
| 5 years | Is the core problem still relevant? |
| Score | Description | Verdict |
|---|---|---|
| 1-3 | Transient, will be obsolete in months | Reject |
| 4-6 | Moderate, depends on current tooling | Revise |
| 7-8 | Solid, principle-based, extensible | Approve |
| 9-10 | Timeless, addresses fundamental problem | Exemplary |
Requirement: All skills must score ≥7.
| Do | Don't |
|---|---|
| Design around principles | Hardcode implementations |
| Document the WHY | Only document the WHAT |
| Include extension points | Create closed systems |
| Abstract volatile dependencies | Direct coupling |
| Version-agnostic patterns | Pin specific versions |
Select based on task complexity:
| Pattern | Use When | Structure |
|---|---|---|
| Single-Phase | Simple linear tasks | Steps 1-2-3 |
| Checklist | Quality/compliance audits | ☐ Item verification |
| Generator | Creating artifacts | Input → Transform → Output |
| Multi-Phase | Complex ordered workflows | Phase 1 → Phase 2 → Phase 3 |
| Multi-Agent Parallel | Independent subtasks | Launch agents concurrently |
| Multi-Agent Sequential | Dependent subtasks | Agent 1 → Agent 2 → Agent 3 |
| Orchestrator | Coordinating multiple skills | Meta-skill chains |
Is it a simple procedure?
├── Yes → Single-Phase
└── No → Does it produce artifacts?
├── Yes → Generator
└── No → Does it verify/audit?
├── Yes → Checklist
└── No → Are subtasks independent?
├── Yes → Multi-Agent Parallel
└── No → Multi-Agent Sequential or Multi-Phase
SKILLCREATOR_CONFIG:
mode: autonomous
depth: maximum # always
core_lens: evolution_timelessness
analysis:
min_lens_depth: 5
max_questioning_rounds: 7
termination_empty_rounds: 3
synthesis:
panel_size: 3
require_unanimous: true
max_iterations: 5
escalate_to_human: true
evolution:
min_timelessness_score: 7
min_extension_points: 2
require_temporal_projection: true
model:
primary: claude-opus-4-6
subagents: claude-opus-4-6
| Skill | Relationship |
|---|---|
| skill-composer | Can orchestrate created skills |
| claude-authoring-guide | Deeper patterns reference |
| codereview | Pattern for multi-agent panels |
| maker-framework | Zero error standard source |
references/multi-lens-framework.mdassets/templates/references/script-patterns-catalog.mdmodel, context, agent, hooks, user-invocablescripts/_constants.py for shared validation constantsscripts/quick_validate.py with extended property validationscripts/validate-skill.py with hooks and agent validationscripts/discover_skills.py to extract version from metadata.versionreferences/script-integration-framework.mdreferences/script-patterns-catalog.mdassets/templates/script-template.py<scripts> sectionnpx claudepluginhub rjmurillo/ai-agentsAnalyzes any input to recommend existing Claude Code skills, improve them, or create new ones via triage of 250+ skills, confidence matching, and multi-agent synthesis.
Creates, modifies, improves, tests, and benchmarks Claude Code skills using category-aware design, gotchas-driven development, eval prompts, and performance analysis.
Creates, fixes, analyzes, and validates skills for AI agents. Includes scripts for structure checks, quality analysis, and character budget management.