Template engines transform parameterized templates into concrete code. This approach dominates configuration-heavy domains.

# Jinja2 template example
template = """
class {{ class_name }}:
    def __init__(self{% for field in fields %}, {{ field.name }}: {{ field.type }}{% endfor %}):
        {% for field in fields %}
        self.{{ field.name }} = {{ field.name }}
        {% endfor %}
"""

# Generates Python class from specification

Advantages: Simple, predictable, debuggable Limitations: Poor for complex logic, limited adaptability

Direct manipulation of language parse trees enables precise, semantically-aware code generation.

import ast

# Generate function AST programmatically
def create_getter(field_name):
    return ast.FunctionDef(
        name=f'get_{field_name}',
        args=ast.arguments(args=[ast.arg(arg='self')], defaults=[]),
        body=[ast.Return(value=ast.Attribute(
            value=ast.Name(id='self'),
            attr=field_name
        ))],
        decorator_list=[]
    )

Advantages: Type-safe, language-aware, enables complex transformations Limitations: Steep learning curve, language-specific

Modern AI models generate code from natural language descriptions or existing code context.

# Example using Claude API
import anthropic

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-5-20251101",
    messages=[{
        "role": "user",
        "content": "Generate a Python function to parse ISO8601 dates with timezone support"
    }]
)

Advantages: Natural specification, handles ambiguity, context-aware Limitations: Non-deterministic, requires validation, can introduce vulnerabilities

Google's protobuf generates serialization code from .proto schemas across 20+ languages.

// person.proto
syntax = "proto3";

message Person {
  string name = 1;
  int32 age = 2;
  repeated string emails = 3;
}

protoc --python_out=. person.proto  # Generates person_pb2.py

Generates REST API clients, servers, and documentation from OpenAPI specifications.

# openapi.yaml
paths:
  /users/{id}:
    get:
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer

Type-safe client code from GraphQL schemas and queries.

graphql-codegen --config codegen.yml  # Generates TypeScript types

Context-aware autocomplete powered by OpenAI Codex. Trained on public repositories.

• Inline suggestions during coding
• Multi-line completions
• Test generation
• Best for: Boilerplate, common patterns, test scaffolding

Full-context code generation, refactoring, and debugging assistant.

• Entire file/project awareness
• Multi-step reasoning
• Code review and explanation
• Best for: Complex refactoring, architecture design, debugging

IDE-integrated AI coding assistants with codebase indexing.

USE for:

• Repetitive boilerplate (getters/setters, constructors)
• API bindings from specifications
• Database models from schemas
• Serialization/deserialization
• Type definitions across language boundaries

AVOID for:

• Business logic (requires human judgment)
• Security-critical code (needs manual review)
• Creative algorithms (AI can introduce subtle bugs)
• One-off implementations (overhead not justified)

1. Always review generated code - Never blindly commit
2. Test thoroughly - Generated code needs validation
3. Version control generators - Track .proto files, not just output
4. Document generation process - Make builds reproducible

Validate that generated code is up-to-date:

#!/bin/bash
# .git/hooks/pre-commit
make codegen
git diff --exit-code gen/ || {
    echo "Generated code out of sync. Run 'make codegen'"
    exit 1
}