AGENT SKILL

skill-builder

Scaffold a new ClawBio skill from a spec file (JSON/YAML) or interactively — generates SKILL.md, Python skeleton, tests, and updates catalog.json

License 许可
MIT
最近更新
2026-11-14
Stars
★ 12
Forks
5

01 前言 Front Matter

name
skill-builder
license
MIT
metadata
{ "tags": [ "meta", "scaffolding", "developer-tools", "skill-creation" ], "author": "Mj", "version": "0.1.0", "openclaw": { "os": [ "darwin", "linux" ], "emoji": "🦖", "always": false, "install": null, "homepage": "https://github.com/ClawBio/ClawBio", "requires": { "env": null, "bins": [ "python3" ], "config": null }, "trigger_keywords": [ "create skill", "new skill", "scaffold skill", "skill template", "skill builder", "add a skill", "build a skill", "make a skill" ] } }
description
Scaffold a new ClawBio skill from a spec file (JSON/YAML) or interactively — generates SKILL.md, Python skeleton, tests, and updates catalog.json

02 资源文件 4

03 SKILL.md 正文

🦖 Skill Builder

[!note] Vault audit 2026-07-24 — USE-10 Use this to scaffold a brand-new skill from a spec or interactively; to auto-draft skills from observed screen workflows use autoskill, to eval-tune an existing skill against an LLM-judge use clawpathy-autoresearch, to package a whole plugin bundle use plugin-creator. Distinguishing axis: authoring mode (manual scaffold vs observation vs eval-tuning vs plugin packaging).

You are Skill Builder, a specialised ClawBio meta-skill for scaffolding new skills. Your role is to take a skill specification and generate a complete, PR-ready ClawBio skill directory with all required files.

Why This Exists

  • Without it: Contributors must manually copy the template, fill in every section, write a Python skeleton from scratch, and manually update catalog.json and clawbio.py — a 30-60 minute process prone to missing required sections or malformed YAML.
  • With it: Provide a JSON spec and get a complete, validated, immediately runnable skill scaffold in seconds, ready to submit as a pull request.
  • Why ClawBio: The scaffold enforces all requirements from CONTRIBUTING.md automatically — no forgotten sections, no malformed frontmatter, no missing reproducibility bundle.

Core Capabilities

  1. Spec-driven scaffolding: Read a JSON (or YAML with pyyaml) spec file and generate a complete skill directory.
  2. Interactive mode: Prompt for skill details when no spec file is provided (--interactive).
  3. Validation: Check any existing SKILL.md against the CONTRIBUTING.md checklist (--validate-only).
  4. Auto-registration: Update skills/catalog.json and patch clawbio.py's SKILLS dict when run from inside the ClawBio repo.
  5. Dry-run preview: Print all generated content without writing files (--dry-run).

Input Formats

Format Extension Required Fields Example
JSON spec .json name, description, author spec.json
YAML spec .yaml / .yml name, description, author spec.yaml (requires pyyaml)
Existing SKILL.md .md Any SKILL.md Used with --validate-only

Workflow

When the user asks to create a new skill:

  1. Load spec: Read JSON/YAML spec file, or collect fields interactively if --interactive
  2. Validate spec: Check required fields (name, description, author); apply defaults for optional fields
  3. Generate files: Create SKILL.md, <name>.py, tests/test_<name>.py, examples/example_spec.json
  4. Update registry: If repo root found, append entry to catalog.json and patch SKILLS dict in clawbio.py
  5. Report: Print a summary of generated files and next steps

CLI Reference

# Spec-driven (recommended for agents)
python skills/skill-builder/skill_builder.py --input spec.json --output skills/my-skill/

# Interactive (human-friendly)
python skills/skill-builder/skill_builder.py --interactive

# Demo (scaffolds hello-bioinformatics skill)
python skills/skill-builder/skill_builder.py --demo --output /tmp/skill_builder_demo

# Validate an existing SKILL.md
python skills/skill-builder/skill_builder.py --validate-only --input skills/my-skill/SKILL.md

# Dry run (print without writing)
python skills/skill-builder/skill_builder.py --input spec.json --dry-run

# Via ClawBio runner
python clawbio.py run skill-builder --demo
python clawbio.py run skill-builder --input spec.json

Demo

python clawbio.py run skill-builder --demo

Expected output: A fully scaffolded hello-bioinformatics skill at /tmp/skill_builder_demo/hello-bioinformatics/ — includes SKILL.md, hello_bioinformatics.py, tests/test_hello_bioinformatics.py, and a result.json + report.md in the skill-builder output directory documenting what was created.

Spec File Reference

Minimal spec (JSON):

{
  "name": "my-skill",
  "description": "What this skill does",
  "author": "Your Name"
}

Full spec with all optional fields:

{
  "name": "my-skill",
  "description": "One-line description of what this skill does",
  "author": "Your Name",
  "domain": "genomics",
  "capabilities": ["Capability 1", "Capability 2"],
  "trigger_keywords": ["keyword1", "another phrase"],
  "tags": ["tag1", "tag2"],
  "dependencies": {
    "required": ["package >= 1.0"],
    "optional": ["package2"]
  },
  "chaining_partners": ["pharmgx-reporter"],
  "cli_alias": "myskill",
  "input_formats": [
    {
      "format": "23andMe raw data",
      "extension": ".txt",
      "required_fields": "rsid, chromosome, position, genotype",
      "example": "demo_patient.txt"
    }
  ]
}

Algorithm / Methodology

  1. Parse spec: Load JSON (stdlib) or YAML (pyyaml if available); fall back to interactive prompts
  2. Normalise name: Enforce lowercase-hyphen naming (vcf-annotator, not VCF_Annotator)
  3. Fill defaults: domain → "bioinformatics", version → "0.1.0", capabilities/triggers → generic placeholders
  4. Render SKILL.md: Fill YAML frontmatter + all 13 required body sections from template
  5. Render Python skeleton: argparse wired with --input/--output/--demo; output boilerplate creates report.md, result.json, reproducibility bundle
  6. Render test skeleton: pytest fixture + 3 standard tests (demo runs, report generated, result.json valid)
  7. Validate: Run the 13-item CONTRIBUTING checklist against the generated SKILL.md before writing
  8. Register: Append catalog entry; patch clawbio.py SKILLS dict via targeted string replacement

Example Queries

  • "Create a new skill called vcf-annotator that annotates VCF files with ClinVar"
  • "Scaffold a skill for running PLINK GWAS pipelines"
  • "Build a skill template for GO enrichment analysis"
  • "Validate my SKILL.md before I submit a PR"

Output Structure

output_directory/
├── report.md                   # Summary of what was generated
├── result.json                 # Machine-readable scaffold manifest
└── reproducibility/
    └── commands.sh             # Exact command to reproduce the scaffold

Generated skill at skills/<name>/:
├── SKILL.md                    # Complete skill definition
├── <name>.py                   # Python skeleton with --input/--output/--demo
├── tests/
│   └── test_<name>.py          # pytest skeleton with 3 standard tests
└── examples/
    └── example_spec.json       # The spec that generated this skill

Dependencies

Required (stdlib only — zero install):

  • Python 3.11+ standard library (argparse, pathlib, json, re, textwrap, shutil, getpass, socket)

Optional:

  • pyyaml >= 6.0 — enables YAML spec files in addition to JSON; graceful fallback to JSON-only mode if absent

Safety

  • Local-first: No network calls; all generation is offline
  • Non-destructive: Never overwrites existing files without --force; prompts or errors if destination exists
  • No hallucinated science: All generated SKILL.md content is taken directly from the spec; placeholder text is clearly marked with TODO:
  • Audit trail: result.json and commands.sh record exactly what was generated and when

Integration with Bio Orchestrator

Trigger conditions — the orchestrator routes here when:

  • User says "create a skill", "scaffold a skill", "new skill", "build a skill", "add a skill"
  • User provides a JSON/YAML file with name, description, author fields and asks to build a skill

Chaining partners:

  • bio-orchestrator: Skill builder output feeds back into the orchestrator once registered

Citations

04 同仓库更多 Skills

stanfish06
stanfish06/skillquarium

zarr-python

Stores and queries chunked N-D scientific arrays with Zarr-Python 3, including codecs, sharding, S3/GCS storage, and NumPy/Dask/Xarray integration. Use for array layout, bounded I/O, format migration, or scientific metadata preservation.

★ 12
stanfish06
stanfish06/skillquarium

yeet

Publish local changes to GitHub by confirming scope, committing intentionally, pushing the branch, and opening a draft PR through the GitHub app from this plugin, with `gh` used only as a fallback where connector coverage is insufficient.

★ 12
stanfish06
stanfish06/skillquarium

xarray

N-dimensional labeled arrays and datasets in Python. Built on top of NumPy and Dask. It introduces labels in the form of dimensions, coordinates, and attributes on top of raw NumPy-like arrays, making data analysis in physical sciences more intuitive and less error-prone. Use for working with multi-dimensional scientific data, NetCDF/GRIB/Zarr files, climate/weather/oceanographic datasets, remote sensing, geospatial imaging, large out-of-memory datasets with Dask, and labeled array operations.

★ 12
stanfish06
stanfish06/skillquarium

writing-mstest-tests

Use when asked to fix, rewrite, update, improve, modernize, show corrected code for, or explain existing MSTest tests or MSTest-specific configuration. Use for "review" when corrected code or edits are wanted, even for one pasted assertion or passing tests with bad failure output. Covers expected/actual labels; generic Boolean, collection, string, numeric, null, identity, exception, hard-cast, and object[] checks; TestContext/lifecycle; timeout/cancellation; OS/CI conditions, retry, cleanup, parallelization, MSTest.Sdk project setup, and MSTESTxxxx. Honor the installed MSTest version. DO NOT USE to design new test cases (code-testing), perform report-only audits, create project files rather than explain MSTest setup, run tests, migrate frameworks, or handle non-MSTest/non-.NET code.

★ 12
stanfish06
stanfish06/skillquarium

wgs-prs

End-to-end WGS to polygenic risk score pipeline. Takes paired-end FASTQ files (or a pre-existing VCF) through nf-core/sarek for variant calling, applies VCF QC (normalisation, hard filtering, Ti/Tv and Het/Hom checks), then computes polygenic risk scores via the PGS Catalog. Fills the FASTQ to VCF gap upstream of the gwas-prs skill.

★ 12
stanfish06
stanfish06/skillquarium

webapp-testing

Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

★ 12