Prompt Engineering for AI Visibility: Best Practices and Implementation

class PromptGenerator:
    def __init__(self):
        self.templates = {
            'comparison': "Compare {brands} for {use_case}. Which would you recommend?",
            'recommendation': "I'm looking for {product_type} that {requirements}. What brands would you suggest?",
            'feature_based': "What {product_type} has {feature_1} and {feature_2}?",
            'problem_solving': "I need {product_type} that solves {problem}. What are my options?"
        }
    
    def generate_prompts(
        self, 
        template_type: str,
        variables: Dict[str, Any],
        variations: int = 10
    ) -> List[str]:
        """Generate multiple prompt variations from template"""
        base_template = self.templates[template_type]
        prompts = []
        
        for i in range(variations):
            # Vary language and phrasing
            prompt = base_template.format(**variables)
            prompt = self._add_variation(prompt, i)
            prompts.append(prompt)
        
        return prompts
    
    def _add_variation(self, prompt: str, index: int) -> str:
        """Add linguistic variation to prompt"""
        variations = [
            lambda p: p.replace("would you", "could you"),
            lambda p: p.replace("recommend", "suggest"),
            lambda p: p.replace("looking for", "searching for"),
            lambda p: p + " Please provide specific brand names.",
            lambda p: "Can you help me? " + p,
        ]
        if index < len(variations):
            return variations[index](prompt)
        return prompt

# Usage
generator = PromptGenerator()
prompts = generator.generate_prompts(
    'recommendation',
    {
        'product_type': 'protein bars',
        'requirements': 'have at least 20g protein and under 200 calories'
    },
    variations=20
)

import asyncio
from typing import List, Dict
import statistics

class PromptTester:
    async def test_prompt_variations(
        self,
        prompt_variations: List[str],
        brand: str,
        llm_provider: str,
        iterations: int = 10
    ) -> Dict[str, float]:
        """Test multiple prompt variations and measure brand mention rate"""
        results = {}
        
        for prompt in prompt_variations:
            mention_counts = []
            for _ in range(iterations):
                response = await self._query_llm(prompt, llm_provider)
                mentions = self._count_brand_mentions(response, brand)
                mention_counts.append(mentions)
            
            results[prompt] = {
                'avg_mentions': statistics.mean(mention_counts),
                'std_dev': statistics.stdev(mention_counts),
                'mention_rate': sum(1 for m in mention_counts if m > 0) / iterations
            }
        
        return results
    
    def select_best_prompts(
        self,
        test_results: Dict[str, Dict],
        top_n: int = 5
    ) -> List[str]:
        """Select top performing prompts based on mention rate"""
        sorted_prompts = sorted(
            test_results.items(),
            key=lambda x: x[1]['mention_rate'],
            reverse=True
        )
        return [prompt for prompt, _ in sorted_prompts[:top_n]]

class PromptScorer:
    def score_prompt(
        self,
        prompt: str,
        response: str,
        brand: str,
        competitors: List[str]
    ) -> Dict[str, float]:
        """Score prompt based on multiple criteria"""
        scores = {
            'brand_mentioned': 1.0 if brand.lower() in response.lower() else 0.0,
            'response_length': min(len(response) / 500, 1.0),  # Normalize to 0-1
            'competitor_balance': self._calculate_competitor_balance(response, competitors),
            'specificity': self._calculate_specificity(response),
            'citation_presence': 1.0 if 'http' in response else 0.0
        }
        
        # Weighted overall score
        weights = {
            'brand_mentioned': 0.4,
            'response_length': 0.1,
            'competitor_balance': 0.2,
            'specificity': 0.2,
            'citation_presence': 0.1
        }
        
        overall_score = sum(scores[k] * weights[k] for k in scores.keys())
        scores['overall'] = overall_score
        
        return scores
    
    def _calculate_competitor_balance(
        self,
        response: str,
        competitors: List[str]
    ) -> float:
        """Calculate if response mentions multiple competitors (good for SOV)"""
        mentioned = sum(1 for comp in competitors if comp.lower() in response.lower())
        return min(mentioned / len(competitors), 1.0)
    
    def _calculate_specificity(self, response: str) -> float:
        """Calculate response specificity (more specific = better)"""
        # Count specific details: numbers, dates, features
        specifics = sum([
            len([x for x in response.split() if x.isdigit()]),
            response.count('%'),
            response.count('$'),
        ])
        return min(specifics / 10, 1.0)  # Normalize