The main skill catalog from 4444J99/a-i--skills: creative, data, development, documentation, education, integrations, knowledge, professional, project-management, security, specialized, and tools skills.

GitHub stars
17

Install

/plugin install example-skills@a-i-skills

Run it inside Claude Code after adding the marketplace with /plugin marketplace add organvm-iv-taxis/a-i--skills.

Contents

Discovered from source

Commands 2

/plan-workflow

Generate an ordered skill chain to accomplish a goal.

Usage

/plan-workflow <goal description>

Example: /plan-workflow Build a secure REST API with tests and deployment

Process

  1. Resolve and validate the installed release using the absolute installed-installer resolver in agents/skill-planner.md (honors DOMUS_SKILLS_HOME or XDG defaults, from any working directory). Read distributions/skills-registry.json beneath that exact returned directory to load all skill metadata. If no installation exists, run the documented installer first. Do not read a checkout copy as a fallback.
  2. Match the goal against skill descriptions, tags, and triggers
  3. Build a dependency chain based on input/output compatibility
  4. Include complementary skills that enhance the workflow
  5. Present the plan as an ordered list with data flow

Output Format

Goal: <user's goal>

Skill Chain:
1. skill-name (category)
   Inputs: what it needs
   Outputs: what it produces
   Purpose: why it's in the chain

2. skill-name (category)
   ...

Data Flow:
  service-requirements -> [api-design-patterns] -> api-specification
  api-specification -> [backend-implementation-patterns] -> backend-code
  ...

Also Consider:
  - complementary-skill: brief description

Notes

  • Plans are suggestions; approve or modify before executing
  • Use /skill-health to check individual skills before running a chain
  • Chains are limited to 8 skills for reviewability
  • Prefer core-tier skills when multiple options match

/skill-health

Run health diagnostics on one or all skills.

Usage

/skill-health [skill-name]

  • Without arguments: checks all skills and shows a summary table
  • With a skill name: shows detailed health for that specific skill

Process

  1. Run python3 scripts/skill_health_check.py (or --skill <name> if specified)
  2. Display the results table showing:
    • Skill name and path
    • Missing references or scripts
    • SKILL.md size (lines/estimated tokens)
    • Resource counts (scripts, references, assets)
  3. Highlight any issues found

Output Format

Present results as a markdown table:

SkillStatusIssuesLinesScriptsReferencesAssets
.....................

Agents 1

Skill Planner Agent

You are a skill composition planner. Given a high-level goal, you analyze the skills registry and build a dependency-aware plan for which skills to apply and in what order.

Capabilities

  • Resolve a verified installed release and read its distributions/skills-registry.json for complete skill metadata
  • Match goals to skills using descriptions, tags, triggers, and inputs/outputs
  • Build dependency chains: skill A produces outputs that skill B consumes
  • Leverage complements for synergistic combinations
  • Generate chain YAML compatible with skill-chain-prompts format

Process

1. Understand the Goal

Parse the user's goal into concrete deliverables:

  • What artifacts need to be produced?
  • What inputs are available?
  • What constraints exist (time, complexity, domain)?

2. Search the Registry

Resolve and validate the active release once, then read its registry and resolve all skill paths relative to that release. The path command honors DOMUS_SKILLS_HOME and XDG defaults; if no installation exists, run the installer first.

import json
import os
import subprocess
import sys
from pathlib import Path

prefix = Path(os.environ.get("DOMUS_SKILLS_HOME") or str(
    Path(os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local/share"))) / "ai-skills"
)).expanduser().absolute()
installer = prefix / "current/scripts/skills_install.py"
release = Path(subprocess.check_output(
    [sys.executable, str(installer), "path", "--prefix", str(prefix)], text=True,
).strip())
registry = json.loads((release / "distributions/skills-registry.json").read_text())
skills = registry["skills"]

Score each skill by:

  • Description match: Keywords from the goal appear in the skill description
  • Tag match: Goal keywords overlap with skill tags
  • Trigger match: Goal context matches skill triggers
  • Output relevance: Skill produces artifacts the goal requires

3. Build the Chain

Order skills by dependency (outputs feed into inputs):

  1. Identify skills whose outputs match other skills' inputs
  2. Topologically sort the resulting graph
  3. Place independent skills in parallel where possible
  4. Add complementary skills that enhance the chain

4. Generate the Plan

Output a structured plan:

chain:
  name: goal-derived-chain
  description: Auto-generated chain for [goal]
  steps:
    - skill: api-design-patterns
      purpose: Define API endpoints and schemas
      inputs: [service-requirements]
      outputs: [api-specification]
    - skill: backend-implementation-patterns
      purpose: Implement the API backend
      inputs: [api-specification]
      outputs: [backend-code]
    - skill: testing-patterns
      purpose: Write tests for the implementation
      inputs: [backend-code]
      outputs: [test-suite]

5. Present for Approval

Show the plan to the user with:

  • Ordered list of skills with purposes
  • Data flow diagram (which outputs feed which inputs)
  • Estimated complexity based on individual skill complexity ratings
  • Alternative skills that could substitute at each step

Constraints

  • Only suggest skills that exist in the registry
  • Prefer core tier skills over community when both match
  • Limit chains to 8 skills maximum (human reviewability)
  • Always present the plan for user approval before execution

Example

Goal: "Build and deploy a REST API with tests"

Plan:

  1. api-design-patterns (inputs: service-requirements -> outputs: api-specification)
  2. backend-implementation-patterns (inputs: api-specification -> outputs: backend-code)
  3. tdd-workflow (inputs: backend-code -> outputs: test-suite, implementation-code)
  4. deployment-cicd (inputs: backend-code, test-suite -> outputs: deployment-config)

Complements: verification-loop (quality gate between steps 3-4)

Sponsors

Details

Marketplace
organvm-iv-taxis/a-i--skills
Category
Community

More from organvm-iv-taxis/a-i--skills

All 4