Understanding Code Generation

• Present the problem: application development is often slow and repetitive.
• Consider using foundation models to generate code and augment developer workflows.
• Share best practices for prompt design and demonstrate examples.
• Discuss risks, testing, and governance requirements.
• Summarize expected organizational outcomes and next steps.

​

The problem: slow application development

• Designing and implementing algorithms and functions.
• Writing boilerplate (project setup, configs, and common patterns).
• Searching documentation and examples to implement specific APIs.
• Ensuring code meets security and compliance requirements.
• Writing and maintaining unit and integration tests.
• Debugging, profiling, and performance tuning.
• Learning new languages and frameworks (e.g., Angular, React, Svelte, ORMs).

​

Solution: use foundation models to generate code

1. Author a clear prompt describing the desired artifact (function, module, or repository).
2. Specify the target language and execution environment (e.g., AWS Lambda, container, embedded device).
3. Invoke the foundation model (LLM) with the prompt.
4. Receive generated source code plus optional tests and documentation; then validate and iterate.

​

Where to integrate generative AI in your development workflow

• AI-first IDEs make the model the primary interface for generating and iterating code (e.g., Cursor, Claude Code).
• Plugins and extensions augment established IDEs to add code completion, refactoring, and test generation (e.g., GitHub Copilot). Some tools use Bedrock under the hood.
• CI/CD pipelines can accept model-generated suggestions that run through the normal verification and scanning stages.
• Documentation generators and code review assistants can summarize code changes or flag potential security issues.

# CLI output from a typical developer toolchain
A new version of kiro-cli is available: 1.26.2
Run kiro-cli update to update to the new version

alistair@HODEI-LEGIONS:~/retro-feedback$ npm run build

# Example invoking a build tool and viewing the start of output
npx vite build 2>&1 | head -20

​

Prompt design for code generation

• Language and version (e.g., Python 3.10, Java 17).
• Execution environment (e.g., AWS Lambda, Docker container, microcontroller).
• Input and output shapes, data types, and schemas.
• Error handling, performance constraints, and security requirements.
• What tests, examples, or docstrings you expect.

• Vague:
  • “Write a function to parse JSON.”
• Better:
  • “Write a Python function that takes a JSON string, returns a dictionary, and includes error handling.”
• Best (specify environment and schema):
  • “Write a Python 3.10 function intended to run in an AWS Lambda environment. It should accept a JSON string matching this schema: {'userId': int, 'action': str, 'metadata': dict}. Return a Python dictionary and include robust error handling for empty body and invalid JSON. Include docstrings and unit tests.”

def factorial(n: int) -> int:
    """
    Return the factorial of a non-negative integer n.

    Raises:
        TypeError: If n is not an integer.
        ValueError: If n is negative.
    """
    if not isinstance(n, int):
        raise TypeError("n must be an integer")
    if n < 0:
        raise ValueError("n must be non-negative")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

import json
from typing import Any, Dict

def parse_event_body(event: Dict[str, Any]) -> Dict[str, Any]:
    """
    Parse the JSON body from an AWS Lambda event.
    Raises ValueError on empty or invalid JSON body.
    """
    body = event.get("body")
    if not body:
        raise ValueError("Empty body")
    try:
        return json.loads(body)
    except json.JSONDecodeError as exc:
        raise ValueError("Invalid JSON body") from exc

def test_parse_event_body_valid():
    event = {"body": '{"userId": 1, "action": "login"}'}
    result = parse_event_body(event)
    assert result["userId"] == 1
    assert result["action"] == "login"

def test_parse_event_body_empty():
    with pytest.raises(ValueError):
        parse_event_body({"body": ""})

def test_parse_event_body_invalid():
    with pytest.raises(ValueError):
        parse_event_body({"body": "{invalid json"})

​

Risks and limitations

• Models predict tokens; they do not run or fully verify code correctness.
• Generated code can include logic bugs, performance pitfalls, or security vulnerabilities.
• Models may not follow your organization’s style, security policies, or licensing restrictions unless you instruct them to.
• Always run existing CI/CD, static analysis, SAST/DAST, and security scanning on generated code.
• Require code review and sign-off before merging generated changes.

​

Organizational results you can expect

• Faster delivery cycles and reduced time-to-market for new features.
• Less time spent searching documentation and example code.
• Faster onboarding for developers learning new frameworks or libraries.
• Improved developer productivity through reduced boilerplate work and faster prototyping.

​

Key takeaway