Prompting for Code Generation

Code generation is one of the most transformative applications of AI. A skilled developer who uses AI prompting effectively can write production-quality code in a fraction of the time. This lesson covers the specific techniques that make code prompts work — and the mistakes that cause them to fail.

Why Code Prompting Is Different

Code has properties that most AI tasks don't:

Correctness is binary — code either works or it doesn't
Context matters enormously — you need to specify language, framework, version, constraints
Edge cases kill production code — you need to ask for error handling explicitly
Style and architecture are opinionated — you need to specify your preferences

Generic prompts produce generic code. Specific prompts produce code you can actually use.

The Code Prompt Template

Language/Framework: [Python 3.12 / Next.js 15 / React 19 / etc.]
Task: [Specific, detailed description of what the function/component should do]
Input: [What data comes in — types, format, example values]
Output: [What data comes out — types, format, example values]
Edge cases to handle: [null inputs, empty lists, network errors, etc.]
Requirements:
- [Requirement 1: e.g., "Use async/await, not callbacks"]
- [Requirement 2: e.g., "Include TypeScript type annotations"]
- [Requirement 3: e.g., "Follow PEP 8 style guidelines"]
Do NOT use: [Libraries or patterns to avoid]

Example: From Vague to Professional

Vague prompt:

"Write a Python function to process user data"

Professional prompt:

Language: Python 3.12
Task: Write a function that takes a list of user objects and returns
summary statistics for the group.

Input: List of user dicts with keys: 'name' (str), 'age' (int),
'email' (str), 'signup_date' (ISO date string), 'is_premium' (bool)

Output: Dict with:
- 'total_users': int
- 'average_age': float (rounded to 1 decimal)
- 'premium_rate': float (percentage, 0-100)
- 'newest_signup': str (ISO date)
- 'age_distribution': dict with 'under_25', '25_to_40', 'over_40' keys (counts)

Edge cases:
- Empty list should return None
- Missing keys in user dicts should be handled gracefully
- Invalid date strings should be skipped with a warning

Requirements:
- Type annotations throughout
- Docstring with Args/Returns/Raises sections
- No external dependencies beyond stdlib

The second prompt produces production-ready code. The first produces a sketch.

Debugging Prompts That Actually Work

The most valuable code prompting skill is getting AI to debug effectively:

"Here is my [language] code that is supposed to [expected behavior]:

[paste code]

Actual behavior: [describe what's happening]
Expected behavior: [describe what should happen]
Error message (if any): [paste exact error]
Example input that triggers the bug: [provide example]

Debug this by:
1. Tracing through the logic step by step with the example input
2. Identifying the exact line(s) where behavior diverges
3. Explaining WHY the bug occurs (not just where)
4. Providing corrected code
5. Suggesting a test case to prevent regression

Do not just give me the fixed code — explain the root cause."

Code Review Prompts

"Review this [language] code as a senior engineer at a top tech company.

[paste code]

Evaluate and provide specific feedback on:
1. **Correctness** — Any bugs or logic errors?
2. **Security** — Any vulnerabilities (injection, auth bypass, data exposure)?
3. **Performance** — Any inefficiencies, especially in loops or DB queries?
4. **Readability** — Is naming clear? Are complex sections explained?
5. **Error handling** — Are all failure modes covered?
6. **Testing** — What edge cases are missing from coverage?

For each issue found: show the problematic code, explain why it's a problem,
and provide the corrected version. Be direct — don't soften real problems."

Generating Tests

"Write comprehensive tests for this function using [pytest/Jest/Vitest]:

[paste function code]

Cover these test categories:
1. Happy path — standard expected inputs
2. Edge cases — empty inputs, boundary values, max/min values
3. Error cases — invalid types, missing required fields
4. Integration scenarios — how this function interacts with [related function]

Use descriptive test names that explain what is being tested.
Each test should have a clear arrange/act/assert structure.
Mock external dependencies."

Architecture and Design Prompts

For larger decisions, chain-of-thought works well:

"I need to design a [system/feature/API] that:
- Does: [requirements]
- Must handle: [scale/performance requirements]
- Integrates with: [existing systems]
- Constraints: [language, framework, timeline]

Think through this architecturally:
1. What are the main components needed?
2. How should data flow between them?
3. What are the critical design decisions and what are their trade-offs?
4. What are the biggest risks and how would you mitigate them?
5. Propose a concrete implementation plan starting with the highest-priority pieces

Draw out the architecture in ASCII if helpful."

Refactoring Prompts

"Refactor this code to improve [readability/performance/maintainability]:

[paste code]

Specifically:
- Extract repeated logic into functions
- Improve variable naming (current names like 'x', 'temp' are unclear)
- Reduce nesting depth where possible
- Split the [function/class/module] if it violates single-responsibility

Requirements:
- Maintain identical behavior — this is a pure refactor
- Preserve all existing tests passing
- Add brief comments only where logic is non-obvious
- Show me a before/after comparison of the most significant changes"

Explaining Complex Code

When you receive unfamiliar code:

"Explain this [language] code to me as if I'm an experienced developer
but new to [this specific domain/library/pattern]:

[paste code]

I need to understand:
1. What this code does at a high level (2-3 sentences)
2. The key algorithmic idea or pattern being used
3. Any non-obvious choices and why they were likely made
4. What I'd need to modify to [specific change I might make]

Don't just translate each line — give me the mental model."

Key Rules for Code Prompting

Always specify the language and version — Python 3.12 behaves differently from Python 3.8
Describe inputs and outputs with types and examples
Explicitly request error handling — AI won't always include it by default
Ask for tests — always request test coverage for production code
Request explanation with complex code — understanding the code matters as much as having it
Iterate in small steps — build incrementally rather than asking for entire applications in one prompt

Next lesson: Prompting for Content Writing — applying the same precision to text creation.