jeffemmett
/
infinite-agents-public
mirror of https://github.com/Jeff-Emmett/infinite-agents-public.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
infinite-agents-public/infinite_variants/infinite_variant_7/.claude/commands/generate-spec.md

9.7 KiB
Raw Blame History

Generate Spec - Auto-Generate New Specifications

Purpose: Automatically create new specification files based on discovered patterns and meta-level insights.

Usage

/generate-spec [source] [focus] [output_name]

Parameters

  • source: What to analyze - "patterns", "logs", "existing_specs", "all" (default: "all")
  • focus: Generation focus - "novel", "variant", "evolution", "hybrid" (default: "novel")
  • output_name: Output filename (default: auto-generated)

Examples

# Generate completely novel spec from all patterns
/generate-spec all novel

# Create variant of existing specs
/generate-spec existing_specs variant custom_spec

# Evolve specs based on improvement logs
/generate-spec logs evolution

# Hybrid approach combining multiple sources
/generate-spec all hybrid advanced_spec

Command Implementation

You are the Auto-Specification Generator. Your role is to analyze patterns and generate new, high-quality specification files using meta-prompting principles.

Phase 1: Pattern Discovery

  1. Load Source Materials

    Based on {{source}} parameter:

    • patterns: Analyze output files for recurring themes, structures, quality patterns
    • logs: Review improvement_log/ for meta-insights and successful strategies
    • existing_specs: Study specs/ directory for specification patterns
    • all: Comprehensive analysis of all sources

  2. Extract Structural Patterns (Meta-Prompting Principle)

    Focus on structure over content:

    • What architectural patterns repeat?
    • What abstract frameworks are most successful?
    • What logical flows work best?
    • What syntax templates are most generalizable?

  3. Identify Meta-Level Insights

    • Which specification elements drive best results?
    • What constraints enable creativity vs. limit it?
    • How do quality criteria correlate with outcomes?
    • What patterns emerge across 10+ iterations?

Phase 2: Specification Synthesis

  1. Apply Generation Focus

    Novel Mode: Create entirely new specification type

    • Identify unexplored problem domains
    • Combine patterns in novel ways
    • Introduce new quality dimensions
    • Define fresh creative constraints

    Variant Mode: Create variation of existing spec

    • Take best-performing existing spec
    • Modify key parameters (complexity, domain, constraints)
    • Maintain proven structural patterns
    • Add 2-3 innovative elements

    Evolution Mode: Evolve specs based on learnings

    • Start with baseline spec
    • Apply improvement log insights
    • Enhance quality criteria based on metrics
    • Refine constraints for better results

    Hybrid Mode: Combine multiple successful patterns

    • Merge structural elements from top specs
    • Create multi-dimensional quality criteria
    • Balance constraints from different domains
    • Synthesize meta-insights into unified spec

  2. Structure-Oriented Spec Design

    Use meta-prompting template:

    # [Spec Title] - Auto-Generated Specification

**Generated From:** {{source}}
**Focus:** {{focus}}
**Created:** {{timestamp}}
**Meta-Patterns Applied:** [list key patterns]

## Overview
[Abstract description of what to generate]

## Structural Framework
[High-level architecture and organization]

## Generation Patterns
[Repeatable patterns for content creation]

### Pattern 1: [Name]
- Abstract Structure: [template]
- Reasoning Flow: [logical steps]
- Quality Criteria: [measurable]

### Pattern 2: [Name]
- Abstract Structure: [template]
- Reasoning Flow: [logical steps]
- Quality Criteria: [measurable]

## Quality Dimensions
[Measurable criteria focusing on structure and principles]

1. **Structural Integrity** (0-10)
   - Clear architectural patterns
   - Logical organization
   - Consistent abstraction levels

2. **Generalizability** (0-10)
   - Pattern applicability across contexts
   - Minimal example-dependency
   - Principle-driven design

3. **Innovation** (0-10)
   - Novel pattern combinations
   - Creative constraint application
   - Unexpected yet coherent results

4. **Meta-Awareness** (0-10)
   - Self-referential understanding
   - Reflection on generation process
   - Evolution potential

## Creative Constraints
[Constraints that enable creativity]

- Must follow [structural pattern]
- Should apply [abstract principle]
- Cannot duplicate [specific anti-pattern]
- Must demonstrate [meta-capability]

## Naming Convention
[Pattern-based naming system]

## File Structure
[Expected organization]

## Success Criteria
[How to evaluate generated output]

## Meta-Instructions for Generators
[Structure-oriented guidance for sub-agents]

When generating content for this spec:
1. Focus on STRUCTURE over content details
2. Apply ABSTRACT frameworks, not specific examples
3. Use PATTERN-based reasoning
4. Maintain META-AWARENESS of your process
5. Reflect and improve with each iteration

## Evolution Hooks
[How this spec can evolve further]

- Complexity progression: [path]
- Domain variations: [options]
- Pattern extensions: [possibilities]
- Meta-level enhancements: [future capabilities]

Phase 3: Validation and Enhancement

  1. Self-Validation

    Review generated spec against criteria:

    • ✓ Is it structurally sound?
    • ✓ Are patterns generalizable?
    • ✓ Does it minimize example-dependency?
    • ✓ Is quality measurable?
    • ✓ Can it evolve further?
    • ✓ Does it embody meta-prompting principles?

  2. Enhancement Opportunities

    • Add 2-3 creative constraints that enable uniqueness
    • Include meta-instructions for self-improvement
    • Design evolution hooks for future iterations
    • Ensure success criteria are objective

Phase 4: Output Generation

  1. Write Specification File

    Create specs/{{output_name}}.md with complete specification.

  2. Generate Companion Files

    Create supporting materials:

    specs/{{output_name}}_guide.md: Usage guide

    # Guide: {{output_name}}

## Quick Start
[How to use this spec]

## Pattern Explanations
[Detail each pattern]

## Quality Assessment
[How to evaluate results]

## Evolution Path
[How to extend this spec]

    specs/{{output_name}}_examples.md: Abstract examples

    # Abstract Examples: {{output_name}}

## Structural Template 1
[Framework without specific content]

## Reasoning Pattern 1
[Logical flow template]

## Quality Benchmark
[What excellence looks like structurally]

  3. Document Generation Process

    Create improvement_log/spec_generation_{{timestamp}}.md:

    # Spec Generation Log - {{output_name}}

## Source Analysis
[What was analyzed]

## Patterns Discovered
[Structural patterns found]

## Meta-Insights Applied
[Meta-prompting principles used]

## Generation Decisions
[Why certain choices were made]

## Validation Results
[How spec was validated]

## Recommended Usage
[Best practices for using this spec]

## Future Evolution
[How this spec can improve]

Phase 5: Integration

  1. Update Spec Index

    Add entry to specs/README.md:

    ### {{output_name}} (Auto-Generated)
- **Focus:** {{focus}}
- **Patterns:** [key patterns]
- **Best For:** [use cases]
- **Evolution:** [maturity level]

  2. Link to Meta-Prompts

    Update meta_prompts/spec_generator.md with:

    • Successful generation patterns used
    • New structural templates discovered
    • Enhanced reasoning frameworks

Meta-Prompting for Spec Generation

This command applies meta-prompting to generate specifications:

ABSTRACTION: Spec generation is pattern synthesis
STRUCTURE: Load sources → Extract patterns → Synthesize → Validate → Output
REASONING: Generalizable frameworks over specific examples

SELF_REFLECTION:
- Am I creating structural templates or just content?
- Are my patterns generalizable across domains?
- Does the spec enable meta-level capabilities?
- Can generators using this spec improve themselves?

META_PATTERN:
Specs should define HOW to think, not WHAT to create.
They provide frameworks, not examples.
They enable evolution, not just execution.

Output Files

specs/
├── {{output_name}}.md
├── {{output_name}}_guide.md
├── {{output_name}}_examples.md
└── README.md (updated)

improvement_log/
├── spec_generation_{{timestamp}}.md
└── patterns_discovered_{{timestamp}}.json

meta_prompts/
└── spec_generator.md (updated)

Advanced Features

Pattern Library Evolution

Maintain specs/pattern_library.md with all discovered patterns:

  • Structural templates
  • Reasoning frameworks
  • Quality dimensions
  • Constraint types

Spec Lineage Tracking

Document spec genealogy:

  • Which specs influenced this one
  • What patterns were combined
  • How it evolved from parent specs
  • Potential child spec variations

Auto-Testing Integration

Generate test cases for new specs:

  • Run small batch (3-5 iterations)
  • Validate pattern effectiveness
  • Measure quality metrics
  • Refine spec based on results

Success Criteria

A successfully generated spec:

  1. Defines clear structural patterns
  2. Minimizes example-dependency
  3. Enables generalizable reasoning
  4. Includes meta-awareness instructions
  5. Has measurable quality criteria
  6. Shows evolution potential
  7. Embodies meta-prompting principles

This command generates specifications using meta-prompting principles. It creates structural frameworks and abstract patterns that enable efficient, generalizable content generation while maintaining meta-level self-improvement capabilities.