---

name: skillcreator-codex description: "Codex-native skill creator. Self-contained 4-phase methodology for creating production-ready Claude Code skills. Adapted from SkillCreator v3.2 for Codex agents with embedded methodology and simulated synthesis panel." license: MIT metadata: version: 1.0.0 based_on: skillcreator-v3.2 upstream: tripleyak/skill-creator-and-improver@3dc5ed4 domains: [meta-skill, codex, skill-creation] type: orchestrator inputs: [user-goal, constraints, context] outputs: [SKILL.md, references/, scripts/]

SkillCreator for Codex

Create production-ready Claude Code skills using a systematic 4-phase methodology.

This skill is self-contained. All methodology is embedded below - no external file reads required.

---

Quick Start

Include this document in your Codex prompt, then add your request:

Copy[This SKILL.md content]

---

Create a skill for: <your goal>

Constraints:
- <constraint 1>
- <constraint 2>

Context:
- Repo: <repo path>
- Related skills: <existing skills>

---

Output Location

All generated skills MUST go to the staging area:

Copytools/skills/generated/<skill_name>/

Structure:

Copytools/skills/generated/<skill_name>/
├── SKILL.md                    # Required - main entry point
├── SKILL_SPEC.md               # Recommended - specification document
├── references/                 # Optional - deep documentation
│   └── *.md
└── scripts/                    # Optional - automation scripts
    └── *.py

DO NOT output directly to .claude/skills/ - always use staging.

---

The 4-Phase Process

CopyYour Request
    │
    ▼
┌─────────────────────────────────────────────────────┐
│ PHASE 1: DEEP ANALYSIS                              │
│ • Expand requirements (explicit, implicit, unknown) │
│ • Apply 11 thinking lenses                          │
│ • Regression questioning until exhausted            │
│ • Identify automation opportunities                 │
├─────────────────────────────────────────────────────┤
│ PHASE 2: SPECIFICATION                              │
│ • Document all decisions with rationale (WHY)       │
│ • Score evolution/timelessness (must be ≥7/10)      │
│ • Define success criteria                           │
├─────────────────────────────────────────────────────┤
│ PHASE 3: GENERATION                                 │
│ • Write SKILL.md with proper frontmatter            │
│ • Create references/ if needed                      │
│ • Create scripts/ if agentic                        │
├─────────────────────────────────────────────────────┤
│ PHASE 4: SYNTHESIS REVIEW                           │
│ • Self-review from 3 perspectives                   │
│ • All perspectives must approve                     │
│ • If issues found → loop back to Phase 1            │
└─────────────────────────────────────────────────────┘
    │
    ▼
Production-Ready Skill in tools/skills/generated/

---

PHASE 1: Deep Analysis

1A: Input Expansion

Transform the goal into comprehensive requirements:

1B: 11 Thinking Lenses

Apply ALL of these lenses to the problem:

Requirement: Scan all 11, apply at least 5 in depth.

1C: Regression Questioning

Ask these questions in rounds until 3 consecutive rounds yield no new insights:

Round N:

1. What am I missing?
2. What would a domain expert add?
3. What would make this fail?
4. What will this look like in 2 years?
5. What's the weakest part of this design?
6. Which thinking lens haven't I applied?

Termination: Stop when 3 consecutive rounds produce no new insights.

1D: Automation Analysis

For each operation the skill will perform:

---

PHASE 2: Specification

Document your analysis in this structure:

Copy# SKILL_SPEC.md

## Metadata
- **Name:** skill-name (hyphen-case)
- **Timelessness Score:** X/10 (must be ≥7)
- **Analysis Iterations:** N rounds

## Problem Statement
[What + Why + Who]

## Requirements

### Explicit
- [What user asked for]

### Implicit
- [Expected but unstated]

### Discovered
- [Found through analysis]

## Architecture
- **Pattern:** [Single-Phase | Checklist | Generator | Multi-Phase]
- **Phases:** [Ordered steps with verification]
- **Decision Points:** [Branches and defaults]

## Scripts (if applicable)
- **Needs Scripts:** Yes/No
- **Script Inventory:** [name, purpose, patterns]

## Evolution Analysis
- **Timelessness Score:** X/10
- **Justification:** [Why this score]
- **Extension Points:** [Where skill can grow]
- **Obsolescence Triggers:** [What would break it]

## Anti-Patterns
| Avoid | Why | Instead |
|-------|-----|---------|

## Success Criteria
- [ ] [Measurable criterion 1]
- [ ] [Measurable criterion 2]

Timelessness Scoring Guide

Requirement: Score must be ≥7 to proceed.

---

PHASE 3: Generation

3A: Create Directory Structure

Copymkdir -p tools/skills/generated/<skill_name>/references
mkdir -p tools/skills/generated/<skill_name>/scripts  # if needed

3B: Write SKILL.md

Required frontmatter properties:

Copy---
name: skill-name          # Required: hyphen-case, max 64 chars
description: "..."        # Required: max 1024 chars, no < or >
license: MIT              # Optional
metadata:                 # Optional
  version: 1.0.0
  domains: [...]
---

Required sections:

1. Title - Clear name
2. Quick Start - Immediate usage example
3. Triggers - 3-5 varied invocation phrases
4. Quick Reference - Table of inputs/outputs
5. How It Works - Process overview
6. Commands - Available commands
7. Validation - How to verify success
8. Anti-Patterns - What to avoid

3C: Create Scripts (if applicable)

Scripts must follow this pattern:

Copy#!/usr/bin/env python3
"""
Script description.

Usage:
    python script_name.py <args>

Exit Codes:
    0  - Success
    1  - General failure
    10 - Validation failure
    11 - Verification failure
"""

import argparse
import sys
from dataclasses import dataclass
from typing import Optional

@dataclass
class Result:
    success: bool
    message: str
    data: Optional[dict] = None

def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    # Add arguments
    args = parser.parse_args()

    # Implementation
    result = do_work(args)

    if result.success:
        print(f"SUCCESS: {result.message}")
        return 0
    else:
        print(f"FAILURE: {result.message}", file=sys.stderr)
        return 1

if __name__ == "__main__":
    sys.exit(main())

---

PHASE 4: Synthesis Review

Since Codex cannot spawn subagents, perform self-review from these 3 perspectives:

Perspective 1: Design/Architecture Agent

Score (1-10): ___ Verdict: APPROVED / CHANGES_REQUIRED

Perspective 2: Usability Agent

Score (1-10): ___ Verdict: APPROVED / CHANGES_REQUIRED

Perspective 3: Evolution Agent

Score (1-10): ___ Verdict: APPROVED / CHANGES_REQUIRED

Consensus

CopyIF all 3 perspectives APPROVED:
    → Finalize skill
    → Write to tools/skills/generated/<skill_name>/
    → Report completion

ELSE:
    → List all issues
    → Return to Phase 1 with issues as input
    → Re-analyze and regenerate
    → Re-review (max 3 iterations)

---

Validation Checklist

Before declaring complete:

• SKILL.md exists with valid YAML frontmatter
• Name is hyphen-case, ≤64 chars
• Description ≤1024 chars, no < or >
• 3-5 trigger phrases defined
• Timelessness score ≥7 documented
• All 3 synthesis perspectives approved
• Output is in tools/skills/generated/ (not .claude/skills/)
• SKILL_SPEC.md documents the analysis

---

Anti-Patterns (DO NOT DO)

---

Failure Handling

If you cannot complete a step:

1. STOP immediately - do not proceed
2. Report exactly what is blocking:
   • Which phase/step
   • What information is missing
   • What error occurred
3. Do not improvise a workaround
4. Ask for clarification before continuing

---

Architecture Patterns

Select based on task complexity:

Selection Decision Tree

CopyIs it a simple procedure?
├── Yes → Single-Phase
└── No → Does it produce artifacts?
    ├── Yes → Generator
    └── No → Does it verify/audit?
        ├── Yes → Checklist
        └── No → Multi-Phase

---

Example Output Structure

For a skill named api-debugger:

Copytools/skills/generated/api-debugger/
├── SKILL.md
│   ---
│   name: api-debugger
│   description: "Debug API response times and identify bottlenecks."
│   license: MIT
│   metadata:
│     version: 1.0.0
│     domains: [api, debugging, performance]
│   ---
│   # API Debugger
│   [Content...]
│
├── SKILL_SPEC.md
│   # Specification
│   - Timelessness: 8/10
│   - Analysis rounds: 4
│   [Analysis documentation...]
│
├── references/
│   └── patterns.md
│
└── scripts/
    └── analyze_timing.py

---

After Generation

Once the skill is in tools/skills/generated/:

1. Validate (if validation script available):

   Copypython .claude/skills/skillcreator/scripts/quick_validate.py tools/skills/generated/<skill_name>
   

2. Review the generated files manually

3. Promote to active skills (after review):

   Copycp -r tools/skills/generated/<skill_name> .claude/skills/<skill_name>
   

---

Reference

• Based on: SkillCreator v3.2
• Upstream: tripleyak/skill-creator-and-improver @ 3dc5ed4
• Claude Code version: .claude/skills/skillcreator/
• This adaptation: Optimized for Codex with embedded methodology