AI Code Generation — Prompting for Developers

Code Prompting Is Different

Generating code requires more precision than generating text. A slightly wrong word in prose is forgivable; a slightly wrong variable name in code is a bug.

The Code Prompt Framework

1. Context First

I'm building a [type of application] using [tech stack].
The codebase uses [patterns/conventions].
I need to [specific task].

Why it works: Models produce dramatically better code when they know the stack, conventions, and surrounding architecture.

2. Spec-Driven Prompting

Instead of describing what you want in prose, write a mini-spec:

## Function: calculateShippingCost

Input:
- items: Array of { weight: number (kg), dimensions: {l, w, h} (cm) }
- destination: { country: string, postalCode: string }
- shippingMethod: "standard" | "express" | "overnight"

Output:
- { cost: number, estimatedDays: number, carrier: string }

Behavior:
- Free shipping for orders over $100
- Express adds 50% to base cost
- Overnight adds 200% to base cost
- International orders add flat $15 surcharge
- Throw error if items array is empty

Constraints:
- TypeScript with strict types
- No external dependencies
- Include JSDoc comments
- Handle edge cases (max weight, oversized items)

3. Show, Don't Tell

Provide an example of existing code in your project:

Here's how we handle similar functions in this codebase:

// Example from our existing code:
export async function calculateTax(amount: number, state: string): Promise<TaxResult> {
  // ... existing code ...
}

Now write a similar function for shipping cost calculation.

What to Include in Code Prompts

Element	Impact	Example
Language/framework	Critical	"TypeScript with Next.js 16"
Existing patterns	High	"We use Prisma for DB access"
Input/output types	High	"Takes a UserDTO, returns a Promise<Result>"
Error handling	Medium	"Use Result type, no throw"
Testing	Medium	"Include Vitest test cases"
Performance	Situational	"Must handle 10K items efficiently"

Common Prompting Patterns

The Rubber Duck

Describe your problem in detail — often the answer becomes obvious:

I have a race condition where two API calls can create duplicate users.
The flow is: 1) check if email exists, 2) if not, create user.
Between steps 1 and 2, another request can slip in.
What's the best way to handle this in PostgreSQL with Prisma?

The Code Review Request

Review this code for:
1. Security vulnerabilities
2. Performance issues
3. Error handling gaps
4. TypeScript type safety

[paste your code]

For each issue, explain WHY it's a problem and provide the fixed code.

The Refactor

Refactor this function to:
- Extract the validation logic into a separate function
- Replace the nested if/else with early returns
- Add proper TypeScript types (no 'any')
- Keep the same behavior (don't change the API)

[paste your code]

The Migration

Convert this Express.js route handler to Next.js 16 App Router format:
- Keep the same logic
- Use the new Route Handler convention
- Adapt the middleware pattern
- Update the response format

[paste Express code]

Iterative Refinement

Don't try to get everything in one prompt. Use a conversation:

1. Start broad: "Build a user authentication system with JWT"
2. Add constraints: "Use httpOnly cookies instead of localStorage"
3. Handle edge cases: "What about token refresh and race conditions?"
4. Add tests: "Write tests for the happy path and 3 edge cases"
5. Review: "Review the complete implementation for security issues"

Model Strengths for Code

Model	Strongest At
Claude Opus/Sonnet	Large codebase understanding, refactoring, architecture decisions
GPT-4o / GPT-5	Quick code generation, API integration, broad language support
Gemini 2.5 Pro	Long-context code analysis, documentation, multi-file understanding
Copilot	Inline completion, boilerplate, test generation
Cursor	Full-file edits, codebase-aware suggestions

Anti-Patterns to Avoid

1. "Write me a todo app" — too vague, produces generic code
2. No context about existing code — the AI can't match your patterns
3. Asking for everything at once — break complex tasks into steps
4. Not reviewing the output — AI code can have subtle bugs
5. Copy-pasting without understanding — if you can't explain the code, don't ship it