{"id":29919,"date":"2024-10-01T09:30:00","date_gmt":"2024-10-01T07:30:00","guid":{"rendered":"https:\/\/www.codemotion.com\/magazine\/?p=29919"},"modified":"2024-10-01T19:05:14","modified_gmt":"2024-10-01T17:05:14","slug":"generative-ai-prompt-patterns-for-software-engineering","status":"publish","type":"post","link":"https:\/\/www.codemotion.com\/magazine\/ai-ml\/generative-ai-prompt-patterns-for-software-engineering\/","title":{"rendered":"Generative AI Prompt Patterns for Software Engineering"},"content":{"rendered":"\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\tTable Of Contents\t\t\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
  1. Introduction<\/a>
  2. Integrating Generative AI into Development Workflows<\/a>
  3. 1. Full-Context Code Analysis Pattern<\/a>
  4. 2. LLM Method Replacement Pattern<\/a>
  5. 3. Context Reducer Pattern<\/a>
  6. 4. Comments Replacement Pattern<\/a>
  7. Conclusion<\/a>
  8. Davide Consonni<\/a><\/ol>\t\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\n\n\n

    Introduction<\/strong><\/h2>\n\n\n\n

    The role of developers is changing rapidly. Those who aren\u2019t ready for this AI-powered future risk becoming extinct, like the Dodo \ud83e\udda4.<\/strong> As Large Language Models (LLMs) improve in their ability to write code, with lower costs and larger context windows, we\u2019re nearing a shift towards Generative AI-driven programming. In this new approach, developers may move away from directly writing code and focus more on being Prompt Engineers and Code Reviewers.<\/p>\n\n\n\n

    In this article, we\u2019ll explore some key Generative AI Prompt Patterns<\/strong> that are shaping the future of software engineering. These patterns represent innovative techniques designed to optimize the interaction between developers and LLMs, streamlining the development process and enhancing code quality.<\/p>\n\n\n\n

    Integrating Generative AI into Development Workflows<\/strong><\/h2>\n\n\n\n

    Before diving into specific Generative AI patterns, it\u2019s crucial to understand how to integrate these powerful tools into your development process effectively. While not all patterns require extended context windows, some advanced techniques significantly benefit from this capability. Moreover, for AI to be truly effective in coding tasks, the chosen models must excel at code generation and understanding.<\/p>\n\n\n\n

    For robust and scalable AI integration, I strongly recommend using a native, managed cloud service like AWS Bedrock<\/strong>. Such services offer superior reliability, built-in scalability, and simplified management, allowing developers to focus on leveraging AI capabilities rather than maintaining infrastructure. Here\u2019s an example of how to integrate a high-performing LLM, such as Claude 3.5 Sonnet<\/a><\/strong> via AWS Bedrock, into your workflow:<\/p>\n\n\n

    import boto3\nimport json\nfrom tenacity import retry, stop_after_attempt, wait_exponential\n\n@retry(stop=stop_after_attempt(5<\/span>), wait=wait_exponential(multiplier=1<\/span>, min=4<\/span>, max=10<\/span>))\ndef call_claude(prompt, max_tokens=1000<\/span>):\n    bedrock = boto3.client('bedrock-runtime'<\/span>)\n    body = json.dumps({\n        \"prompt\"<\/span>: prompt,\n        \"max_tokens_to_sample\"<\/span>: max_tokens,\n        \"temperature\"<\/span>: 0.0<\/span>\n    })\n    response = bedrock.invoke_model(\n        body=body,\n        modelId=\"anthropic.claude-3-5-sonnet-20240620-v1:0\"<\/span>,\n        contentType=\"application\/json\"<\/span>\n    )\n    return<\/span> json.loads(response['body'<\/span>].read())['completion'<\/span>]\n\n# Usage example for code generation<\/span>\ncode_generation_prompt = \"\"<\/span>\"\n...\n\"<\/span>\"\"<\/span>\ngenerated_code = call_claude(code_generation_prompt)\nprint<\/span>(generated_code)\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    This implementation showcases best practices for integrating AI into your development workflow. The @retry decorator implements exponential backoff, enhancing resilience against transient errors. This approach is crucial when working with external AI services, ensuring robust performance even in the face of temporary network issues or service interruptions.<\/p>\n\n\n\n
    By leveraging AWS Bedrock, you benefit from a managed service that handles the complexities of scaling, security, and maintenance. This allows you to focus on implementing and refining your AI-driven development patterns without worrying about the underlying infrastructure.<\/p>\n\n\n\n
    As you develop, it\u2019s vital to understand the strengths of the LLM you\u2019re working with and how they align with your project\u2019s needs. The combination of cutting-edge AI models and the reliability of cloud services like Bedrock gives you the perfect foundation for building advanced AI-driven solutions into your software, without the typical hassle.<\/p>\n\n\n\n
    1. Full-Context Code Analysis Pattern<\/strong><\/h2>\n\n\n\n
    Leveraging comprehensive codebase understanding for precise AI assistance<\/em><\/p>\n\n\n\n
    This pattern involves inserting the entire codebase or a complete microservice into the prompt, providing the LLM with a comprehensive view of the application. This approach enables more accurate and context-aware responses.<\/p>\n\n\n\n
    One particularly powerful use of this pattern is for microservices <\/strong>under 1,000 lines of code. By inserting the entire codebase or a complete microservice into the prompt, you provide the LLM with a full view of the application, leading to more accurate, context-aware responses. This is a game-changer for small, self-contained services where a holistic understanding is essential for generating precise and useful output.<\/p>\n\n\n\n
    Input:<\/strong><\/p>\n\n\n\n
    # [Entire microservice code is pasted here]
    <\/strong>
    Please implement a new GET API endpoint in this microservice with the following requirements:
    1. The endpoint should return a list of book objects. Each book object should contain:
      – id (UUID)
      – title (string)
      – author (string)
      – publication_year (integer)
      – genre (string)
    2. Implement pagination for this endpoint:
      – Accept ‘page’ and ‘size’ query parameters
      – Return appropriate metadata (total items, total pages, current page)
    3. Apply security measures similar to existing methods in the microservice
    4. Implement execution time measurement for this method and log it<\/p>\n\n\n\n
    Output:<\/strong> The LLM provides a complete implementation of the new endpoint, fully integrated with the existing codebase, including pagination, security measures, and execution time logging.Note:<\/strong> This pattern is often used in conjunction with the Context Reset Pattern, which involves pasting the entire current source code into the LLM chat and asking for confirmation before proceeding with specific queries. This ensures the LLM always has the most up-to-date version of the code.<\/p>\n\n\n\n
    2. LLM Method Replacement Pattern<\/strong><\/h2>\n\n\n\n
    Simplifying complex code with AI-generated solutions<\/em><\/p>\n\n\n\n
    This pattern involves replacing complex methods in software applications with LLM-driven solutions. It\u2019s particularly valuable for tasks that benefit from natural language processing capabilities and adaptability to changing requirements.<\/p>\n\n\n\n
    By leveraging LLMs, you can drastically simplify the readability and maintainability of the methods, making the codebase easier to understand and modify. To ensure reliability, it\u2019s recommended to validate both inputs and outputs, guaranteeing that the LLM\u2019s generated solutions meet the expected standards and integrate seamlessly into your application.<\/p>\n\n\n
    Input:\ndef extract_financial_data(text):\n    prompt = f\"\"<\/span>\"\n    Extract the following financial data from the given text:\n    - Revenue\n    - Net Income\n    - Earnings Per Share (EPS)\n    - Debt-to-Equity Ratio\n\n    Text: {text}\n\n    Return the results as a JSON object with the extracted values.\n    If a value is not found, use null.\n    \"<\/span>\"\"<\/span>\n\n    try<\/span>:\n        response = call_llm(prompt)\n        financial_data = json.loads(response)\n        \n        # Validate and process the extracted data<\/span>\n        for<\/span> key in ['Revenue'<\/span>, 'Net Income'<\/span>, 'EPS'<\/span>, 'Debt-to-Equity Ratio'<\/span>]:\n            if<\/span> key not in financial_data:\n                financial_data[key] = None\n        \n        return<\/span> financial_data\n    except Exception<\/span> as<\/span> e:\n        print<\/span>(f\"Error in LLM processing: {e}\"<\/span>)\n        return<\/span> None\n\n# Usage<\/span>\ntext = \"\"<\/span>\"\nIn the fiscal year 2023, XYZ Corp reported strong financial performance. \nThe company's revenue reached $10.5 billion, up 15% year-over-year. \nNet income increased to $2.1 billion, resulting in an earnings per share \n(EPS) of $4.20. The company maintained a healthy balance sheet with \na debt-to-equity ratio of 0.8.\n\"<\/span>\"\"<\/span>\n\nresult = extract_financial_data(text)\nprint<\/span>(json.dumps(result, indent=2<\/span>))<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/strong>
    <\/p>\n\n\n
    {\n  \"Revenue\"<\/span>: \"$10.5 billion\"<\/span>,\n  \"Net Income\"<\/span>: \"$2.1 billion\"<\/span>,\n  \"EPS\"<\/span>: \"$4.20\"<\/span>,\n  \"Debt-to-Equity Ratio\"<\/span>: \"0.8\"<\/span>\n}\n<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
    3. Context Reducer Pattern<\/strong><\/h2>\n\n\n\n
    Optimizing structured data generation for efficiency and cost-effectiveness<\/em><\/p>\n\n\n\n
    This pattern addresses the challenges of generating structured data with Generative AI, particularly when dealing with context limitations and output costs. It involves creating a condensed version of the data structure and expanding it in post-processing.<\/p>\n\n\n\n
    Input:<\/strong><\/p>\n\n\n
    unstructured_data = \"\"<\/span>\"\nJohn Doe, johndoe@email.com, 30 years old, residing in Germany, contact: \n+49 123 456789\nJane Smith, janesmith@email.com, 28 years old, residing in France, contact: \n+33 987 654321\nMike Johnson, mikej@email.com, 35 years old, residing in Spain, contact: \n+34 567 890123\n\"<\/span>\"\"<\/span>\n\nprompt = f\"\"<\/span>\"\nConvert the following unstructured user data into a reduced JSON structure \nusing these abbreviations:\nn: name\ne: email\na: age\nc: country\np: phone\n\nUnstructured data:\n{unstructured_data}\n\nGenerate the reduced JSON output for all users.\n\"<\/span>\"\"<\/span>\n\n# Generate the reduced JSON structure<\/span>\nresponse = call_llm(prompt)\n\ndef expand_keys(data):\n    key_mapping = {\"n\"<\/span>: \"name\"<\/span>, \"e\"<\/span>: \"email\"<\/span>, \"a\"<\/span>: \"age\"<\/span>, \"c\"<\/span>: \"country\"<\/span>, \n                   \"p\"<\/span>: \"phone\"<\/span>}\n    return<\/span> [{key_mapping.get(k, k): v for<\/span> k, v in item.items()} \n            for<\/span> item in data]\n\nreduced_data = json.loads(response)\nexpanded_data = expand_keys(reduced_data)\n\nprint<\/span>(\"\\nExpanded data:\"<\/span>)\nprint<\/span>(json.dumps(expanded_data, indent=2<\/span>))<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/strong>
    <\/p>\n\n\n
    [\n  {\n    \"name\"<\/span>: \"John Doe\"<\/span>,\n    \"email\"<\/span>: \"johndoe@email.com\"<\/span>,\n    \"age\"<\/span>: 30<\/span>,\n    \"country\"<\/span>: \"Germany\"<\/span>,\n    \"phone\"<\/span>: \"+49 123 456789\"<\/span>\n  },\n  {\n    \"name\"<\/span>: \"Jane Smith\"<\/span>,\n    \"email\"<\/span>: \"janesmith@email.com\"<\/span>,\n    \"age\"<\/span>: 28<\/span>,\n    \"country\"<\/span>: \"France\"<\/span>,\n    \"phone\"<\/span>: \"+33 987 654321\"<\/span>\n  },\n  {\n    \"name\"<\/span>: \"Mike Johnson\"<\/span>,\n    \"email\"<\/span>: \"mikej@email.com\"<\/span>,\n    \"age\"<\/span>: 35<\/span>,\n    \"country\"<\/span>: \"Spain\"<\/span>, \n    \"phone\"<\/span>: \"+34 567 890123\"<\/span>\n  }\n]\n<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
    4. Comments Replacement Pattern<\/strong><\/h2>\n\n\n\n
    Enhancing code readability in multilingual development environments<\/em><\/p>\n\n\n\n
    This pattern addresses the challenge of working with codebases containing comments in various languages. It leverages LLMs to translate and adapt comments to a desired language, improving code readability and maintainability.<\/p>\n\n\n\n
    When using LLMs for this task, generating a patch rather than directly rewriting the entire codebase helps minimize unnecessary changes. This reduces the output to only what\u2019s needed, keeping the process efficient. It\u2019s recommended to thoroughly review the patch to ensure that no unintended code modifications are made in the process.<\/p>\n\n\n\n
    Input:<\/strong><\/p>\n\n\n
    You are an expert polyglot programmer.\nYour task is to translate all comments in the following Python code\nfrom Japanese to English.\nMaintain the original comment structure and<\/span> enhance clarity where possible.\nGenerate a Git patch format output for<\/span> the changes.\n\ndef calculate_total(items):\n    # \u30a2\u30a4\u30c6\u30e0\u306e\u5408\u8a08\u91d1\u984d\u3092\u8a08\u7b97\u3059\u308b<\/span>\n    total = 0<\/span>\n    for<\/span> item in items:\n        # \u7a0e\u8fbc\u307f\u4fa1\u683c\u3092\u8a08\u7b97<\/span>\n        price_with_tax = item.price * 1.1<\/span>\n        total += price_with_tax\n    # \u5408\u8a08\u3092\u8fd4\u3059<\/span>\n    return<\/span> total\n# \u30e1\u30a4\u30f3\u51e6\u7406<\/span>\nif<\/span> __name__ == \"__main__\"<\/span>:\n    # \u30c6\u30b9\u30c8\u30c7\u30fc\u30bf<\/span>\n    test_items = [Item(100<\/span>), Item(200<\/span>), Item(300<\/span>)]\n    result = calculate_total(test_items)\n    print<\/span>(f\"\u5408\u8a08\u91d1\u984d: {result}\u5186\"<\/span>)\n\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/strong><\/p>\n\n\n
    diff --git a\/sample.py b\/sample.py\nindex abcdef1..ghijklm 100644<\/span>\n--- a\/sample.py\n+++ b\/sample.py\n@@ -1<\/span>,13<\/span> +1<\/span>,13<\/span> @@\n def calculate_total(items):\n-    # \u30a2\u30a4\u30c6\u30e0\u306e\u5408\u8a08\u91d1\u984d\u3092\u8a08\u7b97\u3059\u308b<\/span>\n+    # Calculate the total amount for all items<\/span>\n     total = 0<\/span>\n     for<\/span> item in items:\n-        # \u7a0e\u8fbc\u307f\u4fa1\u683c\u3092\u8a08\u7b97<\/span>\n+        # Calculate price including tax<\/span>\n         price_with_tax = item.price * 1.1<\/span>\n         total += price_with_tax\n-    # \u5408\u8a08\u3092\u8fd4\u3059<\/span>\n+    # Return the total<\/span>\n     return<\/span> total\n \n-# \u30e1\u30a4\u30f3\u51e6\u7406<\/span>\n+# Main process<\/span>\n if<\/span> __name__ == \"__main__\"<\/span>:\n-    # \u30c6\u30b9\u30c8\u30c7\u30fc\u30bf<\/span>\n+    # Test data<\/span>\n     test_items = [Item(100<\/span>), Item(200<\/span>), Item(300<\/span>)]\n     result = calculate_total(test_items)\n-    print<\/span>(f\"\u5408\u8a08\u91d1\u984d: {result}\u5186\"<\/span>)\n+    print<\/span>(f\"Total amount: {result} ye\u00f9n\"<\/span>)<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Conclusion<\/strong><\/h2>\n\n\n\n
    The patterns we\u2019ve explored represent just the tip of the iceberg in the rapidly evolving field of AI-assisted software development. As we continue to refine these techniques and develop new ones, we\u2019re witnessing a fundamental shift in how software is created and maintained.<\/p>\n\n\n\n
    At Capgemini<\/a>, we\u2019re committed to staying at the forefront of this AI revolution in software engineering. We believe that by embracing these patterns and continually innovating, we can create more efficient, robust, and adaptable software solutions for our clients.<\/p>\n\n\n\n
    As we move forward, it\u2019s crucial to remember that while AI is a powerful tool, it doesn\u2019t replace human creativity and judgment. The most effective approach is a synergy between human expertise and AI capabilities. By mastering these prompt patterns and remaining open to emerging techniques, developers can position themselves at the cutting edge of this exciting new frontier in technology.<\/p>\n\n\n\n
    The future of software engineering is one of human-AI collaboration, where our creativity and expertise are amplified by the capabilities of artificial intelligence. Are you ready to be part of this revolution?<\/p>\n\n\n\n
    \"Davide<\/figure><\/div><\/div>
    Davide Consonni<\/a><\/h2>
    Head of Cloud Native @Capgemini<\/a><\/p>
    Davide is the Head of Cloud Native at Capgemini, where he leads innovative cloud solutions and strategies. With extensive experience as a People Manager, Engagement Manager, and Cloud Architect, he specializes in optimizing business operations through cutting-edge technology.<\/em>

    Renowned for his expertise in cloud computing and project management, Davide is dedicated to helping organizations leverage cloud-native architectures. His insights will reshape your understanding of digital transformation and enhance your approach to cloud adoption.<\/em><\/div>