Wat is meta-prompting?

META_SYSTEM_PROMPT_GENERATOR = '''You are a prompt engineer specializing in system prompts.
Given a description of an AI assistant role, generate a comprehensive system prompt.

The system prompt you generate must:
1. Define the assistant\'s persona and expertise
2. Specify its primary objectives
3. List behavioral rules (what it should and should not do)
4. Define output format preferences
5. Include appropriate disclaimers for the domain
6. Be between 200-400 words

Output only the system prompt — no explanation, no preamble.'''

def generate_system_prompt(role_description):
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=600,
        system=META_SYSTEM_PROMPT_GENERATOR,
        messages=[{'role': 'user', 'content':
            f'Generate a system prompt for: {role_description}'}]
    )
    return response.content[0].text

# Example: generate a system prompt for a coding tutor
result = generate_system_prompt(
    'A Python coding tutor for absolute beginners aged 12-16, '
    'who explains concepts using simple analogies and emojis'
)
print(result[:400], '...')

META_CRITERIA_GENERATOR = '''You are an evaluation framework designer.
Given a task description, create a detailed evaluation rubric.

For each criterion:
- Name: concise label
- Weight: percentage (all weights sum to 100)
- Description: what to look for
- Scoring: 1-5 scale with what each score means

Output as a JSON array.'''

def generate_eval_criteria(task_description):
    import json
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=1000,
        system=META_CRITERIA_GENERATOR,
        messages=[{'role': 'user', 'content':
            f'Create evaluation criteria for: {task_description}'}]
    )
    return json.loads(response.content[0].text)

criteria = generate_eval_criteria(
    'AI-generated summaries of financial earnings reports'
)
for c in criteria[:3]:
    print(f'{c["name"]} ({c["weight"]}%): {c["description"][:50]}')

META_TEMPLATE_DESIGNER = '''You are a prompt template engineer.
Given a task type, design a prompt template with {variable} placeholders.

Requirements:
- Identify all input variables and use {variable_name} syntax
- Include clear instruction structure
- Specify desired output format
- Add any necessary constraints or rules
- Output: JSON with keys: template (string), variables (list of variable descriptions)'''

def design_prompt_template(task_type):
    import json
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=800,
        system=META_TEMPLATE_DESIGNER,
        messages=[{'role': 'user', 'content':
            f'Design a prompt template for: {task_type}'}]
    )
    return json.loads(response.content[0].text)

template = design_prompt_template('extracting action items from meeting notes')
print('Template:', template['template'][:200], '...')
print('Variables:', template['variables'][:3])

META_PERSONA_GENERATOR = '''Generate {num_personas} distinct AI assistant personas for the following application.
Each persona should have:
- Name
- Personality traits (3-5 adjectives)
- Communication style description
- Expertise areas
- Signature phrases or patterns
- Things this persona would never say

Make personas meaningfully different from each other.
Output as a JSON array.'''

def generate_personas(application, num_personas=3):
    import json
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=1500,
        messages=[{'role': 'user', 'content':
            META_PERSONA_GENERATOR.format(num_personas=num_personas) +
            f'\n\nApplication: {application}'}]
    )
    return json.loads(response.content[0].text)

personas = generate_personas('a fitness and wellness coaching app')
for p in personas:
    print(f'{p["name"]}: {p["personality_traits"]}')

def meta_prompt_pipeline(application_description):
    print('Step 1: Generating system prompt...')
    system_prompt = generate_system_prompt(application_description)

    print('Step 2: Generating evaluation criteria...')
    criteria = generate_eval_criteria(
        f'Responses from an AI assistant that: {application_description}'
    )

    print('Step 3: Generating test cases...')
    test_cases_meta = (
        f'Generate 5 diverse test user messages for an AI assistant '
        f'that {application_description}. '
        f'Include edge cases and difficult requests. Return as JSON list.'
    )
    test_response = client.messages.create(
        model='claude-opus-4-5', max_tokens=800,
        messages=[{'role': 'user', 'content': test_cases_meta}]
    )
    import json
    test_cases = json.loads(test_response.content[0].text)

    return {
        'system_prompt': system_prompt,
        'eval_criteria': criteria,
        'test_cases': test_cases
    }

result = meta_prompt_pipeline('helps junior developers understand error messages')
print('Pipeline output keys:', list(result.keys()))

def validate_generated_system_prompt(system_prompt):
    checks = {
        'Has persona definition': any(w in system_prompt.lower() for w in
            ['you are', 'your role', 'you\'re', 'act as']),
        'Has behavioral rules': any(w in system_prompt.lower() for w in
            ['do not', 'never', 'always', 'must', 'should']),
        'Has output format': any(w in system_prompt.lower() for w in
            ['format', 'output', 'structure', 'respond with']),
        'Length appropriate': 100 < len(system_prompt.split()) < 600,
        'No explicit profanity': True,  # add real check in production
        'Has domain scope': len(system_prompt) > 50
    }
    passed = sum(checks.values())
    print(f'Validation: {passed}/{len(checks)} checks passed')
    for check, result in checks.items():
        status = 'PASS' if result else 'FAIL'
        print(f'  [{status}] {check}')
    return all(checks.values())

# Validate a generated prompt
test_prompt = 'You are a helpful customer service assistant. Always be polite.'
validate_generated_system_prompt(test_prompt)

meta_prompting_limitations = {
    'Quality variance': (
        'Generated prompts vary in quality. '
        'Always evaluate and iterate — do not use raw output in production.'
    ),
    'Domain knowledge gaps': (
        'The model may generate plausible-sounding prompts that '
        'miss critical domain-specific requirements. '
        'Domain experts must review generated criteria and rules.'
    ),
    'Hallucinated instructions': (
        'Generated prompts may include instructions that sound right '
        'but are incorrect (e.g., citing wrong regulations, wrong APIs). '
        'Verify all factual claims in generated prompts.'
    ),
    'Misalignment with intent': (
        'A generated system prompt may technically fulfill the meta-prompt '
        'but not capture the actual product requirements. '
        'User testing is still required.'
    ),
    'Compounding errors': (
        'In meta-prompt chains, errors in early stages compound. '
        'Validate outputs at each step before passing to the next.'
    )
}

for limitation, description in meta_prompting_limitations.items():
    print(f'{limitation}: {description[:80]}...')

CRITIQUE_META_PROMPT = '''You are an expert prompt engineer.
Review the following prompt and identify weaknesses.

Prompt to review:
{prompt_to_review}

For each weakness:
1. Weakness: what is missing or unclear
2. Impact: what problems this causes in practice
3. Fix: exact suggested replacement text

Also provide:
- Overall quality score: 1-10
- Top 3 improvements ordered by impact

Be specific — quote the relevant part of the prompt.'''

def critique_existing_prompt(prompt_text):
    import anthropic
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=1000,
        messages=[{'role': 'user', 'content':
            CRITIQUE_META_PROMPT.format(prompt_to_review=prompt_text)}]
    )
    return response.content[0].text

# Example usage
weak_prompt = 'Summarize the article.'
critique = critique_existing_prompt(weak_prompt)
print(critique[:300], '...')

WHEN_TO_USE = {
    'Meta-prompting is better when': [
        'You need many prompt variants quickly (A/B testing)',
        'The use case is well-defined and the requirements are clear',
        'You need to scale prompt creation across many categories',
        'You want to explore the design space of possible prompts',
        'You have evaluation criteria to filter generated prompts'
    ],
    'Manual prompt engineering is better when': [
        'Deep domain expertise is required (medical, legal, safety-critical)',
        'The prompt controls a high-stakes production system',
        'Iterative refinement and human judgment are essential',
        'The requirements are nuanced and hard to express to a meta-prompt',
        'You need guaranteed correctness (not just plausible)'
    ]
}

for mode, reasons in WHEN_TO_USE.items():
    print(f'\n{mode}:')
    for r in reasons[:3]:
        print(f'  - {r}')