Skip to main content
skill CX Codex

Manifest Generator — Claude Code skill: what it does, how to install

Manifest Generator turns a skill or MCP description into a YAML capability manifest: preconditions, effects, domains, risk. Useful when the descriptions exist but the orchestration cards do not.

MIT 131 installs ★ 39 updated 2025-12-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add daffy0208/ai-dev-standards --skill manifest-generator -a claude-code
Open on GitHub

What Manifest Generator does

The skill reads a resource's description and, when there is one, the first 100 lines of its index.js. It also pulls the matching record out of META/skill-registry.json with jq, so the model sees how the resource is already registered. Then it calls codex exec and asks for YAML that fits the capability-manifest schema: preconditions as checks (file_exists('package.json'), has_dependency('react'), env_var_set('OPENAI_API_KEY')), effects named with imperative verbs, technical domains, a compatibility block with requires, conflicts_with, composes_with and enables, plus cost, latency and risk_level.

Nothing is written before npx ajv validates the draft against SCHEMAS/capability-manifest.schema.json. The result is copied to output_path, which defaults to the skill's own directory.

The manifest is inferred, not measured. A thin SKILL.md gives thin preconditions and vague effects, and the generation step needs the codex command on the machine.

What it helps with

  • generate a manifest for a new skill without hand-writing YAML
  • regenerate a manifest after the description changes
  • catch drift between a stored manifest and the current description
  • pull preconditions and side effects out of an existing SKILL.md
  • assign cost, latency and risk level to an MCP server

Example prompts for the agent

  • Generate a capability manifest for the skill in SKILLS/rag-implementer, reading SKILL.md and writing manifest.yaml beside it.
  • Regenerate the manifest for the pinecone-mcp server and show me what changed against the current one.
  • Validate the generated manifest.yaml against SCHEMAS/capability-manifest.schema.json and fix whatever fails.

How to install Manifest Generator

1Skills CLI (Vercel)

npx skills add daffy0208/ai-dev-standards --skill manifest-generator -a claude-code

2Manually: put the files in place

~/.claude/skills/manifest-generator/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/manifest-generator/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about Manifest Generator

How do I install Manifest Generator in Claude Code?

Run npx skills add daffy0208/ai-dev-standards --skill manifest-generator -a claude-code. The skill file lands at ~/.claude/skills/manifest-generator/SKILL.md.

What does Manifest Generator do?

It takes a skill, MCP server, tool or component description and has codex exec infer a capability manifest from it: what has to exist beforehand, what the resource changes, which domains it touches, how risky it is. The YAML is checked against the schema before it is saved.

What has to be on my machine for it to run?

codex for the generation step, jq for reading META/skill-registry.json, and npx ajv with SCHEMAS/capability-manifest.schema.json for validation.

Source text

SKILL.md · MIT
---
name: Manifest Generator
description: Auto-generate capability manifests from skill/MCP descriptions using Codex-powered semantic analysis and structured extraction.
version: 1.0.0
category: ai-native
tags:
  - codex
  - automation
  - manifest
---

# Manifest Generator

**Auto-generate capability manifests from skill/MCP descriptions using Codex**

## Purpose

Uses OpenAI Codex to analyze existing skills, MCPs, tools, and components to automatically generate their capability manifests. This bootstraps the entire orchestration system by inferring preconditions, effects, domains, and relationships from descriptions and implementations.

## When to Use

- Bootstrapping: Generate manifests for all 59 skills + 50 MCPs at once
- New resources: Auto-generate manifest when creating new skills/MCPs
- Updates: Regenerate manifest when skill description changes
- Validation: Compare generated manifest with existing to detect drift

## Key Capabilities

- **Precondition Inference**: Analyzes skill description to determine what must exist before use
- **Effect Extraction**: Identifies state changes the skill produces
- **Domain Detection**: Categorizes skill into technical domains
- **Relationship Discovery**: Infers which skills this enables/conflicts with/composes with
- **Risk Assessment**: Evaluates cost, latency, and risk level from description

## Inputs

```yaml
inputs:
  skill_path: string # Path to skill directory (e.g., SKILLS/rag-implementer)
  resource_type: string # "skill" | "mcp" | "tool" | "component" | "integration"
  description_file: string # Usually SKILL.md or README.md
  implementation_file: string # Optional: actual code file for validation
  output_path: string # Where to write manifest.yaml (default: same directory)
```

## Process

### Step 1: Read Source Materials

```bash
# Read skill description
DESCRIPTION=$(cat $skill_path/SKILL.md)

# Read implementation if available
if [ -f "$skill_path/index.js" ]; then
  IMPLEMENTATION=$(head -100 $skill_path/index.js)
fi

# Read existing registry entry
REGISTRY_ENTRY=$(jq ".[] | select(.name==\"$skill_name\")" META/skill-registry.json)
```

### Step 2: Generate Manifest with Codex

```bash
codex exec "
Analyze this ${resource_type} and generate a capability manifest.

DESCRIPTION:
${DESCRIPTION}

IMPLEMENTATION (if available):
${IMPLEMENTATION}

REGISTRY ENTRY:
${REGISTRY_ENTRY}

Generate a YAML manifest matching this schema:
$(cat SCHEMAS/capability-manifest.schema.json)

Infer the following:

1. PRECONDITIONS: What files, dependencies, or state must exist?
   Examples:
   - file_exists('package.json')
   - has_dependency('react')
   - env_var_set('OPENAI_API_KEY')
   - not file_exists('.vector-index')

2. EFFECTS: What does this create/modify/delete?
   Examples:
   - creates_vector_index
   - adds_auth_middleware
   - configures_database
   - updates_tests

3. DOMAINS: What technical areas does it touch?
   Examples: rag, auth, api, database, testing, nextjs, react

4. COMPATIBILITY:
   - requires: What must exist first?
   - conflicts_with: What can't coexist?
   - composes_with: What works well together?
   - enables: What does this unlock?

5. RISK ASSESSMENT:
   - cost: free/low/medium/high (API calls, compute)
   - latency: instant/fast/slow (execution time)
   - risk_level: safe/low/medium/high (side effects)

6. SUCCESS SIGNAL: How do we know it worked?
   Examples:
   - 'tests pass'
   - 'file exists: .vector-index'
   - 'HTTP 200 from /api/search'
   - 'can query vector database'

Output ONLY valid YAML. No explanatory text.
"
```

### Step 3: Validate and Write

```bash
# Validate generated YAML against schema
npx ajv validate \
  -s SCHEMAS/capability-manifest.schema.json \
  -d /tmp/generated-manifest.yaml

# Write to output location
cp /tmp/generated-manifest.yaml $output_path
```

## Codex Prompt Template

```
Analyze this ${kind} and extract capability information:

NAME: ${name}
DESCRIPTION:
${description}

${implementation ? "IMPLEMENTATION:\n" + implementation : ""}

Generate a capability manifest with:

1. PRECONDITIONS (what must be true to use this?):
   - File checks: file_exists('path'), not file_exists('path')
   - Dependency checks: has_dependency('package-name')
   - Env checks: env_var_set('VAR_NAME')
   - State checks: describe project state requirements

2. EFFECTS (what changes does it make?):
   - Use imperative verbs: creates_, adds_, configures_, updates_, removes_
   - Be specific: "creates_vector_index", not "does vector stuff"

3. DOMAINS (what technical areas?):
   - Choose from: rag, auth, api, database, testing, nextjs, react, security, performance, etc.

4. COMPATIBILITY:
   - requires: [list of required capabilities]
   - conflicts_with: [capabilities that can't coexist]
   - composes_with: [capabilities that work well together]
   - enables: [capabilities this unlocks]

5. COST/LATENCY/RISK:
   - cost: free (no API calls), low (< $0.10), medium (< $1), high (> $1)
   - latency: instant (< 1s), fast (< 10s), slow (> 10s)
   - risk_level: safe (no side effects), low (idempotent), medium (modifies files), high (irreversible changes)

6. SUCCESS_SIGNAL: What confirms it worked?

Output as YAML matching capability-manifest schema.
```

## Example Output

```yaml
# SKILLS/rag-implementer/manifest.yaml
name: rag-implementer
kind: skill
description: Implement retrieval-augmented generation systems with vector databases and embedding pipelines
preconditions:
  - check: file_exists('package.json')
    description: Node.js project with package.json
    required: true
  - check: not file_exists('.vector-index')
    description: Vector database not already configured
    required: false
  - check: env_var_set('OPENAI_API_KEY') or env_var_set('ANTHROPIC_API_KEY')
    description: LLM API key for embeddings
    required: true
effects:
  - creates_vector_index
  - adds_embedding_pipeline
  - configures_retrieval_api
  - adds_rag_tests
domains:
  - rag
  - ai
  - search
  - embeddings
  - api
cost: medium
latency: slow
risk_level: low
side_effects:
  - modifies_files
  - makes_api_calls
idempotent: false
success_signal: 'Vector index created and queryable with test embeddings'
failure_signals:
  - 'API key invalid'
  - 'Vector database connection failed'
  - 'Embedding generation failed'
compatibility:
  requires:
    - openai-integration OR anthropic-integration
  conflicts_with:
    - existing-vector-database
  composes_with:
    - pinecone-mcp
    - weaviate-mcp
    - embedding-generator-mcp
  enables:
    - semantic-search
    - document-qa
    - knowledge-retrieval
observability:
  logs:
    - 'Embedding X documents'
    - 'Vector index created with Y dimensions'
    - 'Retrieval query: {query} returned {count} results'
  metrics:
    - embedding_count
    - retrieval_latency_ms
    - search_relevance_score
metadata:
  version: '1.0.0'
  created_at: '2025-10-28'
  tags:
    - rag
    - vector-database
    - embeddings
    - semantic-search
  examples:
    - 'Implement RAG for Next.js documentation site'
    - 'Add semantic search to existing API'
    - 'Build document Q&A system'
```

## Bootstrap Script

Run this to generate manifests for ALL resources:

```bash
#!/bin/bash
# scripts/bootstrap-manifests.sh

echo "Generating manifests for all skills..."
for skill_dir in SKILLS/*/; do
  skill_name=$(basename "$skill_dir")
  echo "  Processing $skill_name..."

  # Use manifest-generator skill
  bash scripts/skills/manifest-generator.sh \
    --path "$skill_dir" \
    --type "skill" \
    --description "$skill_dir/SKILL.md" \
    --output "$skill_dir/manifest.yaml"
done

echo "\nGenerating manifests for all MCPs..."
for mcp_dir in MCP-SERVERS/*/; do
  mcp_name=$(basename "$mcp_dir")
  echo "  Processing $mcp_name..."

  bash scripts/skills/manifest-generator.sh \
    --path "$mcp_dir" \
    --type "mcp" \
    --description "$mcp_dir/README.md" \
    --implementation "$mcp_dir/index.js" \
    --output "$mcp_dir/manifest.yaml"
done

echo "\nDone! Generated $(find SKILLS MCP-SERVERS -name 'manifest.yaml' | wc -l) manifests"
```

## Benefits

1. **Speed**: Generate 109 manifests in minutes instead of weeks
2. **Consistency**: Uniform format and completeness
3. **Discovery**: Codex finds relationships humans miss
4. **Validation**: Compare to detect description/implementation drift
5. **Evolution**: Re-run to update as skills change

## Integration

### With capability-graph-builder

Manifests become nodes in the capability graph. Relationships inferred from compatibility fields.

### With orchestration-planner

Planner queries manifests to find capabilities matching goal requirements.

### With skill-validator

Validator compares generated manifest with actual implementation to find discrepancies.

## Success Metrics

- ✅ 100% of skills/MCPs have manifests
- ✅ All manifests validate against schema
- ✅ Preconditions cover 90%+ of actual requirements
- ✅ Effects accurately describe state changes
- ✅ Relationship inferences 80%+ accurate

## Related Skills

- capability-graph-builder: Consumes manifests to build graph
- skill-validator: Validates manifests match implementations
- orchestration-planner: Uses manifests for planning

© daffy0208 · MIT · daffy0208/ai-dev-standards

Similar skills

All skills for Agent setup: memory, context, orchestration →
edit-manifest chrono-meta edit-manifest — a Claude Code skill that closes the edit loop in a harness: every change to SKILL.md, rules, or CLAUDE.md gets stored with a predicted effect, and the next session checks the prediction against what actually happened. CX Codex +1 ★ 33repo stars manifest-yaml-cursorrules-prompt-file PatrickJS manifest-yaml-cursorrules-prompt-file — a Cursor rule that turns the assistant into a Manifest backend developer. It kicks in when generating demo apps with entities and relationships in YAML. CX Codex +1 ★ 41,178repo stars feature-manifest curiositech A skill for working with feature manifests: create them, check health, map features to code, update changelogs. Useful when you need to know which code belongs to which feature. CX Codex +1 181installs platform-manifest-generate forcedotcom platform-manifest-generate writes a Salesforce package.xml or a destructive manifest from a source folder, a component list, or org introspection. Handy when the deploy is ready but the manifest is not. CX Codex +1 3,300installs generate-ppmplugin-manifest Microsoft generate-ppmplugin-manifest is a Claude Code skill that validates and stages manifest.json for .ppmplugin bundles before packaging, checking names, prefixes, and entrypoints without build tools. CX Codex +1 ★ 1,167repo stars pcf-manifest-schema official github pcf-manifest-schema — a rule that feeds Copilot the structure of ControlManifest.Input.xml: which elements and attributes exist and what they do. Useful when editing a PCF component manifest. CX Codex +1 ★ 41,430repo stars

From the same set63

The whole set →
System Diagnostician System Diagnostician runs automated repository diagnostics, spots structural and security gaps, and produces an action plan ranked by impact and effort. CX Codex +1 138installs Framework Orchestrator The Framework Orchestrator skill maps frameworks and other skills to project phases. Use it when you need a project pattern, an ordered plan, or phase checks. CX Codex +1 136installs release-manager release-manager turns a risky deploy into stages: internal team first, then 5% of beta users, then everyone. Comes with feature flags, canary deploys and rollback rules. CX Codex +1 135installs Orchestration Planner The Orchestration Planner skill turns a high-level goal into a checked workflow with ranked paths and fallbacks. It fits projects that keep capabilities in a graph. CX Codex +1 134installs Skill Validator Skill Validator validates skill and MCP implementations against manifests using Codex. Detects feature drift, unchecked preconditions, and API mismatches. CX Codex +1 131installs Capability Graph Builder Capability Graph Builder builds a queryable capability graph from tool manifests and checks relationships via Codex. Useful when setting up an orchestration knowledge base. CX Codex +1 130installs Archon Manager Archon Manager — a skill for strategic project management, task tracking, and knowledge base search across multiple platforms. CX Codex +1 129installs Dark Matter Analyzer Dark Matter Analyzer audits codebases for hidden friction, documentation inflation, and divergence between goals and commits. Useful before major refactorings. CX Codex +1 128installs

Project sponsors

Companies that keep this analytics open