acrid-skill-creator（辛辣的技能创建器）

SKILL: skill-creator

Description

The foundational meta-skill that architects and generates production-grade agent skills from natural language. This is the factory floor — every skill in the Acrid ecosystem is born here. It doesn't just scaffold files; it thinks through design, enforces quality gates, generates battle-tested logic, and outputs skills that work on first run.

Usage

Invoke this skill when:

• You need to create a new capability, tool integration, or automation
• You're converting a manual workflow into a repeatable skill
• You want to prototype a skill idea rapidly with full documentation
• You need to refactor or rebuild an existing skill from scratch

Trigger phrases: "Create a skill...", "Build me a skill...", "I need a skill that...", "Scaffold a new skill for..."

Inputs

Steps

Phase 1: Intelligence Gathering

1. Parse the request — Extract:

- Core purpose (single sentence, verb-first: "Fetches...", "Monitors...", "Generates...") - Required external APIs or services - Required tools (Bash, WebFetch, WebSearch, Read, Write, Grep, Glob, etc.) - Input parameters with types and validation rules - Expected output format (JSON, markdown, plain text, file) - Error scenarios (API down, bad input, rate limits, auth failure, empty results) - Edge cases specific to the domain

1. Determine complexity tier:

- Simple: Single tool, no external APIs, <20 lines of logic (e.g., file formatter) - Standard: 1-2 tools, may call external APIs, needs error handling (e.g., stock checker) - Advanced: Multiple tools, chained API calls, stateful logic, helper scripts required (e.g., deploy pipeline)

1. Identify the execution model:

- Direct: Skill logic runs entirely within SKILL.md steps (preferred for simple/standard) - Scripted: Complex logic lives in src/ scripts, SKILL.md orchestrates (required for advanced) - Hybrid: SKILL.md handles orchestration, delegates specific computations to scripts

Phase 2: Architecture

1. Design the skill contract:

- Define exact input schema with types, defaults, and validation - Define exact output schema — what does success look like? - Define error responses — what does each failure mode return? - Map the dependency chain (what calls what, in what order)

1. Scaffold the directory:

For simple skills:

   skills/<name>/
     SKILL.md
     README.md

For standard skills:

   skills/<name>/
     SKILL.md
     README.md
     src/           # Only if computation is complex

For advanced skills:

   skills/<name>/
     SKILL.md
     README.md
     src/
       main.py|js   # Core logic
       utils.py|js  # Shared helpers (only if genuinely needed)
     config/
       defaults.json

Phase 3: Generation

1. Generate SKILL.md — The skill definition must include ALL of these sections:

   # SKILL: <name>

   ## Description
   <Single paragraph. First sentence is the hook — what it does in <15 words.
   Second sentence adds context. Third sentence covers key differentiator.>

   ## Usage
   <When to invoke. Include 2-3 specific trigger phrases.>

   ## Inputs
   <Table format with: Parameter | Required | Type | Default | Description>
   <Include validation rules inline>

   ## Outputs
   <What the skill returns on success. Include format specification.>

   ## Steps
   <Numbered, imperative steps. Each step must be:
   - Actionable (starts with a verb)
   - Atomic (does one thing)
   - Error-aware (includes failure handling where relevant)
   - Tool-specific (names the exact tool to use when applicable)>

   ## Error Handling
   <Explicit failure modes and recovery actions:
   - What to do when an API is unreachable
   - What to do with malformed input
   - What to do when results are empty
   - Retry logic if applicable>

SKILL.md generation rules: - Steps MUST be deterministic — no ambiguity in what the agent does - Every external call MUST have a failure path - Steps should reference specific tools by name (WebFetch, Bash, Grep, etc.) - Include concrete examples of expected input/output in the steps where helpful - Never use vague instructions like "process the data" — specify HOW - If a step involves parsing, specify the exact format and extraction method - Rate limiting: if the skill calls external APIs, include a note about respecting rate limits

1. Generate README.md:

   # <Skill Name (Title Case)>

   <One-line description>

   ## Quick Start
   <Minimal trigger example>

   ## Parameters
   <Full parameter docs with examples>

   ## Example Usage
   <2-3 real-world invocation examples with expected outputs>

   ## Setup
   <Environment variables, API keys, dependencies — only if needed>

   ## How It Works
   <Brief technical explanation of the skill's approach>

   ## Limitations
   <Honest about what it can't do>

1. Generate helper scripts (if complexity requires):

Python scripts must: - Use argparse for CLI arguments - Output JSON to stdout (parseable by the agent) - Include a if __name__ == "__main__" guard - Handle exceptions with meaningful error messages in JSON format: {"error": "...", "code": "..."} - Use type hints - Include a docstring

Node.js scripts must: - Parse args from process.argv or use a minimal arg parser - Output JSON to stdout - Handle errors with try/catch, output: {"error": "...", "code": "..."} - Use strict mode

Phase 4: Quality Gates

1. Run the Acrid Quality Checklist — Every generated skill must pass ALL gates:

1. Final review — Read through the complete generated skill one more time. Ask:

- Would this work if I ran it right now? - Is there anything I'd need to guess or assume? - Are the steps clear enough that a different agent could execute them? - If any answer is "no", fix it before delivering.

Phase 5: Delivery

1. Write all files to the target directory using the Write tool.

1. Report to user with:

- Skill name and location - Quick summary of what was generated - Any setup steps required (API keys, env vars) - A ready-to-use invocation example

Error Handling

Anti-Patterns — Do NOT Generate Skills That:

• Have steps like "analyze the data" without specifying HOW
• Depend on tools not available to the agent
• Require manual intervention mid-execution (unless explicitly designed as interactive)
• Have undocumented environment variables or secrets
• Contain placeholder logic ("TODO: implement this")
• Over-engineer with abstractions for single-use operations
• Include unnecessary comments or boilerplate

Examples

Input:

name: stock-checker
description: Fetches the current price of a stock by ticker symbol using a free API
requirements: Must use a free API, return price in USD

Output: See examples/stock-checker/ for the complete generated skill.