Code Generation That Actually Works

The Copy-Paste Trap

Here’s the most common mistake developers make with AI code generation: they type a vague prompt, get back 50 lines of generic code, paste it in, and spend the next hour fixing it to match their codebase.

That’s not AI-assisted development. That’s AI-obstructed development.

The fix isn’t better AI. It’s better prompts. When you give AI the right context, it doesn’t just generate code—it generates code that looks like your team wrote it.

Let me show you the difference.

Vague vs. Specific: A Real Example

The vague prompt:

Write a function to handle user registration.

You’ll get back something generic. Maybe Express.js, maybe Flask, maybe something with no framework at all. It’ll use conventions you don’t follow and patterns that don’t match your codebase.

The specific prompt:

Write a user registration endpoint for our Express.js API.

Our patterns:
- We use TypeScript with strict mode
- Controllers are classes with static methods
- Validation uses Zod schemas
- Errors throw AppError(statusCode, message)
- Passwords hashed with bcrypt (12 rounds)
- Responses follow { success: boolean, data?: T, error?: string }

Here's an existing endpoint for reference:

static async login(req: Request, res: Response) {
  const { email, password } = LoginSchema.parse(req.body);
  const user = await UserRepository.findByEmail(email);
  if (!user) throw new AppError(401, 'Invalid credentials');
  const valid = await bcrypt.compare(password, user.passwordHash);
  if (!valid) throw new AppError(401, 'Invalid credentials');
  const token = generateToken(user.id);
  res.json({ success: true, data: { token, user: sanitize(user) } });
}

Write the register method following the same patterns.

The second prompt produces code that drops straight into your codebase. Same patterns, same error handling, same response format. Why? Because you showed the AI exactly what “right” looks like.

The Three Layers of Context

When generating code, think about context in three layers:

Layer 1: Project Context

What stack are you using? What conventions does your team follow? What patterns are already established?

Project: Node.js/TypeScript REST API
Framework: Express with middleware pattern
Database: PostgreSQL via Prisma ORM
Auth: JWT with refresh tokens
Testing: Jest + Supertest

You don’t need to repeat this every time—but for new AI conversations, a brief project summary saves a lot of back-and-forth.

Layer 2: Code Context

What existing code is relevant? This is the most powerful context you can provide. Paste in:

• The file you’re adding to (or at least the relevant parts)
• Related interfaces or types
• Similar functions that demonstrate your patterns
• Database schemas or models involved

Layer 3: Task Context

What specifically needs to happen? Be concrete:

Add a PATCH /users/:id/preferences endpoint that:
- Accepts partial updates to user preferences
- Validates that notification_email is a valid email if provided
- Validates that theme is one of: 'light', 'dark', 'system'
- Returns the updated preferences object
- Requires authentication (use our authMiddleware)

Generating Code Incrementally

Big tasks produce worse results than small ones. Here’s why: when you ask for an entire feature at once, the AI has to juggle too many concerns—types, validation, business logic, error handling, database queries, response formatting.

Instead, break it down:

Step 1: Types and interfaces first

Based on our Prisma schema for User, create a Zod
validation schema for updating user preferences.
Fields: theme (light/dark/system), notification_email
(valid email), language (ISO 639-1 code).
All fields optional for partial updates.

Step 2: Business logic

Write the updatePreferences method for UserService.
It should accept a userId and the validated partial
preferences object. Use our existing pattern from
UserService.updateProfile (shown below).

[paste updateProfile method]

Step 3: Controller and route

Create the controller method and route registration
for PATCH /users/:id/preferences. Follow the pattern
from our existing user routes (shown below).

[paste relevant route file]

Each piece is focused. Each piece builds on verified output from the previous step. And if something goes wrong, you know exactly where.

Quick Check: Fix This Prompt

Here’s a prompt a developer might write. How would you improve it?

Create a caching layer for my API.

Think about what’s missing. What would you add? Here’s one improved version:

Add Redis-based response caching to our Express API.

Requirements:
- Cache GET responses for 5 minutes by default
- Use the request URL + query params as cache key
- Skip caching for authenticated requests (has Authorization header)
- Invalidate cache when POST/PUT/DELETE hits the same resource
- Implement as Express middleware so we can add it per-route

Our current middleware pattern:
[paste example middleware]

Redis client setup:
[paste Redis config]

The difference is night and day.

Handling AI Mistakes in Generated Code

AI-generated code will sometimes be wrong. Not catastrophically wrong—usually subtly wrong. Here are the patterns to watch for:

Hallucinated APIs. The AI invents a method that doesn’t exist in the library version you’re using. Always verify that methods, parameters, and return types exist in your version.

# AI might generate this for pandas 2.x
df.append(new_row)  # WRONG: .append() was removed in pandas 2.0
# Correct:
df = pd.concat([df, pd.DataFrame([new_row])])

Outdated patterns. AI training data includes old code. You might get componentWillMount in React or var in modern JavaScript. Specify your versions explicitly.

Missing error handling. AI tends to generate the happy path beautifully and forget edge cases. After generating code, always ask: “What error handling is missing from this code?”

Wrong assumptions about your data. The AI might assume a field is always present when it’s nullable, or that an array is never empty. Cross-reference with your actual schema.

Security blind spots. AI-generated code sometimes skips input sanitization, uses deprecated crypto methods, or creates SQL injection vulnerabilities. Never trust AI with security-critical code without careful review.

The “Show, Don’t Tell” Principle

The most effective code generation pattern is showing the AI what you want through examples rather than describing it in words.

Telling (less effective):

Write functions that follow functional programming
principles with immutability and pure functions.

Showing (much more effective):

Write the calculateDiscount function following the same
pattern as these existing functions:

const calculateTax = (price: number, rate: number): Money => ({
  amount: Math.round(price * rate * 100) / 100,
  currency: 'USD',
});

const calculateShipping = (weight: number, zone: Zone): Money => ({
  amount: ZONE_RATES[zone] * Math.ceil(weight),
  currency: 'USD',
});

The AI immediately picks up your patterns: TypeScript with explicit types, pure functions, the Money return type, the rounding convention. You didn’t have to explain any of that.

Practical Exercise: Generate a Real Component

Try this with your own codebase right now:

1. Pick a feature you need to build (or recently built)
2. Find 1-2 similar existing components/functions
3. Write a prompt that includes:
   • Your project context (2-3 lines)
   • The existing code examples
   • Specific requirements for the new code
4. Generate the code
5. Compare it to what you would have written manually

Notice what the AI got right and what needed adjusting. That gap will shrink dramatically as you get better at providing context.

Key Takeaways

• Specific prompts with examples beat vague requests every time
• Provide three layers of context: project, code, and task
• Break complex generation tasks into smaller, focused steps
• Always verify AI output—watch for hallucinated APIs and missing error handling
• Show the AI your patterns through code examples, not prose descriptions
• AI-generated code is a first draft, not a final product

Next up: debugging. When things go wrong—and they will—AI becomes your most powerful diagnostic tool. You’ll learn to turn cryptic error messages into clear explanations and fix suggestions.

Up next: In the next lesson, we’ll dive into Debugging and Error Resolution with AI.