How does the prompt affect generated code quality?

Dramatically. Specifying language, types, error handling, edge cases, and desired patterns in your prompt can shift output from prototype-quality to production-ready code with proper structure and documentation.

Should I review LLM-generated code?

Always. LLMs can produce code with subtle bugs, security vulnerabilities, or incorrect assumptions. Treat generated code as a draft from a junior developer — review, test, and validate before using.

Which programming languages do LLMs generate best?

Python, JavaScript/TypeScript, and Java have the most training data and best results. Less common languages (Rust, Haskell, Elixir) work but with more errors. Always verify syntax and idioms.

How can I use LLMs for refactoring existing code?

Provide the code with explicit instructions: 'Refactor to reduce duplication', 'Convert to async/await', 'Add TypeScript types'. Include context about patterns and constraints. Review diffs carefully.

ApplicationNew

Code Generation

Writing code with AI

The Problem: Writing code is time-consuming, and it's easy to forget syntax or make mistakes. How can AI help write code faster and more reliably?

The Solution: Your AI Junior Developer

Code Generation uses LLMs to write, complete, and transform code based on natural language descriptions. It's like having a junior developer who can quickly draft code while you focus on architecture and logic. Using chain-of-thought prompting and few-shot examples significantly improves code quality.

Think of it like a programming intern:

1. Write specification: "Write a function to validate email addresses — return true/false"
2. Include types and signatures: Specify input/output types, language, and expected interface
3. Add edge cases: Empty input, unicode, very long strings, concurrent access
4. AI generates code: Complete implementation with types, error handling, and docs
5. Review for subtle bugs: Check for race conditions, null checks, off-by-one errors, and missing cleanup

Where Is This Used?

Code Completion: IDE integrations like GitHub Copilot
Boilerplate Generation: Creating repetitive code structures
Language Translation: Converting code between languages
Test Generation: Writing unit tests from function signatures
Gotchas: Subtle Bugs: LLM-generated code can look correct but hide race conditions, off-by-one errors, missing error handling, or incorrect edge case logic — always review critically

Fun Fact: LLM-generated code has a dangerous property: it looks plausible at first glance. Studies show developers accept AI-generated code with less scrutiny than human-written code, yet it can contain subtle logical errors — swapped comparison operators, missing null checks, or async code that works 99% of the time but deadlocks under load.

Try It Yourself!

Use the interactive example below to see how different prompting approaches affect the quality of generated code.

5 lines

Task:Build a function that fetches user data from an API

Build your prompt — toggle features:

Your Prompt (1 parts)

Write a function to fetch user data from /api/users/:id.

Generated CodeBase version

1async function getUser(id) {

2 const res = await fetch('/api/users/' + id);

3 const data = await res.json();

4 return data;

Toggle a feature above to see how your prompt changes the generated code

Code quality:

Minimal

Key Insight

1. Specificity = quality. "Write a function" gives minimum. Each requirement improves the output.
2. If you don't ask for it, you won't get it — LLMs take the shortest path.
3. Good prompts are checklists, not essays — each toggle = one line in the prompt.

Try it yourself

Interactive demo of this technique

Technique Comparison

Demo Mode

Pre-recorded responses

TaskBeginnerCoding

Write a function to filter an array of objects by multiple criteria

Without technique

Prompt

Write an array filter function.

Response

function filter(arr, key, value) { return arr.filter(item => item[key] === value); }

Tokens:12/35

Time:280ms

Quality:

With Code Generation

With technique

Prompt

Write a TypeScript function filterByMultipleCriteria that: 1. Takes an array of objects and a criteria object (key → value or array of values) 2. Supports exact match and array inclusion check 3. Returns a typed result 4. Includes JSDoc with usage example Usage example: filterByMultipleCriteria(users, { role: "admin", status: ["active", "pending"] }) Constraints: strict TypeScript, no any, cover edge case of empty criteria object.

Response

type Criteria<T> = {
  [K in keyof T]?: T[K] | T[K][];
};

/**
 * Filters an array of objects by multiple criteria.
 * A criterion can be a value (exact match) or array (inclusion check).
 *
 * @example
 * const users = [{ name: "Alice", role: "admin", status: "active" }];
 * filterByMultipleCriteria(users, { role: "admin", status: ["active", "pending"] });
 * // => [{ name: "Alice", role: "admin", status: "active" }]
 */
function filterByMultipleCriteria<T extends Record<string, unknown>>(
  items: T[],
  criteria: Criteria<T>
): T[] {
  const entries = Object.entries(criteria);
  if (entries.length === 0) return [...items];

  return items.filter((item) =>
    entries.every(([key, expected]) => {
      const actual = item[key];
      return Array.isArray(expected)
        ? expected.includes(actual)
        : actual === expected;
    })
  );
}

👁️Concrete usage example defines the expected API: key → value or array

🧠Typing and JSDoc requirement makes the model think through the generic Criteria<T> type

🔍Edge case (empty criteria) explicitly stated → model handles it instead of ignoring

Tokens:120/210

Time:980ms

Quality:

Why this works

A structured prompt with a usage example, typing constraints, and an explicit edge case transforms a one-liner without types into a production-ready generic function.

1 / 2

Practice Challenges

Create a free account to solve challenges

6 AI-verified challenges for this lesson

Related lessons:Chain Of Thought Data Generation

This lesson is part of a structured LLM course.

My Learning Path

ApplicationNew

Code Generation

Writing code with AI

The Problem: Writing code is time-consuming, and it's easy to forget syntax or make mistakes. How can AI help write code faster and more reliably?

The Solution: Your AI Junior Developer

Think of it like a programming intern:

1. Write specification: "Write a function to validate email addresses — return true/false"
2. Include types and signatures: Specify input/output types, language, and expected interface
3. Add edge cases: Empty input, unicode, very long strings, concurrent access
4. AI generates code: Complete implementation with types, error handling, and docs
5. Review for subtle bugs: Check for race conditions, null checks, off-by-one errors, and missing cleanup

Where Is This Used?

Code Completion: IDE integrations like GitHub Copilot
Boilerplate Generation: Creating repetitive code structures
Language Translation: Converting code between languages
Test Generation: Writing unit tests from function signatures
Gotchas: Subtle Bugs: LLM-generated code can look correct but hide race conditions, off-by-one errors, missing error handling, or incorrect edge case logic — always review critically

Try It Yourself!

Use the interactive example below to see how different prompting approaches affect the quality of generated code.

5 lines

Task:Build a function that fetches user data from an API

Build your prompt — toggle features:

Your Prompt (1 parts)

Write a function to fetch user data from /api/users/:id.

Generated CodeBase version

1async function getUser(id) {

2 const res = await fetch('/api/users/' + id);

3 const data = await res.json();

4 return data;

Toggle a feature above to see how your prompt changes the generated code

Code quality:

Minimal

Key Insight

1. Specificity = quality. "Write a function" gives minimum. Each requirement improves the output.
2. If you don't ask for it, you won't get it — LLMs take the shortest path.
3. Good prompts are checklists, not essays — each toggle = one line in the prompt.

Try it yourself

Interactive demo of this technique

Technique Comparison

Demo Mode

Pre-recorded responses

TaskBeginnerCoding

Write a function to filter an array of objects by multiple criteria

Without technique

Prompt

Write an array filter function.

Response

function filter(arr, key, value) { return arr.filter(item => item[key] === value); }

Tokens:12/35

Time:280ms

Quality:

With Code Generation

With technique

Prompt

Response

type Criteria<T> = {
  [K in keyof T]?: T[K] | T[K][];
};

/**
 * Filters an array of objects by multiple criteria.
 * A criterion can be a value (exact match) or array (inclusion check).
 *
 * @example
 * const users = [{ name: "Alice", role: "admin", status: "active" }];
 * filterByMultipleCriteria(users, { role: "admin", status: ["active", "pending"] });
 * // => [{ name: "Alice", role: "admin", status: "active" }]
 */
function filterByMultipleCriteria<T extends Record<string, unknown>>(
  items: T[],
  criteria: Criteria<T>
): T[] {
  const entries = Object.entries(criteria);
  if (entries.length === 0) return [...items];

  return items.filter((item) =>
    entries.every(([key, expected]) => {
      const actual = item[key];
      return Array.isArray(expected)
        ? expected.includes(actual)
        : actual === expected;
    })
  );
}

👁️Concrete usage example defines the expected API: key → value or array

🧠Typing and JSDoc requirement makes the model think through the generic Criteria<T> type

🔍Edge case (empty criteria) explicitly stated → model handles it instead of ignoring

Tokens:120/210

Time:980ms

Quality:

Why this works

A structured prompt with a usage example, typing constraints, and an explicit edge case transforms a one-liner without types into a production-ready generic function.

1 / 2

Practice Challenges

Create a free account to solve challenges

6 AI-verified challenges for this lesson

Related lessons:Chain Of Thought Data Generation

This lesson is part of a structured LLM course.

My Learning Path