Chapter 5: Prompt Engineering and System Instructions

5.3 Prompt Templates: Coding, Productivity, Customer Support

Prompt templates are carefully designed, pre-formulated instructions that serve as blueprints for AI interactions. These templates act as structured frameworks that guide AI models to generate responses in a consistent, predictable, and desired format. Think of them as recipe cards - they contain all the necessary ingredients and steps to produce the exact output you need.

The power of prompt templates lies in their ability to:

Standardize Communication: They ensure every interaction follows a predetermined pattern
Improve Efficiency: By eliminating the need to craft new prompts for similar requests
Enhance Quality: Through carefully worded instructions that prevent common mistakes
Save Time: By reducing the trial-and-error process in prompt engineering

In this section, we'll explore three essential categories of prompt templates that form the backbone of many AI applications:

Coding – For programming help, debugging, or code generation
- Includes syntax correction, code optimization, and architectural guidance
- Helps maintain consistent coding standards and best practices
Productivity – For generating summaries, to-do lists, or scheduling insights
- Facilitates better time management and task organization
- Helps create clear, actionable items from complex information
Customer Support – For addressing inquiries, providing troubleshooting steps, or responding to customer feedback
- Ensures consistent, professional communication with customers
- Maintains brand voice while delivering helpful solutions

Let's explore each category with detailed examples.

5.3.1 Prompt Templates for Coding

When building AI-powered coding assistants or tutoring systems, clarity is absolutely essential for effective results. Your prompt template serves as the foundation for all interactions, so it must be meticulously crafted with several key elements. Let's explore each element in detail to understand their importance and implementation:

First, it should clearly define the task at hand - whether that's code review, bug fixing, or concept explanation. This definition needs to be specific enough that the AI understands exactly what type of assistance is required. For example, instead of saying "review this code," specify "review this Python function for potential memory leaks and suggest optimizations for better performance." This level of specificity helps the AI provide more targeted and valuable assistance.

Second, the template must specify any important constraints or requirements, such as programming language, coding style guidelines, or performance considerations. These constraints help ensure the AI's response stays within useful parameters. For instance, you might specify:

Programming language version (e.g., "Python 3.9+")
- Style guide requirements (e.g., "PEP 8 compliant")
- Performance targets (e.g., "optimize for memory usage over speed")
- Project-specific conventions (e.g., "follow company naming conventions")

Finally, including a relevant example in your template can significantly improve the quality of responses. This example serves as a concrete reference point, showing the AI exactly what kind of output you're looking for. For instance, when asking for code optimization, providing a sample of the current code structure helps the AI understand your coding style and maintain consistency. A good example should include:

Context about the code's purpose and environment
Any existing documentation or comments
Related functions or dependencies
Expected input/output behaviors
Current performance metrics or issues

Example: Debugging Assistance

Imagine you want the AI to help debug a piece of Python code. Your prompt might provide context, show the code snippet, and ask specific questions about potential errors.

Template:

import openai
import os
from dotenv import load_dotenv
import logging
from typing import Optional

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def setup_openai_client() -> bool:
    """Initialize OpenAI client with API key from environment."""
    try:
        load_dotenv()
        openai.api_key = os.getenv("OPENAI_API_KEY")
        if not openai.api_key:
            raise ValueError("OpenAI API key not found")
        return True
    except Exception as e:
        logger.error(f"Failed to initialize OpenAI client: {e}")
        return False

def factorial(n: int) -> Optional[int]:
    """
    Calculate the factorial of a non-negative integer.
    
    Args:
        n (int): The number to calculate factorial for
        
    Returns:
        Optional[int]: The factorial result or None if input is invalid
        
    Raises:
        RecursionError: If input is too large
        ValueError: If input is negative
    """
    try:
        if not isinstance(n, int):
            raise TypeError("Input must be an integer")
        if n < 0:
            raise ValueError("Input must be non-negative")
        if n == 0:
            return 1
        else:
            return n * factorial(n - 1)  # Fixed recursion
    except Exception as e:
        logger.error(f"Error calculating factorial: {e}")
        return None

def get_debugging_assistance(code_snippet: str) -> str:
    """
    Get AI assistance for debugging code.
    
    Args:
        code_snippet (str): The problematic code to debug
        
    Returns:
        str: AI's debugging suggestions
    """
    if not setup_openai_client():
        return "Failed to initialize OpenAI client"

    messages = [
        {"role": "system", "content": "You are a knowledgeable and patient coding assistant."},
        {"role": "user", "content": (
            f"I have the following Python code that needs debugging:\n\n"
            f"{code_snippet}\n\n"
            "Please identify any bugs and suggest fixes."
        )}
    ]

    try:
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=messages,
            max_tokens=200,
            temperature=0.5
        )
        return response["choices"][0]["message"]["content"]
    except Exception as e:
        logger.error(f"Error getting OpenAI response: {e}")
        return f"Failed to get debugging assistance: {str(e)}"

def main():
    # Example usage
    test_cases = [5, 0, -1, "invalid", 10]
    
    for test in test_cases:
        print(f"\nTesting factorial({test})")
        try:
            result = factorial(test)
            print(f"Result: {result}")
        except Exception as e:
            print(f"Error: {e}")

    # Example of getting debugging assistance
    problematic_code = """
    def factorial(n):
        if n == 0:
            return 1
        else:
            return n * factorial(n)  # Bug: infinite recursion
    """
    
    print("\nGetting debugging assistance:")
    assistance = get_debugging_assistance(problematic_code)
    print(assistance)

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Structure and Organization
- Imports are grouped logically and include type hints and logging
- Functions are well-documented with docstrings
- Error handling is implemented throughout
Key Components
- setup_openai_client(): Handles API initialization safely
- factorial(): Improved with type hints and error handling
- get_debugging_assistance(): Encapsulates AI interaction logic
- main(): Demonstrates usage with various test cases
Improvements Over Original
- Added comprehensive error handling
- Included type hints for better code clarity
- Implemented logging for debugging
- Added test cases to demonstrate different scenarios
Best Practices Demonstrated
- Function separation for better maintainability
- Proper documentation and comments
- Robust error handling and logging
- Type hints for better code clarity

In this template, the prompt clearly sets expectations by indicating the AI’s role and providing the exact problem. This helps the assistant diagnose issues effectively.

5.3.2 Prompt Templates for Productivity

For productivity applications, your prompts need to be carefully designed to generate different types of organizational content. These templates should be structured to handle three main categories of productivity tools:

1. Detailed Summaries

These should condense complex information into digestible formats while preserving essential meaning. When crafting prompts for summaries, consider:

Key information extraction techniques
- Using semantic analysis to identify main concepts
- Implementing keyword recognition for important points
- Applying natural language processing to detect key themes
Hierarchical organization of main points and supporting details
- Creating clear primary, secondary, and tertiary levels of information
- Establishing logical connections between related points
- Using consistent formatting to indicate information hierarchy
Methods for maintaining context while reducing length
- Preserving critical contextual information
- Using concise language without sacrificing clarity
- Implementing effective transition phrases to maintain flow

Example: Detailed Summary Generator

import openai
import os
from dotenv import load_dotenv
from typing import Dict, List, Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class SummaryGenerator:
    def __init__(self):
        """Initialize the SummaryGenerator with OpenAI credentials."""
        load_dotenv()
        self.api_key = os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OpenAI API key not found in environment")
        openai.api_key = self.api_key

    def extract_key_points(self, text: str) -> List[str]:
        """
        Extract main points from the input text using semantic analysis.
        
        Args:
            text (str): Input text to analyze
            
        Returns:
            List[str]: List of key points extracted from the text
        """
        try:
            messages = [
                {"role": "system", "content": "You are a precise summarization assistant. Extract only the main points from the following text."},
                {"role": "user", "content": text}
            ]
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=150,
                temperature=0.3
            )
            
            return response.choices[0].message.content.split('\n')
        except Exception as e:
            logger.error(f"Error extracting key points: {e}")
            return []

    def generate_hierarchical_summary(self, text: str, max_length: int = 500) -> Dict[str, any]:
        """
        Generate a structured summary with hierarchical organization.
        
        Args:
            text (str): Input text to summarize
            max_length (int): Maximum length of the summary
            
        Returns:
            Dict: Structured summary with main points and supporting details
        """
        try:
            messages = [
                {"role": "system", "content": (
                    "Create a hierarchical summary with the following structure:\n"
                    "1. Main points (maximum 3)\n"
                    "2. Supporting details for each point\n"
                    "3. Key takeaways"
                )},
                {"role": "user", "content": f"Summarize this text in {max_length} characters:\n{text}"}
            ]
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=300,
                temperature=0.4
            )
            
            return {
                "summary": response.choices[0].message.content,
                "length": len(response.choices[0].message.content),
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error generating summary: {e}")
            return {"error": str(e)}

    def format_summary(self, summary_dict: Dict[str, any]) -> str:
        """
        Format the summary into a readable structure.
        
        Args:
            summary_dict (Dict): Dictionary containing summary information
            
        Returns:
            str: Formatted summary
        """
        if "error" in summary_dict:
            return f"Error generating summary: {summary_dict['error']}"
            
        formatted_output = [
            "# Summary Report",
            f"Generated on: {summary_dict['timestamp']}",
            f"Length: {summary_dict['length']} characters\n",
            summary_dict['summary']
        ]
        
        return "\n".join(formatted_output)

def main():
    # Example usage
    sample_text = """
    Artificial Intelligence has transformed various industries, from healthcare to finance.
    Machine learning algorithms now power recommendation systems, fraud detection, and
    medical diagnosis. Deep learning, a subset of AI, has particularly excelled in image
    and speech recognition tasks. However, these advances also raise important ethical
    considerations regarding privacy and bias in AI systems.
    """
    
    summarizer = SummaryGenerator()
    
    # Generate and display summary
    summary = summarizer.generate_hierarchical_summary(sample_text)
    formatted_summary = summarizer.format_summary(summary)
    print(formatted_summary)

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Class Structure and Organization
- SummaryGenerator class encapsulates all summary-related functionality
- Clear separation of concerns with distinct methods for different tasks
- Proper error handling and logging throughout the code
Key Components
- extract_key_points(): Uses semantic analysis to identify main concepts
- generate_hierarchical_summary(): Creates structured summaries with clear hierarchy
- format_summary(): Converts raw summary data into readable output
Advanced Features
- Type hints for better code clarity and maintainability
- Configurable summary length and structure
- Timestamp tracking for summary generation
- Error handling with detailed logging
Best Practices Demonstrated
- Environment variable management for API keys
- Comprehensive documentation with docstrings
- Modular design for easy testing and maintenance
- Clean code structure following PEP 8 guidelines

This example demonstrates a production-ready approach to generating detailed summaries, with proper error handling, logging, and a clear structure that can be easily integrated into larger applications.

2. To-Do Lists

These break down tasks into manageable steps. Effective to-do list prompts should incorporate:

Task prioritization mechanisms
- High/Medium/Low priority flags to identify critical tasks
- Urgency indicators based on deadlines and impact
- Dynamic reprioritization based on changing circumstances
Time estimation guidelines
- Realistic time frames for task completion
- Buffer periods for unexpected delays
- Effort-based estimations (e.g., quick wins vs. complex tasks)
Dependency mapping between tasks
- Clear identification of prerequisites
- Sequential vs. parallel task relationships
- Critical path analysis for complex projects
Progress tracking indicators
- Percentage completion metrics
- Milestone checkpoints
- Status updates (Not Started, In Progress, Completed)

Example: Task Management System

import openai
import os
from datetime import datetime, timedelta
from typing import List, Dict, Optional
from enum import Enum
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

class TaskStatus(Enum):
    NOT_STARTED = "not_started"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"

class Task:
    def __init__(
        self,
        title: str,
        description: str,
        priority: Priority,
        due_date: datetime,
        estimated_hours: float
    ):
        self.title = title
        self.description = description
        self.priority = priority
        self.due_date = due_date
        self.estimated_hours = estimated_hours
        self.status = TaskStatus.NOT_STARTED
        self.completion_percentage = 0
        self.dependencies: List[Task] = []
        self.created_at = datetime.now()

class TodoListManager:
    def __init__(self):
        """Initialize TodoListManager with OpenAI credentials."""
        load_dotenv()
        self.api_key = os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OpenAI API key not found")
        openai.api_key = self.api_key
        self.tasks: List[Task] = []

    def add_task(self, task: Task) -> None:
        """Add a new task to the list."""
        self.tasks.append(task)
        logger.info(f"Added task: {task.title}")

    def update_task_status(
        self,
        task: Task,
        status: TaskStatus,
        completion_percentage: int
    ) -> None:
        """Update task status and completion percentage."""
        task.status = status
        task.completion_percentage = min(100, max(0, completion_percentage))
        logger.info(f"Updated task {task.title}: {status.value}, {completion_percentage}%")

    def add_dependency(self, task: Task, dependency: Task) -> None:
        """Add a dependency to a task."""
        if dependency not in task.dependencies:
            task.dependencies.append(dependency)
            logger.info(f"Added dependency {dependency.title} to {task.title}")

    def get_priority_tasks(self, priority: Priority) -> List[Task]:
        """Get all tasks of a specific priority."""
        return [task for task in self.tasks if task.priority == priority]

    def get_overdue_tasks(self) -> List[Task]:
        """Get all overdue tasks."""
        now = datetime.now()
        return [
            task for task in self.tasks
            if task.due_date < now and task.status != TaskStatus.COMPLETED
        ]

    def generate_task_summary(self) -> str:
        """Generate a summary of all tasks using AI."""
        try:
            tasks_text = "\n".join(
                f"- {task.title} ({task.priority.value}, {task.completion_percentage}%)"
                for task in self.tasks
            )

            messages = [
                {"role": "system", "content": "You are a task management assistant."},
                {"role": "user", "content": f"Generate a brief summary of these tasks:\n{tasks_text}"}
            ]

            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=150,
                temperature=0.3
            )

            return response.choices[0].message.content
        except Exception as e:
            logger.error(f"Error generating task summary: {e}")
            return "Unable to generate summary at this time."

def main():
    # Example usage
    todo_manager = TodoListManager()

    # Create sample tasks
    task1 = Task(
        "Implement user authentication",
        "Add OAuth2 authentication to the API",
        Priority.HIGH,
        datetime.now() + timedelta(days=2),
        8.0
    )

    task2 = Task(
        "Write unit tests",
        "Create comprehensive test suite",
        Priority.MEDIUM,
        datetime.now() + timedelta(days=4),
        6.0
    )

    # Add tasks and dependencies
    todo_manager.add_task(task1)
    todo_manager.add_task(task2)
    todo_manager.add_dependency(task2, task1)

    # Update task status
    todo_manager.update_task_status(task1, TaskStatus.IN_PROGRESS, 50)

    # Generate and print summary
    summary = todo_manager.generate_task_summary()
    print("\nTask Summary:")
    print(summary)

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Class Structure and Design
- Task class encapsulates all task-related attributes and metadata
- TodoListManager handles task operations and AI interactions
- Enum classes provide type safety for Priority and TaskStatus
Key Features
- Comprehensive task tracking with priorities and dependencies
- Progress monitoring with completion percentages
- AI-powered task summarization capability
- Robust error handling and logging
Advanced Functionality
- Dependency management between tasks
- Overdue task identification
- Priority-based task filtering
- AI-generated task summaries
Best Practices Implemented
- Type hints for better code clarity
- Comprehensive error handling
- Proper logging implementation
- Clean, modular code structure

This implementation demonstrates a production-ready task management system that combines traditional to-do list functionality with AI-powered features for enhanced productivity.

3. Project Outlines

These map out objectives and milestones, providing a comprehensive roadmap for project success. Your prompts should address:

Project scope definition
- Clear objectives and deliverables
- Project boundaries and limitations
- Key stakeholder requirements
Timeline creation and management
- Major milestone identification
- Task sequencing and dependencies
- Deadline setting and tracking methods
Resource allocation considerations
- Team member roles and responsibilities
- Budget distribution and tracking
- Equipment and tool requirements
Risk assessment factors
- Potential obstacles and challenges
- Mitigation strategies
- Contingency planning approaches

Example: Project Management System

import openai
import os
from datetime import datetime, timedelta
from typing import List, Dict, Optional
from enum import Enum
import logging
from dataclasses import dataclass

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class Milestone:
    title: str
    due_date: datetime
    description: str
    completion_status: float = 0.0
    
class ProjectStatus(Enum):
    PLANNING = "planning"
    IN_PROGRESS = "in_progress"
    ON_HOLD = "on_hold"
    COMPLETED = "completed"

class ProjectOutlineManager:
    def __init__(self):
        """Initialize ProjectOutlineManager with OpenAI configuration."""
        self.api_key = os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OpenAI API key not found")
        openai.api_key = self.api_key
        
        self.objectives: List[str] = []
        self.milestones: List[Milestone] = []
        self.resources: Dict[str, List[str]] = {}
        self.risks: List[Dict[str, str]] = []
        self.status = ProjectStatus.PLANNING
        
    def add_objective(self, objective: str) -> None:
        """Add a project objective."""
        self.objectives.append(objective)
        logger.info(f"Added objective: {objective}")
        
    def add_milestone(self, milestone: Milestone) -> None:
        """Add a project milestone."""
        self.milestones.append(milestone)
        logger.info(f"Added milestone: {milestone.title}")
        
    def add_resource(self, category: str, resource: str) -> None:
        """Add a resource under a specific category."""
        if category not in self.resources:
            self.resources[category] = []
        self.resources[category].append(resource)
        logger.info(f"Added {resource} to {category}")
        
    def add_risk(self, risk: str, mitigation: str) -> None:
        """Add a risk and its mitigation strategy."""
        self.risks.append({"risk": risk, "mitigation": mitigation})
        logger.info(f"Added risk: {risk}")
        
    def generate_project_summary(self) -> str:
        """Generate an AI-powered project summary."""
        try:
            project_details = {
                "objectives": self.objectives,
                "milestones": [f"{m.title} (Due: {m.due_date})" for m in self.milestones],
                "resources": self.resources,
                "risks": self.risks,
                "status": self.status.value
            }
            
            messages = [
                {"role": "system", "content": "You are a project management assistant."},
                {"role": "user", "content": f"Generate a concise summary of this project:\n{project_details}"}
            ]
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=200,
                temperature=0.3
            )
            
            return response.choices[0].message.content
        except Exception as e:
            logger.error(f"Error generating project summary: {e}")
            return "Unable to generate summary at this time."
            
    def export_outline(self) -> Dict:
        """Export the project outline in a structured format."""
        return {
            "status": self.status.value,
            "objectives": self.objectives,
            "milestones": [
                {
                    "title": m.title,
                    "due_date": m.due_date.isoformat(),
                    "description": m.description,
                    "completion": m.completion_status
                }
                for m in self.milestones
            ],
            "resources": self.resources,
            "risks": self.risks,
            "last_updated": datetime.now().isoformat()
        }

def main():
    # Example usage
    project_manager = ProjectOutlineManager()
    
    # Add objectives
    project_manager.add_objective("Develop a scalable web application")
    project_manager.add_objective("Launch beta version within 3 months")
    
    # Add milestones
    milestone1 = Milestone(
        "Complete Backend API",
        datetime.now() + timedelta(days=30),
        "Implement RESTful API endpoints"
    )
    project_manager.add_milestone(milestone1)
    
    # Add resources
    project_manager.add_resource("Development Team", "Frontend Developer")
    project_manager.add_resource("Development Team", "Backend Developer")
    project_manager.add_resource("Tools", "AWS Cloud Services")
    
    # Add risks
    project_manager.add_risk(
        "Technical debt accumulation",
        "Regular code reviews and refactoring sessions"
    )
    
    # Generate and display summary
    summary = project_manager.generate_project_summary()
    print("\nProject Summary:")
    print(summary)
    
if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Core Structure and Design
- Uses dataclasses for clean data structure representation
- Implements Enum for project status tracking
- Centralizes project management functionality in ProjectOutlineManager
Key Components
- Milestone tracking with due dates and completion status
- Resource management categorized by department/type
- Risk assessment with mitigation strategies
- AI-powered project summary generation
Advanced Features
- Structured data export functionality
- Comprehensive logging system
- Error handling for AI interactions
- Flexible resource categorization
Best Practices Implemented
- Type hints for improved code maintainability
- Proper error handling and logging
- Clean code organization following PEP 8
- Comprehensive documentation

This implementation provides a robust foundation for managing project outlines, combining traditional project management principles with AI-powered insights for enhanced project planning and tracking.

The key elements to focus on when designing these prompts are:

Clarity
Ensuring instructions are unambiguous and specific is crucial for effective prompt engineering. Here's a detailed breakdown of key practices:

Precise language and terminology is essential when crafting prompts. This means choosing words that have clear, specific meanings rather than vague or ambiguous terms. It's important to use industry-standard terminology when applicable to avoid confusion, and maintain consistency with terminology throughout your prompts.

Concrete examples play a vital role in effective prompt engineering. Include relevant, real-world examples that clearly illustrate your requirements. It's helpful to show both good and bad examples to highlight important distinctions, and ensure that examples are appropriate for your target audience's expertise level.

When it comes to output formats, clarity is key. You should specify exact structure requirements, whether that's JSON, markdown, or bullet points. Including sample outputs that show the desired formatting helps eliminate ambiguity, and defining any special formatting rules or conventions ensures consistency in the results.

Finally, setting clear parameters and constraints helps guide the output effectively. This involves establishing specific boundaries for length, scope, and content, defining any technical limitations or requirements, and specifying any forbidden elements or approaches to avoid.

Structure
Maintaining logical flow and hierarchical organization requires several key strategies. First, establishing clear sections and subsections is essential. This involves breaking down content into distinct main topics, creating logical subdivisions within each section, and using consistent heading levels to show relationships between different parts of the content.

The implementation of consistent formatting guidelines is equally important. This means defining standard styles for different types of content, maintaining uniform spacing and alignment throughout documents, and using consistent font styles and sizes for similar elements to ensure visual coherence.

Standardized labeling systems play a crucial role in organization. These systems should include clear naming conventions for sections, systematic numbering or coding schemes, and descriptive, meaningful labels that help users navigate through the content efficiently.

Finally, developing coherent information hierarchies ensures optimal content structure. This involves arranging information from general to specific concepts, grouping related information in a logical manner, and establishing clear parent-child relationships between different concepts. These hierarchical relationships help users understand how different pieces of information relate to each other.

When implementing these elements, be specific in your requirements. For summaries, explicitly state the desired length (e.g., "200 words"), key points to highlight, and preferred format (e.g., bullet points vs. paragraphs). For to-do lists, clearly indicate priority levels (high/medium/low), specific deadlines, and task dependencies. With project outlines, define the scope with measurable objectives, establish concrete timelines, and specify the required level of detail for each component.

This meticulous attention to detail in prompt design ensures that the AI's output is not only practical and immediately actionable but also consistently formatted and easily integrated into existing productivity workflows.

5.3.3 Prompt Templates for Customer Support

In customer support scenarios, clear and empathetic communication is crucial. Your prompts should instruct the assistant to address issues thoroughly, provide troubleshooting steps, or respond to inquiries in a friendly manner. Let's explore these essential components in detail:

First, the prompt should guide the AI to acknowledge the customer's concern with empathy, showing understanding of their frustration or difficulty. This means teaching the AI to recognize emotional cues in customer messages and respond appropriately. For example, if a customer expresses frustration about a failed payment, the AI should first acknowledge this frustration before moving to solutions: "I understand how frustrating payment issues can be, especially when you're trying to complete an important transaction." This helps establish a positive rapport from the start and shows the customer they're being heard.

Second, responses should be structured clearly, with a logical flow from acknowledgment to resolution. This means breaking down complex solutions into manageable steps and using clear, jargon-free language that any customer can understand. Each step should be numbered or clearly separated, with specific actions the customer can take. For instance, instead of saying "check your cache," the AI should say "Open your browser settings by clicking the three dots in the top right corner, then select 'Clear browsing data.'" This level of detail ensures customers can follow instructions without confusion.

Third, the prompt should emphasize the importance of thoroughness - ensuring all aspects of the customer's issue are addressed, while maintaining a balance between being comprehensive and concise. This includes anticipating follow-up questions and providing relevant additional information. The AI should be trained to identify related issues that might arise and proactively address them. For example, when helping with login issues, the AI might not only solve the immediate password reset problem but also explain two-factor authentication setup and security best practices.

Finally, the tone should remain consistently professional yet friendly throughout the interaction, making customers feel valued while maintaining the company's professional standards. This includes using positive language, offering reassurance, and ending with clear next steps or an invitation for further questions if needed. The AI should be guided to use phrases that build confidence ("I'll help you resolve this"), show proactiveness ("Let me check that for you"), and maintain engagement ("Is there anything else you'd like me to clarify?"). The language should be warm but not overly casual, striking a balance between approachability and professionalism.

Example: Response to a Support Inquiry

For instance, you might want the assistant to help respond to a customer who is having trouble with their account login.

Template:

import openai
import os
from dotenv import load_dotenv

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

messages = [
    {"role": "system", "content": "You are a courteous and knowledgeable customer support assistant."},
    {"role": "user", "content": (
        "A customer says: 'I'm unable to log into my account even after resetting my password. "
        "What steps can I take to resolve this issue? Please provide a friendly response with troubleshooting steps.'"
    )}
]

response = openai.ChatCompletion.create(
    model="gpt-4o",
    messages=messages,
    max_tokens=150,
    temperature=0.5
)

print("Customer Support Response Example:")
print(response["choices"][0]["message"]["content"])

Let me break down this example code, which demonstrates a simple customer support chat implementation:

1. Setup and Configuration

Uses the OpenAI and dotenv libraries to manage API access
Loads environment variables to securely handle the API key

2. Message Structure

Creates a messages array with two components:
- A system message that defines the AI's role as a customer support assistant
- A user message containing the customer's login issue and request for help

3. API Call Configuration

Makes a call to OpenAI's ChatCompletion API with specific parameters:
- Uses the GPT-4 model
- Sets a token limit of 150
- Uses a temperature of 0.5 (balancing creativity and consistency)

4. Output Handling

The code prints the response as a "Customer Support Response Example"

This prompt instructs the assistant to be empathetic and to present clear troubleshooting steps, ensuring a positive customer experience. It not only addresses the customer’s specific problem but also maintains a warm tone.

Example: Support Response Template

# customer_support_templates.py
from dataclasses import dataclass
from datetime import datetime
from typing import List, Dict, Optional
import openai
import logging

@dataclass
class CustomerQuery:
    query_id: str
    customer_name: str
    issue_type: str
    description: str
    timestamp: datetime
    priority: str

class CustomerSupportSystem:
    def __init__(self, api_key: str):
        self.api_key = api_key
        openai.api_key = self.api_key
        self.templates: Dict[str, str] = self._load_templates()
        
    def _load_templates(self) -> Dict[str, str]:
        return {
            "login_issues": """
                Please help the customer with their login issue.
                Key points to address:
                - Express understanding of their frustration
                - Provide clear step-by-step troubleshooting
                - Include security best practices
                - Offer additional assistance
                Context: {context}
                Customer query: {query}
            """,
            "billing_issues": """
                Address the customer's billing concern.
                Key points to cover:
                - Acknowledge the payment problem
                - Explain the situation clearly
                - Provide resolution steps
                - Detail prevention measures
                Context: {context}
                Customer query: {query}
            """
        }
    
    def generate_response(self, query: CustomerQuery) -> str:
        template = self.templates.get(query.issue_type, self.templates["general"])
        
        messages = [
            {
                "role": "system",
                "content": "You are an empathetic customer support specialist. Maintain a professional yet friendly tone."
            },
            {
                "role": "user",
                "content": template.format(
                    context=f"Customer: {query.customer_name}, Priority: {query.priority}",
                    query=query.description
                )
            }
        ]
        
        try:
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=300,
                temperature=0.7
            )
            return response.choices[0].message.content
        except Exception as e:
            logging.error(f"Error generating response: {e}")
            return "We apologize, but we're experiencing technical difficulties. Please try again later."

def main():
    # Example usage
    support_system = CustomerSupportSystem("your-api-key")
    
    # Sample customer query
    query = CustomerQuery(
        query_id="QRY123",
        customer_name="John Doe",
        issue_type="login_issues",
        description="I can't log in after multiple password reset attempts",
        timestamp=datetime.now(),
        priority="high"
    )
    
    # Generate response
    response = support_system.generate_response(query)
    print(f"Generated Response:\n{response}")

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Core Components and Structure
- Uses dataclass CustomerQuery for structured query representation
- Implements a CustomerSupportSystem class for centralized support operations
- Maintains a template dictionary for different types of customer issues
Key Features
- Template-based response generation with context awareness
- Priority-based handling of customer queries
- Flexible template system for different issue types
- Error handling and logging mechanisms
Advanced Capabilities
- Dynamic template formatting with customer context
- Customizable response parameters (temperature, token limit)
- Extensible template system for new issue types
- Professional response generation with consistent tone
Best Practices Implementation
- Type hints for better code maintenance
- Proper error handling with logging
- Clean code organization following PEP 8
- Modular design for easy expansion

This implementation provides a robust foundation for managing customer support responses, combining template-based structure with AI-powered personalization to ensure consistent, helpful, and empathetic customer communication.

5.3.4 Final Thoughts on Prompt Templates

Prompt templates serve as crucial building blocks in creating effective AI interactions. These templates act as standardized frameworks that bridge the gap between user intent and AI responses in several important ways:

First, they establish a consistent communication protocol. By providing structured formats for inputs and outputs, templates ensure that every interaction follows established patterns. This standardization is particularly valuable when multiple team members or departments are working with the same AI system, as it maintains uniformity in how information is requested and received.

Second, templates significantly reduce ambiguity in AI interactions. They guide users to provide necessary context and parameters upfront, preventing misunderstandings and reducing the need for clarifying follow-up questions. This clarity leads to more accurate and relevant responses from the AI system.

Third, well-designed templates are inherently scalable. As your application grows, these templates can be easily replicated, modified, or extended to handle new use cases while maintaining consistency with existing functionality. This scalability is essential for growing organizations that need to maintain quality while expanding their AI capabilities.

The examples we've explored throughout this chapter demonstrate the versatility of prompt templates across different scenarios. From assisting developers with code debugging to streamlining daily task management and enhancing customer support interactions, each template can be customized to address specific needs while maintaining core best practices.

Ultimately, effective prompt templates are the foundation for creating reliable, high-quality AI interactions. They not only set the stage for targeted responses but also ensure that these responses remain consistent, scalable, and aligned with your organization's objectives. Whether you're building a small application or a large-scale AI system, investing time in developing robust prompt templates will pay dividends in the quality and consistency of your AI interactions.

5.3 Prompt Templates: Coding, Productivity, Customer Support

Prompt templates are carefully designed, pre-formulated instructions that serve as blueprints for AI interactions. These templates act as structured frameworks that guide AI models to generate responses in a consistent, predictable, and desired format. Think of them as recipe cards - they contain all the necessary ingredients and steps to produce the exact output you need.

The power of prompt templates lies in their ability to:

Standardize Communication: They ensure every interaction follows a predetermined pattern
Improve Efficiency: By eliminating the need to craft new prompts for similar requests
Enhance Quality: Through carefully worded instructions that prevent common mistakes
Save Time: By reducing the trial-and-error process in prompt engineering

In this section, we'll explore three essential categories of prompt templates that form the backbone of many AI applications:

Coding – For programming help, debugging, or code generation
- Includes syntax correction, code optimization, and architectural guidance
- Helps maintain consistent coding standards and best practices
Productivity – For generating summaries, to-do lists, or scheduling insights
- Facilitates better time management and task organization
- Helps create clear, actionable items from complex information
Customer Support – For addressing inquiries, providing troubleshooting steps, or responding to customer feedback
- Ensures consistent, professional communication with customers
- Maintains brand voice while delivering helpful solutions

Let's explore each category with detailed examples.

5.3.1 Prompt Templates for Coding

When building AI-powered coding assistants or tutoring systems, clarity is absolutely essential for effective results. Your prompt template serves as the foundation for all interactions, so it must be meticulously crafted with several key elements. Let's explore each element in detail to understand their importance and implementation:

First, it should clearly define the task at hand - whether that's code review, bug fixing, or concept explanation. This definition needs to be specific enough that the AI understands exactly what type of assistance is required. For example, instead of saying "review this code," specify "review this Python function for potential memory leaks and suggest optimizations for better performance." This level of specificity helps the AI provide more targeted and valuable assistance.

Second, the template must specify any important constraints or requirements, such as programming language, coding style guidelines, or performance considerations. These constraints help ensure the AI's response stays within useful parameters. For instance, you might specify:

Programming language version (e.g., "Python 3.9+")
- Style guide requirements (e.g., "PEP 8 compliant")
- Performance targets (e.g., "optimize for memory usage over speed")
- Project-specific conventions (e.g., "follow company naming conventions")

Finally, including a relevant example in your template can significantly improve the quality of responses. This example serves as a concrete reference point, showing the AI exactly what kind of output you're looking for. For instance, when asking for code optimization, providing a sample of the current code structure helps the AI understand your coding style and maintain consistency. A good example should include:

Context about the code's purpose and environment
Any existing documentation or comments
Related functions or dependencies
Expected input/output behaviors
Current performance metrics or issues

Example: Debugging Assistance

Imagine you want the AI to help debug a piece of Python code. Your prompt might provide context, show the code snippet, and ask specific questions about potential errors.

Template:

import openai
import os
from dotenv import load_dotenv
import logging
from typing import Optional

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def setup_openai_client() -> bool:
    """Initialize OpenAI client with API key from environment."""
    try:
        load_dotenv()
        openai.api_key = os.getenv("OPENAI_API_KEY")
        if not openai.api_key:
            raise ValueError("OpenAI API key not found")
        return True
    except Exception as e:
        logger.error(f"Failed to initialize OpenAI client: {e}")
        return False

def factorial(n: int) -> Optional[int]:
    """
    Calculate the factorial of a non-negative integer.
    
    Args:
        n (int): The number to calculate factorial for
        
    Returns:
        Optional[int]: The factorial result or None if input is invalid
        
    Raises:
        RecursionError: If input is too large
        ValueError: If input is negative
    """
    try:
        if not isinstance(n, int):
            raise TypeError("Input must be an integer")
        if n < 0:
            raise ValueError("Input must be non-negative")
        if n == 0:
            return 1
        else:
            return n * factorial(n - 1)  # Fixed recursion
    except Exception as e:
        logger.error(f"Error calculating factorial: {e}")
        return None

def get_debugging_assistance(code_snippet: str) -> str:
    """
    Get AI assistance for debugging code.
    
    Args:
        code_snippet (str): The problematic code to debug
        
    Returns:
        str: AI's debugging suggestions
    """
    if not setup_openai_client():
        return "Failed to initialize OpenAI client"

    messages = [
        {"role": "system", "content": "You are a knowledgeable and patient coding assistant."},
        {"role": "user", "content": (
            f"I have the following Python code that needs debugging:\n\n"
            f"{code_snippet}\n\n"
            "Please identify any bugs and suggest fixes."
        )}
    ]

    try:
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=messages,
            max_tokens=200,
            temperature=0.5
        )
        return response["choices"][0]["message"]["content"]
    except Exception as e:
        logger.error(f"Error getting OpenAI response: {e}")
        return f"Failed to get debugging assistance: {str(e)}"

def main():
    # Example usage
    test_cases = [5, 0, -1, "invalid", 10]
    
    for test in test_cases:
        print(f"\nTesting factorial({test})")
        try:
            result = factorial(test)
            print(f"Result: {result}")
        except Exception as e:
            print(f"Error: {e}")

    # Example of getting debugging assistance
    problematic_code = """
    def factorial(n):
        if n == 0:
            return 1
        else:
            return n * factorial(n)  # Bug: infinite recursion
    """
    
    print("\nGetting debugging assistance:")
    assistance = get_debugging_assistance(problematic_code)
    print(assistance)

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Structure and Organization
- Imports are grouped logically and include type hints and logging
- Functions are well-documented with docstrings
- Error handling is implemented throughout
Key Components
- setup_openai_client(): Handles API initialization safely
- factorial(): Improved with type hints and error handling
- get_debugging_assistance(): Encapsulates AI interaction logic
- main(): Demonstrates usage with various test cases
Improvements Over Original
- Added comprehensive error handling
- Included type hints for better code clarity
- Implemented logging for debugging
- Added test cases to demonstrate different scenarios
Best Practices Demonstrated
- Function separation for better maintainability
- Proper documentation and comments
- Robust error handling and logging
- Type hints for better code clarity

In this template, the prompt clearly sets expectations by indicating the AI’s role and providing the exact problem. This helps the assistant diagnose issues effectively.

5.3.2 Prompt Templates for Productivity

For productivity applications, your prompts need to be carefully designed to generate different types of organizational content. These templates should be structured to handle three main categories of productivity tools:

1. Detailed Summaries

These should condense complex information into digestible formats while preserving essential meaning. When crafting prompts for summaries, consider:

Key information extraction techniques
- Using semantic analysis to identify main concepts
- Implementing keyword recognition for important points
- Applying natural language processing to detect key themes
Hierarchical organization of main points and supporting details
- Creating clear primary, secondary, and tertiary levels of information
- Establishing logical connections between related points
- Using consistent formatting to indicate information hierarchy
Methods for maintaining context while reducing length
- Preserving critical contextual information
- Using concise language without sacrificing clarity
- Implementing effective transition phrases to maintain flow

Example: Detailed Summary Generator

import openai
import os
from dotenv import load_dotenv
from typing import Dict, List, Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class SummaryGenerator:
    def __init__(self):
        """Initialize the SummaryGenerator with OpenAI credentials."""
        load_dotenv()
        self.api_key = os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OpenAI API key not found in environment")
        openai.api_key = self.api_key

    def extract_key_points(self, text: str) -> List[str]:
        """
        Extract main points from the input text using semantic analysis.
        
        Args:
            text (str): Input text to analyze
            
        Returns:
            List[str]: List of key points extracted from the text
        """
        try:
            messages = [
                {"role": "system", "content": "You are a precise summarization assistant. Extract only the main points from the following text."},
                {"role": "user", "content": text}
            ]
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=150,
                temperature=0.3
            )
            
            return response.choices[0].message.content.split('\n')
        except Exception as e:
            logger.error(f"Error extracting key points: {e}")
            return []

    def generate_hierarchical_summary(self, text: str, max_length: int = 500) -> Dict[str, any]:
        """
        Generate a structured summary with hierarchical organization.
        
        Args:
            text (str): Input text to summarize
            max_length (int): Maximum length of the summary
            
        Returns:
            Dict: Structured summary with main points and supporting details
        """
        try:
            messages = [
                {"role": "system", "content": (
                    "Create a hierarchical summary with the following structure:\n"
                    "1. Main points (maximum 3)\n"
                    "2. Supporting details for each point\n"
                    "3. Key takeaways"
                )},
                {"role": "user", "content": f"Summarize this text in {max_length} characters:\n{text}"}
            ]
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=300,
                temperature=0.4
            )
            
            return {
                "summary": response.choices[0].message.content,
                "length": len(response.choices[0].message.content),
                "timestamp": datetime.now().isoformat()
            }
        except Exception as e:
            logger.error(f"Error generating summary: {e}")
            return {"error": str(e)}

    def format_summary(self, summary_dict: Dict[str, any]) -> str:
        """
        Format the summary into a readable structure.
        
        Args:
            summary_dict (Dict): Dictionary containing summary information
            
        Returns:
            str: Formatted summary
        """
        if "error" in summary_dict:
            return f"Error generating summary: {summary_dict['error']}"
            
        formatted_output = [
            "# Summary Report",
            f"Generated on: {summary_dict['timestamp']}",
            f"Length: {summary_dict['length']} characters\n",
            summary_dict['summary']
        ]
        
        return "\n".join(formatted_output)

def main():
    # Example usage
    sample_text = """
    Artificial Intelligence has transformed various industries, from healthcare to finance.
    Machine learning algorithms now power recommendation systems, fraud detection, and
    medical diagnosis. Deep learning, a subset of AI, has particularly excelled in image
    and speech recognition tasks. However, these advances also raise important ethical
    considerations regarding privacy and bias in AI systems.
    """
    
    summarizer = SummaryGenerator()
    
    # Generate and display summary
    summary = summarizer.generate_hierarchical_summary(sample_text)
    formatted_summary = summarizer.format_summary(summary)
    print(formatted_summary)

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Class Structure and Organization
- SummaryGenerator class encapsulates all summary-related functionality
- Clear separation of concerns with distinct methods for different tasks
- Proper error handling and logging throughout the code
Key Components
- extract_key_points(): Uses semantic analysis to identify main concepts
- generate_hierarchical_summary(): Creates structured summaries with clear hierarchy
- format_summary(): Converts raw summary data into readable output
Advanced Features
- Type hints for better code clarity and maintainability
- Configurable summary length and structure
- Timestamp tracking for summary generation
- Error handling with detailed logging
Best Practices Demonstrated
- Environment variable management for API keys
- Comprehensive documentation with docstrings
- Modular design for easy testing and maintenance
- Clean code structure following PEP 8 guidelines

This example demonstrates a production-ready approach to generating detailed summaries, with proper error handling, logging, and a clear structure that can be easily integrated into larger applications.

2. To-Do Lists

These break down tasks into manageable steps. Effective to-do list prompts should incorporate:

Task prioritization mechanisms
- High/Medium/Low priority flags to identify critical tasks
- Urgency indicators based on deadlines and impact
- Dynamic reprioritization based on changing circumstances
Time estimation guidelines
- Realistic time frames for task completion
- Buffer periods for unexpected delays
- Effort-based estimations (e.g., quick wins vs. complex tasks)
Dependency mapping between tasks
- Clear identification of prerequisites
- Sequential vs. parallel task relationships
- Critical path analysis for complex projects
Progress tracking indicators
- Percentage completion metrics
- Milestone checkpoints
- Status updates (Not Started, In Progress, Completed)

Example: Task Management System

import openai
import os
from datetime import datetime, timedelta
from typing import List, Dict, Optional
from enum import Enum
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

class TaskStatus(Enum):
    NOT_STARTED = "not_started"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"

class Task:
    def __init__(
        self,
        title: str,
        description: str,
        priority: Priority,
        due_date: datetime,
        estimated_hours: float
    ):
        self.title = title
        self.description = description
        self.priority = priority
        self.due_date = due_date
        self.estimated_hours = estimated_hours
        self.status = TaskStatus.NOT_STARTED
        self.completion_percentage = 0
        self.dependencies: List[Task] = []
        self.created_at = datetime.now()

class TodoListManager:
    def __init__(self):
        """Initialize TodoListManager with OpenAI credentials."""
        load_dotenv()
        self.api_key = os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OpenAI API key not found")
        openai.api_key = self.api_key
        self.tasks: List[Task] = []

    def add_task(self, task: Task) -> None:
        """Add a new task to the list."""
        self.tasks.append(task)
        logger.info(f"Added task: {task.title}")

    def update_task_status(
        self,
        task: Task,
        status: TaskStatus,
        completion_percentage: int
    ) -> None:
        """Update task status and completion percentage."""
        task.status = status
        task.completion_percentage = min(100, max(0, completion_percentage))
        logger.info(f"Updated task {task.title}: {status.value}, {completion_percentage}%")

    def add_dependency(self, task: Task, dependency: Task) -> None:
        """Add a dependency to a task."""
        if dependency not in task.dependencies:
            task.dependencies.append(dependency)
            logger.info(f"Added dependency {dependency.title} to {task.title}")

    def get_priority_tasks(self, priority: Priority) -> List[Task]:
        """Get all tasks of a specific priority."""
        return [task for task in self.tasks if task.priority == priority]

    def get_overdue_tasks(self) -> List[Task]:
        """Get all overdue tasks."""
        now = datetime.now()
        return [
            task for task in self.tasks
            if task.due_date < now and task.status != TaskStatus.COMPLETED
        ]

    def generate_task_summary(self) -> str:
        """Generate a summary of all tasks using AI."""
        try:
            tasks_text = "\n".join(
                f"- {task.title} ({task.priority.value}, {task.completion_percentage}%)"
                for task in self.tasks
            )

            messages = [
                {"role": "system", "content": "You are a task management assistant."},
                {"role": "user", "content": f"Generate a brief summary of these tasks:\n{tasks_text}"}
            ]

            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=150,
                temperature=0.3
            )

            return response.choices[0].message.content
        except Exception as e:
            logger.error(f"Error generating task summary: {e}")
            return "Unable to generate summary at this time."

def main():
    # Example usage
    todo_manager = TodoListManager()

    # Create sample tasks
    task1 = Task(
        "Implement user authentication",
        "Add OAuth2 authentication to the API",
        Priority.HIGH,
        datetime.now() + timedelta(days=2),
        8.0
    )

    task2 = Task(
        "Write unit tests",
        "Create comprehensive test suite",
        Priority.MEDIUM,
        datetime.now() + timedelta(days=4),
        6.0
    )

    # Add tasks and dependencies
    todo_manager.add_task(task1)
    todo_manager.add_task(task2)
    todo_manager.add_dependency(task2, task1)

    # Update task status
    todo_manager.update_task_status(task1, TaskStatus.IN_PROGRESS, 50)

    # Generate and print summary
    summary = todo_manager.generate_task_summary()
    print("\nTask Summary:")
    print(summary)

if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Class Structure and Design
- Task class encapsulates all task-related attributes and metadata
- TodoListManager handles task operations and AI interactions
- Enum classes provide type safety for Priority and TaskStatus
Key Features
- Comprehensive task tracking with priorities and dependencies
- Progress monitoring with completion percentages
- AI-powered task summarization capability
- Robust error handling and logging
Advanced Functionality
- Dependency management between tasks
- Overdue task identification
- Priority-based task filtering
- AI-generated task summaries
Best Practices Implemented
- Type hints for better code clarity
- Comprehensive error handling
- Proper logging implementation
- Clean, modular code structure

This implementation demonstrates a production-ready task management system that combines traditional to-do list functionality with AI-powered features for enhanced productivity.

3. Project Outlines

These map out objectives and milestones, providing a comprehensive roadmap for project success. Your prompts should address:

Project scope definition
- Clear objectives and deliverables
- Project boundaries and limitations
- Key stakeholder requirements
Timeline creation and management
- Major milestone identification
- Task sequencing and dependencies
- Deadline setting and tracking methods
Resource allocation considerations
- Team member roles and responsibilities
- Budget distribution and tracking
- Equipment and tool requirements
Risk assessment factors
- Potential obstacles and challenges
- Mitigation strategies
- Contingency planning approaches

Example: Project Management System

import openai
import os
from datetime import datetime, timedelta
from typing import List, Dict, Optional
from enum import Enum
import logging
from dataclasses import dataclass

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class Milestone:
    title: str
    due_date: datetime
    description: str
    completion_status: float = 0.0
    
class ProjectStatus(Enum):
    PLANNING = "planning"
    IN_PROGRESS = "in_progress"
    ON_HOLD = "on_hold"
    COMPLETED = "completed"

class ProjectOutlineManager:
    def __init__(self):
        """Initialize ProjectOutlineManager with OpenAI configuration."""
        self.api_key = os.getenv("OPENAI_API_KEY")
        if not self.api_key:
            raise ValueError("OpenAI API key not found")
        openai.api_key = self.api_key
        
        self.objectives: List[str] = []
        self.milestones: List[Milestone] = []
        self.resources: Dict[str, List[str]] = {}
        self.risks: List[Dict[str, str]] = []
        self.status = ProjectStatus.PLANNING
        
    def add_objective(self, objective: str) -> None:
        """Add a project objective."""
        self.objectives.append(objective)
        logger.info(f"Added objective: {objective}")
        
    def add_milestone(self, milestone: Milestone) -> None:
        """Add a project milestone."""
        self.milestones.append(milestone)
        logger.info(f"Added milestone: {milestone.title}")
        
    def add_resource(self, category: str, resource: str) -> None:
        """Add a resource under a specific category."""
        if category not in self.resources:
            self.resources[category] = []
        self.resources[category].append(resource)
        logger.info(f"Added {resource} to {category}")
        
    def add_risk(self, risk: str, mitigation: str) -> None:
        """Add a risk and its mitigation strategy."""
        self.risks.append({"risk": risk, "mitigation": mitigation})
        logger.info(f"Added risk: {risk}")
        
    def generate_project_summary(self) -> str:
        """Generate an AI-powered project summary."""
        try:
            project_details = {
                "objectives": self.objectives,
                "milestones": [f"{m.title} (Due: {m.due_date})" for m in self.milestones],
                "resources": self.resources,
                "risks": self.risks,
                "status": self.status.value
            }
            
            messages = [
                {"role": "system", "content": "You are a project management assistant."},
                {"role": "user", "content": f"Generate a concise summary of this project:\n{project_details}"}
            ]
            
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=messages,
                max_tokens=200,
                temperature=0.3
            )
            
            return response.choices[0].message.content
        except Exception as e:
            logger.error(f"Error generating project summary: {e}")
            return "Unable to generate summary at this time."
            
    def export_outline(self) -> Dict:
        """Export the project outline in a structured format."""
        return {
            "status": self.status.value,
            "objectives": self.objectives,
            "milestones": [
                {
                    "title": m.title,
                    "due_date": m.due_date.isoformat(),
                    "description": m.description,
                    "completion": m.completion_status
                }
                for m in self.milestones
            ],
            "resources": self.resources,
            "risks": self.risks,
            "last_updated": datetime.now().isoformat()
        }

def main():
    # Example usage
    project_manager = ProjectOutlineManager()
    
    # Add objectives
    project_manager.add_objective("Develop a scalable web application")
    project_manager.add_objective("Launch beta version within 3 months")
    
    # Add milestones
    milestone1 = Milestone(
        "Complete Backend API",
        datetime.now() + timedelta(days=30),
        "Implement RESTful API endpoints"
    )
    project_manager.add_milestone(milestone1)
    
    # Add resources
    project_manager.add_resource("Development Team", "Frontend Developer")
    project_manager.add_resource("Development Team", "Backend Developer")
    project_manager.add_resource("Tools", "AWS Cloud Services")
    
    # Add risks
    project_manager.add_risk(
        "Technical debt accumulation",
        "Regular code reviews and refactoring sessions"
    )
    
    # Generate and display summary
    summary = project_manager.generate_project_summary()
    print("\nProject Summary:")
    print(summary)
    
if __name__ == "__main__":
    main()

Code Breakdown Explanation:

Core Structure and Design
- Uses dataclasses for clean data structure representation
- Implements Enum for project status tracking
- Centralizes project management functionality in ProjectOutlineManager
Key Components
- Milestone tracking with due dates and completion status
- Resource management categorized by department/type
- Risk assessment with mitigation strategies
- AI-powered project summary generation
Advanced Features
- Structured data export functionality
- Comprehensive logging system
- Error handling for AI interactions
- Flexible resource categorization
Best Practices Implemented
- Type hints for improved code maintainability
- Proper error handling and logging
- Clean code organization following PEP 8
- Comprehensive documentation