platxa-skill-generator
Autonomous skill creator for Claude Code CLI. Uses multi-phase orchestrated workflow with Task tool subagents to research domains, design architecture, generate content, and validate quality. Creates production-ready skills following Anthropic's Agent Skills specification.
Best use case
platxa-skill-generator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Autonomous skill creator for Claude Code CLI. Uses multi-phase orchestrated workflow with Task tool subagents to research domains, design architecture, generate content, and validate quality. Creates production-ready skills following Anthropic's Agent Skills specification.
Teams using platxa-skill-generator should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/platxa-skill-generator/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How platxa-skill-generator Compares
| Feature / Agent | platxa-skill-generator | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Autonomous skill creator for Claude Code CLI. Uses multi-phase orchestrated workflow with Task tool subagents to research domains, design architecture, generate content, and validate quality. Creates production-ready skills following Anthropic's Agent Skills specification.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
SKILL.md Source
# Platxa Skill Generator
Create Claude Code skills autonomously using a multi-phase orchestrated workflow.
## Overview
This skill guides you through creating production-ready Claude Code skills by:
1. **Discovering** domain knowledge through web research and existing skill analysis
2. **Architecting** the skill structure based on type (Builder/Guide/Automation/Analyzer/Validator)
3. **Generating** SKILL.md content, scripts, and reference documentation
4. **Validating** against Anthropic's Agent Skills spec with quality scoring
The workflow uses Task tool subagents for each phase, ensuring deep expertise at every step.
## Workflow
### Phase 1: Initialize
```
User: /skill-generator
```
Ask the user for:
- Skill description (what should the skill do?)
- Target users (who will use this skill?)
### Phase 2: Discovery (Automatic)
Use Task tool with `subagent_type="Explore"` to:
1. Search web for domain best practices
2. Fetch relevant documentation
3. Analyze existing skills in `~/.claude/skills/` for patterns
4. Identify procedural knowledge (HOW) vs domain expertise (WHAT)
5. Determine what varies by project vs what's constant
**Sufficiency Check**: Evaluate if research is complete. Only ask user for clarification if gaps exist.
### Phase 3: Architecture
Based on discovery, determine:
- **Skill Type**: Builder, Guide, Automation, Analyzer, or Validator
- **Structure**: Which directories needed (scripts/, references/, assets/)
- **Token Budget**: SKILL.md < 500 lines, metadata ~100 tokens
Generate architecture blueprint JSON:
```json
{
"skill_type": "Builder",
"directories": ["scripts", "references"],
"skill_md_sections": ["Overview", "Workflow", "Examples", "Output Checklist"],
"scripts": [{"name": "validate.sh", "purpose": "Validate output"}],
"references": [{"name": "best-practices.md", "purpose": "Domain expertise"}]
}
```
### Phase 4: Generation
Create all skill files:
1. **SKILL.md** with valid YAML frontmatter
2. **scripts/** with executable helpers
3. **references/** with domain documentation
Use templates from `references/templates/` based on skill type.
### Phase 5: Validation
Run quality checks:
- [ ] SKILL.md exists with valid frontmatter
- [ ] Name is hyphen-case, ≤64 characters
- [ ] Description is ≤1024 characters
- [ ] Token budget within limits
- [ ] Scripts are executable and secure
- [ ] References provide real domain expertise
**Quality Score**: Must be ≥7.0/10 to pass.
### Phase 6: Installation
Ask user for installation location:
- **User skill**: `~/.claude/skills/{skill-name}/`
- **Project skill**: `.claude/skills/{skill-name}/`
Copy files and verify installation.
## Examples
### Example 1: Creating a Code Documenter Skill
```
User: /skill-generator
Assistant: What skill would you like to create?
User: A skill that generates documentation for Python code
Assistant: [Runs Discovery subagent to research Python docstring standards...]
Assistant: [Creates architecture for "Automation" type skill...]
Assistant: [Generates py-documenter skill with SKILL.md, scripts/generate-docs.sh]
Assistant: Quality score: 8.2/10. Install to ~/.claude/skills/py-documenter? (y/n)
```
### Example 2: Creating a Security Analyzer Skill
```
User: /skill-generator
Assistant: What skill would you like to create?
User: A skill that scans code for security vulnerabilities
Assistant: [Discovers OWASP Top 10, SAST patterns, CVE databases...]
Assistant: [Creates "Analyzer" type skill with references/owasp-checklist.md]
Assistant: Quality score: 7.8/10. Ready to install.
```
## Output Checklist
When generating a skill, verify:
- [ ] SKILL.md has valid YAML frontmatter
- [ ] Name follows hyphen-case (e.g., `my-skill-name`)
- [ ] Name is ≤64 characters
- [ ] Description is ≤1024 characters
- [ ] `allowed-tools` lists only tools the skill needs
- [ ] Workflow section has clear steps
- [ ] Examples show realistic usage
- [ ] References contain actual domain expertise (not placeholders)
- [ ] Scripts are executable and tested
- [ ] Quality score ≥7.0/10
## Skill Types Reference
| Type | Purpose | Key Sections |
|------|---------|--------------|
| Builder | Create new things | Workflow, Templates, Output Checklist |
| Guide | Teach/explain | Steps, Examples, Best Practices |
| Automation | Automate tasks | Triggers, Scripts, Verification |
| Analyzer | Inspect/audit | Checklist, Metrics, Reports |
| Validator | Verify quality | Rules, Thresholds, Pass/Fail Criteria |Related Skills
viral-generator-builder
Expert in building shareable generator tools that go viral - name generators, quiz makers, avatar creators, personality tests, and calculator tools. Covers the psychology of sharing, viral mechanic...
terragrunt-generator
Comprehensive toolkit for generating best practice Terragrunt configurations (HCL files) following current standards and conventions. Use this skill when creating new Terragrunt resources (root configs, child modules, stacks, environment setups), or building multi-environment Terragrunt projects.
steering-specs-generator
Extract tacit engineering knowledge through guided interviews and generate structured steerings. Use when user mentions "steerings", "tacit knowledge", "conventions", "engineering practices", "interview", or wants to document team/project knowledge. Also activates when user asks for "steerings for X", "document X conventions", "continue steerings", "resume interview", or wants to extract knowledge about a specific topic. Supports reviewing and transforming existing steerings to standard format. Auto-detects existing sessions and offers to continue incomplete ones.
spider-generator
Generate Scrapy spiders with best practices when creating new spiders, crawlers, or implementing scraping patterns. Automatically scaffolds spiders based on target website type and requirements.
spec-generator
Interview user in-depth to create a detailed spec
schematic-generator
Generates schematics, netlists, or HDL from requirements for hardware/PCB projects. Validates physical constraints. Use when building PCB, HDL, or hardware designs from approved requirements.
repo-docs-generator
Generate comprehensive AGENTS.md, README.md, and CLAUDE.md documentation for any repository. Deep-dives into codebase structure, identifies technologies, creates ASCII architecture diagrams, and respects existing documentation content.
promql-generator
Comprehensive toolkit for generating best practice PromQL (Prometheus Query Language) queries following current standards and conventions. Use this skill when creating new PromQL queries, implementing monitoring and alerting rules, or building observability dashboards.
PRD Generator for TaskMaster
Smart PRD generator with TaskMaster integration. Detects existing PRDs and offers execute/update/replace options. Generates comprehensive technical PRDs optimized for task breakdown, validates with 13 automated checks, and optionally executes tasks autonomously with datetime tracking and rollback support. Use when user requests "PRD", "product requirements", or mentions task-driven development. Default: PRD generation + handoff to TaskMaster. Optional: autonomous execution with 4 modes.
plan-generator
Creates structured plans from requirements. Generates comprehensive plans with steps, dependencies, risks, and success criteria. Coordinates with specialist agents for planning input and validates plan completeness. Uses template-renderer for formatted output.
open-eth-terminal-action-generator
An agent that can help users with creating new actions to check into the codebase. It should generate action code and link it to the application after querying the user for information about the goal of the action.
Newt Blueprint Generator
Generate and validate Pangolin Newt blueprint configurations in YAML or Docker Labels format. Use when creating Pangolin resource configurations, proxy resources, client resources, authentication settings, or Docker Compose blueprints.