Code Generation Prompt

The Problem

Generic prompts produce generic code — no error handling, no types, no edge cases, no tests. The AI writes code that works for the happy path but breaks in production. You need prompts that specify not just what the code should do, but how it should handle failure, what types it should use, and what patterns it should follow.

The Prompt

Write production-ready [LANGUAGE] code for: [TASK DESCRIPTION]

TECHNICAL REQUIREMENTS:
- Language/Runtime: [language and version]
- Framework: [framework and version if applicable]
- Type System: [strict TypeScript / Python type hints / etc.]
- Style Guide: [ESLint config / PEP 8 / project conventions]

CODE REQUIREMENTS:
- Include comprehensive error handling (try/catch, validation, edge cases)
- Add JSDoc/docstring comments for public functions
- Use descriptive variable names (no single letters except loop indices)
- Handle null/undefined/empty inputs gracefully
- Follow [PATTERN: functional / OOP / reactive]

OUTPUT FORMAT:
- Code only, no explanations before or after
- Include imports at the top
- Add inline comments only for non-obvious logic
- If tests are needed: [jest / pytest / vitest] test file separately

CONTEXT:
[relevant existing code, types, or API signatures this code must integrate with]

Example Output

import { z } from "zod";

/** Schema for validating user registration input */
const RegistrationSchema = z.object({
  email: z.string().email("Invalid email format"),
  password: z.string().min(8, "Password must be at least 8 characters"),
  name: z.string().min(1, "Name is required").max(100),
});

type RegistrationInput = z.infer<typeof RegistrationSchema>;

/** Register a new user with validation and duplicate checking */
export async function registerUser(
  input: unknown,
  db: Database
): Promise<{ success: true; userId: string } | { success: false; error: string }> {
  const parsed = RegistrationSchema.safeParse(input);
  if (!parsed.success) {
    return { success: false, error: parsed.error.issues[0].message };
  }

  const existing = await db.users.findByEmail(parsed.data.email);
  if (existing) {
    return { success: false, error: "Email already registered" };
  }

  const hashedPassword = await hashPassword(parsed.data.password);
  const user = await db.users.create({
    ...parsed.data,
    password: hashedPassword,
  });

  return { success: true, userId: user.id };
}

When to Use

Use this skill for any code generation task that will run in production — API endpoints, data transformations, utility functions, or component implementations. It is the difference between getting a code sketch and getting a deployable implementation.

Pro Tips

• Provide existing type definitions — pasting your interfaces or types gives the model exact contracts to follow instead of inventing its own.
• Specify the error handling pattern — “return Result type” vs “throw exceptions” vs “return null” produces fundamentally different code.
• Ask for the test file separately — generating code and tests in the same prompt splits the model’s attention; chain them instead.
• Include your linting rules — “no any types, no console.log, prefer const” prevents the most common code review rejections.