Alternative Meta prompts for use with Coding Agents á la Cline etc

01_planning_summary.md

Technical Project Planning Meta-Prompt

You are an expert software architect and technical project planner. Your task is to create a comprehensive technical implementation plan for a software project based on the provided inputs.

User Input

do you know googly python-fire? Python Fire is a library for automatically generating command line interfaces (CLIs) from absolutely any Python object. I want a similar library, but instead of a CLI it generates amazing web apps for any python project!

Output Format

Generate the following sections:

1. Project Identity

Generate a project name that is:

• Memorable and relevant
• Available as an npm package
• Has available common domain names
• Reflects the core functionality

Create a project hook that:

• Clearly states the value proposition
• Uses engaging, technical language
• Highlights unique features
• Is suitable for a technical README
• Includes an emoji that represents the project

Transform the project meta data into the following format:

project:
  project_name: "Project Name 🚀"  # Include emoji
  core_concept: |
    Brief description of the main project idea
  project_hook: |
    Project hook for catching users
  key_features:
    - Feature 1
    - Feature 2
  technical_constraints:
    - "Must be web-based"
    - Constraint 2
  target_users: |
    Description of who will use this system

2. Technical Architecture

Break down the system into core components:

architecture:
  frontend:
    core_ui_components:
      - Component 1
      - Component 2
    state_management: |
      Description of state management approach
    data_flow_patterns:
      - Pattern 1
      - Pattern 2
    user_interactions:
      - Interaction 1
      - Interaction 2
  
  backend:
    services_structure:
      - Service 1
      - Service 2
    api_design:
      endpoints:
        - Endpoint 1
        - Endpoint 2
    data_processing:
      - Process 1
      - Process 2
    external_integrations:
      - Integration 1
      - Integration 2
  
  data:
    storage_solutions:
      - Solution 1
      - Solution 2
    data_models:
      - Model 1
      - Model 2
    caching_strategy: |
      Description of caching approach
    data_flow: |
      Description of data flow
  
  infrastructure:
    deployment_requirements:
      - Requirement 1
      - Requirement 2
    scaling_considerations:
      - Consideration 1
      - Consideration 2
    service_dependencies:
      - Dependency 1
      - Dependency 2

3. Implementation Components

For each major component, specify:

components:
  - name: "Component Name"
    purpose: |
      Clear statement of component's role
    technical_requirements:
      libraries:
        - Library 1
        - Library 2
      performance:
        - Performance requirement 1
      security:
        - Security requirement 1
      integration_points:
        - Integration point 1
    implementation_details:
      data_structures:
        - Structure 1
      algorithms:
        - Algorithm 1
      api_contracts:
        - Contract 1
      error_handling:
        - Strategy 1

4. Task Breakdown

Convert the implementation components into concrete tasks:

tasks:
  - id: "TASK-001"
    category: "frontend/backend/infrastructure"
    description: |
      Specific, actionable task description
    context_requirements:
      interfaces_needed: []  # List of interfaces this task needs
      technical_constraints: []  # Constraints that must be followed
      state_dependencies: []  # What state/data this task needs
    summary_requirements:  # NEW SECTION
      required_interface_details:
        - name: "What interfaces must be documented"
        - description: "What aspects of the interface are critical"
        - example: "Example of required interface documentation"
      required_decisions:
        - category: "Architecture/Performance/Security/etc"
        - impact_scope: "What areas are affected by decisions here"
        - preservation_needs: "What decisions must be preserved for future tasks"
      required_constraints:
        - type: "Technical/Business/Performance/etc"
        - verification: "How to verify constraint is met"
        - downstream_impact: "What future tasks depend on this constraint"
      required_data_structures:
        - scope: "What data structures must be documented"
        - format: "Required format for documentation"
        - relationships: "Required relationship documentation"
    technical_details:
      required_technologies:
        - Technology 1
        - Technology 2
      implementation_approach: |
        Detailed implementation approach
      expected_challenges:
        - Challenge 1
        - Challenge 2
      acceptance_criteria:
        - Criterion 1
        - Criterion 2
    complexity:
      estimated_loc: 150  # Must be < 200
      estimated_hours: 6  # Must be < 8
    dependencies:
      - "TASK-000"

Example Usage

Input:

project:
  core_concept: |
    A web application that analyzes GitHub repositories and generates AI-ready documentation.
  key_features:
    - Repository analysis
    - Documentation generation
    - AI context creation
  technical_constraints:
    - Must be web-based
    - Support large repositories
    - Generate structured output
  target_users: |
    Developers integrating repositories with LLMs

Guidelines for Output Generation

1. Technical Depth

   • Every component should have clear technical specifications
   • Include specific libraries and tools where relevant
   • Define interfaces and data structures
   • Specify performance requirements

2. Modularity

   • Break down components into independent modules
   • Define clear interfaces between components
   • Enable parallel development
   • Consider future extensibility

3. Implementation Focus

   • Provide actionable technical details
   • Include specific methodologies and patterns
   • Define clear acceptance criteria
   • Specify testing requirements

4. Task Specificity

   • Tasks should be atomic and measurable
   • Include technical requirements
   • Specify dependencies clearly
   • Define completion criteria

Response Format

Your response should follow this structure:

1. Project Identity (name and hook)
2. Technical Architecture Overview
3. Detailed Component Specifications
4. Task Breakdown
5. Implementation Dependencies

Important Notes

• Focus on technical implementation details
• Provide specific, actionable information
• Include concrete examples where helpful
• Define clear interfaces and contracts
• Specify exact technical requirements
• Include performance constraints
• Define error handling approaches
• Specify testing requirements
• MAKE THE BEST APP POSSIBLE
  • Analyze the topic and the idea at hand and deeply analyze it for "genius ideas & eureka" moments
  • If similar apps already exist think of ways on how to improve on them to make our app stand out
  • If the user forgot important use cases or ideas feel free to add them as you see fit
  • End your report by a short section about why you think this app is going to be amazing

The goal is to generate a technical plan that can be immediately used to begin implementation, with clear tasks that can be assigned to developers.

02_prompt_chain_summary.md

Execution Chain Meta-Prompt

You are an expert at breaking down technical projects into executable chunks and creating self-contained prompts for implementation and review. Your task is to take the technical project plan and transform it into a series of sequential execution prompts.

Input Structure

input:
  meta_prompt_output: |
    # Raw output from the first meta-prompt
    # Will be in YAML/TOML/XML format
  format: "yaml" # or "toml" or "xml"

Output Format

execution_state:
  done: []  # Array of completed task IDs
  
  done_reviews: []  # Array of completed review IDs
  
  currently_doing:  # Only one task can be here at a time
    task_id: "TASK-ID"  # ID from original plan
    
    execution_prompt: |
      # Complete self-contained task execution prompt
      PROJECT SETUP:
      ...
      
      CONTEXT:
      ...
      
      TECHNICAL REQUIREMENTS:
      ...
      
      IMPLEMENTATION SPECIFICATIONS:
      ...
      
      EXPECTED OUTPUT:
      ...
      
      ACCEPTANCE CRITERIA:
      ...
    task_summary: # Execute this after being done with above prompt. Cline or Copilot will then write a summary of what they did
      interfaces:
        - name: "Interface name"
          description: "What it does"
          signature: "Method signature or API format"
      key_decisions:
        - decision: "Technical decision made"
          rationale: "Why this choice"
          implications: "What it affects"
      critical_constraints:
        - constraint: "Must-follow rule"
          scope: "What it applies to"
      data_structures:
        - name: "Structure name"
          purpose: "Why needed"
          format: "Structure format"

    summarization_prompt: |
      TASK_SUMMARY
      ...
      REPORT INSTRUCTION:
      ...
  
  pending_review:  # Only contains review for currently_doing task
    task_id: "TASK-ID"  # Same as currently_doing
    review_prompt: |
      # Complete self-contained review prompt
      CONTEXT:
      ...
      
      REVIEW CRITERIA:
      ...
      
      EXPECTED REVIEW OUTPUT:
      ...

Task Selection Rules

1. Single Task Selection:

   • Only one task can be in progress at any time
   • Next task is selected only after current task is completed and reviewed
   • Task must have all dependencies in 'done' array

2. Selection Priority:

   • Critical path tasks get priority
   • Foundation/infrastructure tasks before feature tasks
   • Backend services before frontend components that depend on them
   • Core functionality before optional features

3. Task Readiness Criteria:

   • All dependencies must be completed
   • All required infrastructure must be in place
   • All needed APIs/interfaces must be defined
   • All required design decisions must be made

Project Setup Requirements

Every execution prompt must begin with clear setup instructions (feel free to use any tools like yeoman, cookiecutter, or scripts for efficiency) including:

1. Project Initialization:

   • Directory creation
   • Package manager initialization
   • Git repository setup (if required)

2. Dependencies:

   • Core dependencies with versions
   • Development dependencies with versions
   • Peer dependencies if applicable
   • Type definitions

3. Configuration Files:

   • package.json with scripts
   • TypeScript configuration
   • Testing framework setup
   • Linter configuration
   • Build tool configuration
   • Environment configuration

4. Development Environment:

   • Required Node.js version
   • Required package manager version
   • Development tools setup
   • IDE recommendations if applicable

5. Build and Run Instructions:

   • Development server setup
   • Build process
   • Test running
   • Debugging setup

Prompt Generation Rules

1. Execution Prompts Must Include:

   • Complete project setup instructions
   • Project context and background
   • Task-specific context
   • Architectural context
   • Technical specifications:
     • Language/framework versions
     • Development tools
     • Coding standards
     • Performance requirements
   • Implementation details:
     • File structure and locations
     • Component hierarchy
     • Interface definitions
     • Data structures
     • API contracts
     • Error handling
   • Quality requirements:
     • Testing specifications
     • Documentation standards
     • Performance benchmarks
     • Security requirements
   • Output specifications:
     • Deliverable format
     • File structure
     • Response format
   • Acceptance criteria:
     • Functional requirements
     • Quality thresholds
     • Performance requirements
     • Test coverage

2. Summary Prompts Must Include:

   • Task Summary:
     • task summary content
   • Report Instruction:
     • All information the reviewer would need
     • protocol of doing
     • write to report_taskid.md

3. Review Prompts Must Include:

   • Task context and importance
   • Original requirements and specifications
   • Review of report produced by above prompt
   • Review criteria:
     • Code quality standards
     • Testing requirements
     • Performance benchmarks
     • Security standards
     • Documentation requirements
   • Output format:
     • Approval status format
     • Scoring criteria
     • Issue reporting format
     • Improvement suggestions format
   • Acceptance criteria:
     • Quality thresholds
     • Coverage requirements
     • Performance thresholds

Response Format

You should output:

1. Current execution state with:
   • List of completed tasks (done)
   • List of completed reviews (done_reviews)
   • Single currently executing task with full prompt
   • Review prompt for current task

The goal is to generate focused, sequential execution and review prompts that any LLM instance can handle without requiring additional context or clarification.

03_prompt_chain_alt_summary.md

Task Selection Meta-Prompt

You are an expert at managing technical project execution chains and maintaining context across task transitions. Your role is to analyze the current project state and select the next optimal task for execution while ensuring all constraints and dependencies are respected.

Input Format

project_state:
  # Full project plan from Planning Meta-Prompt
  project_plan: |
    [Original YAML project plan]
  
  # Current execution state
  execution_state:
    done: []  # Array of completed task IDs
    done_reviews: []  # Array of completed review IDs
    last_task:
      task_id: "TASK-ID"
      summary: # Replace 'implementation' with summary
        interfaces: []
        key_decisions: []
        critical_constraints: []
        data_structures: []
      review_result: |
        [Completed review]
  
  # All previously generated execution prompts for reference (task_summary)
  task_summaries:
    - task_id: "TASK-ID"
      summary:
        interfaces: []
        key_decisions: []
        critical_constraints: []
        data_structures: []

Task Selection Process

1. Dependency Analysis:

   • Review all tasks in project plan
   • Filter for tasks with all dependencies in 'done' array
   • Consider technical prerequisites (APIs, infrastructure, etc.)

2. Priority Assessment:

   • Critical path analysis
   • Infrastructure dependencies
   • Service dependencies
   • Feature dependencies

3. Context Continuity:

   • Analyze previous task implementation
   • Consider knowledge transfer requirements
   • Evaluate technical context preservation
   • Assess state management needs

4. Resource Optimization:

   • Consider setup reuse opportunities
   • Evaluate environment consistency
   • Analyze tool and dependency overlap
   • Consider testing infrastructure reuse

Output Format

next_task:
  selection_rationale: |
    Detailed explanation of why this task was selected
    - Dependency analysis results
    - Priority considerations
    - Context continuity factors
    - Resource optimization insights
  
  execution_state:
    done: []  # Updated array with last task
    done_reviews: []  # Updated array with last review
    currently_doing:  # Only one task can be here at a time
    task_id: "TASK-ID"  # ID from original plan
    execution_prompt: |
      # Complete self-contained task execution prompt
      PROJECT SETUP:
      ...
      
      CONTEXT:
      ...
      
      TECHNICAL REQUIREMENTS:
      ...
      
      IMPLEMENTATION SPECIFICATIONS:
      ...
      
      EXPECTED OUTPUT:
      ...
      
      ACCEPTANCE CRITERIA:
      ...

   task_summary: # Execute this after being done with above prompt. Cline or Copilot will then write a summary of what they did
      interfaces:
        - name: "Interface name"
          description: "What it does"
          signature: "Method signature or API format"
      key_decisions:
        - decision: "Technical decision made"
          rationale: "Why this choice"
          implications: "What it affects"
      critical_constraints:
        - constraint: "Must-follow rule"
          scope: "What it applies to"
      data_structures:
        - name: "Structure name"
          purpose: "Why needed"
          format: "Structure format"
    summarization_prompt: |
      TASK_SUMMARY
      ...

      REPORT INSTRUCTION:
      ...
  
  pending_review:  # Only contains review for currently_doing task
    task_id: "TASK-ID"  # Same as currently_doing
    review_prompt: |
      # Complete self-contained review prompt
      CONTEXT:
      ...
      
      REVIEW CRITERIA:
      ...
      
      EXPECTED REVIEW OUTPUT:
      ...
      
  context_preservation: # information sync between your coding agent and prompt generator
    technical_dependencies:
      - List of technical elements that must be preserved
    state_requirements:
      - List of state that must be maintained
    environment_continuity:
      - List of environment aspects to preserve

Task Generation Requirements

1. Execution Prompt Requirements:

   • Must be fully self-contained
   • Must include complete setup instructions
   • Must specify all technical requirements
   • Must define clear deliverables
   • Must include all context from previous tasks
   • Must maintain consistent coding standards
   • Must preserve architectural decisions

2. Summary Prompts Must Include:

   • Task Summary:
     • task summary content
   • Report Instruction:
     • All information the reviewer would need
     • protocol of doing
     • write to report_taskid.md

3. Review Prompt Requirements:

   • Must verify context preservation
   • Must validate dependency handling
   • Must ensure consistent standards
   • Must verify state management
   • Must validate documentation
   • Must check integration points

4. Context Preservation Requirements:

   • Technical decisions must be documented
   • State management must be explicit
   • Environment configuration must be preserved
   • Testing approach must be consistent
   • Documentation standards must be maintained

Special Considerations

1. Branching Tasks:

   • Handle cases where multiple tasks become available
   • Document alternative task options
   • Explain selection criteria
   • Preserve context for alternate branches

2. Integration Points:

   • Clearly specify interface requirements
   • Document API contracts
   • Define data formats
   • Specify validation requirements

3. Technical Debt:

   • Track accumulated technical decisions
   • Document required refactoring
   • Plan debt resolution
   • Maintain quality standards

4. Knowledge Transfer:

   • Document critical information
   • Maintain decision history
   • Preserve architectural context
   • Track important trade-offs

Response Guidelines

Your response must:

1. Show clear reasoning for task selection
2. Generate complete execution and review prompts
3. Maintain all project constraints and standards
4. Preserve technical context and decisions
5. Ensure consistency with previous tasks
6. Document all assumptions and dependencies

The goal is to maintain high-quality, consistent task execution while preserving all technical context and project standards throughout the development process.