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	[object Object]

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:

[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:

tools/skills/generated/<skill_name>/

Structure:

tools/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

Your 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:

Category	Questions to Answer
Explicit	What did the user literally ask for?
Implicit	What do they expect but didn't say?
Unknown	What don't they know they need?
Context	What existing skills/patterns are related?

1B: 11 Thinking Lenses

Apply ALL of these lenses to the problem:

Lens	Core Question
First Principles	What's fundamentally needed? Strip away conventions.
Inversion	What would guarantee failure? Build anti-patterns.
Second-Order	What happens after the obvious effect?
Pre-Mortem	Assume it failed - why?
Systems Thinking	How do parts interact? Dependencies?
Devil's Advocate	Strongest counter-argument?
Constraints	What's truly fixed vs assumed?
Pareto	Which 20% delivers 80% of value?
Root Cause	Why is this needed? (5 Whys)
Comparative	How do alternatives compare?
Opportunity Cost	What are we giving up?

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:

What am I missing?
What would a domain expert add?
What would make this fail?
What will this look like in 2 years?
What's the weakest part of this design?
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:

Question	If YES →
Is this operation repeatable?	Consider generation script
Does this produce verifiable output?	Consider validation script
Does this need state across sessions?	Consider state management
Can success be verified autonomously?	Add self-verification

PHASE 2: Specification

Document your analysis in this structure:

# 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

Score	Description	Verdict
1-3	Transient, will be obsolete in months	Reject
4-6	Moderate, depends on current tooling	Revise
7-8	Solid, principle-based, extensible	Approve
9-10	Timeless, addresses fundamental problem	Exemplary

Requirement: Score must be ≥7 to proceed.

PHASE 3: Generation

3A: Create Directory Structure

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

3B: Write SKILL.md

Required frontmatter properties:

---
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:

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

3C: Create Scripts (if applicable)

Scripts must follow this pattern:

#!/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

Criterion	Check
Pattern appropriate?	Does the architecture match the problem?
Phases logical?	Are steps in correct order with clear transitions?
No circular dependencies?	Can each phase complete independently?
Error handling?	Are failure modes addressed?

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

Perspective 2: Usability Agent

Criterion	Check
Triggers natural?	Would a user think to say this?
Steps unambiguous?	Can someone follow without guessing?
No assumed knowledge?	Is everything explained?
Quick start works?	Can someone use it immediately?

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

Perspective 3: Evolution Agent

Criterion	Check
Timelessness ≥7?	Will this be useful in 2 years?
Extension points clear?	Can it grow without rewrite?
Ecosystem fit?	Does it complement existing skills?
WHY documented?	Can someone understand the reasoning?

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

Consensus

IF 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)

Avoid	Why	Instead
Skip Deep Analysis	Leads to shallow skills	Complete all 11 lenses
No specification	Can't verify decisions	Write SKILL_SPEC.md
Output to `.claude/skills/`	Bypasses review	Use staging area
Single trigger phrase	Hard to discover	3-5 varied phrases
No verification criteria	Can't confirm success	Measurable outcomes
Missing WHY	Can't evolve or debug	Document rationale
Improvise when stuck	Leads to drift	STOP and report blocker

Failure Handling

If you cannot complete a step:

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

Architecture Patterns

Select based on task complexity:

Pattern	Use When	Structure
Single-Phase	Simple linear tasks	Steps 1-2-3
Checklist	Quality/compliance audits	Item verification
Generator	Creating artifacts	Input → Transform → Output
Multi-Phase	Complex ordered workflows	Phase 1 → Phase 2 → Phase 3

Selection Decision Tree

Is 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:

tools/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/:

Validate (if validation script available):

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

Review the generated files manually

Promote to active skills (after review):

cp -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

Install Skill

SKILL.md

SkillCreator for Codex

Quick Start

Output Location

The 4-Phase Process

PHASE 1: Deep Analysis

1A: Input Expansion

1B: 11 Thinking Lenses

1C: Regression Questioning

1D: Automation Analysis

PHASE 2: Specification

Timelessness Scoring Guide

PHASE 3: Generation

3A: Create Directory Structure

3B: Write SKILL.md

3C: Create Scripts (if applicable)

PHASE 4: Synthesis Review

Perspective 1: Design/Architecture Agent

Perspective 2: Usability Agent

Perspective 3: Evolution Agent

Consensus

Validation Checklist

Anti-Patterns (DO NOT DO)

Failure Handling

Architecture Patterns

Selection Decision Tree

Example Output Structure

After Generation

Reference