Coding Prompts

Generate a trace of dictionary or object manipulation code step by step, or produce a key-value practice problem and check a submitted attempt against it.

Convert plain-English algorithm pseudocode into working code line by line, flagging every ambiguous step and stating the assumption made to resolve it.

Explain a classic design pattern by naming the recurring problem it solves before any code, then a working example and a sign it was overused.

Generate a small dataset and a NumPy or Pandas exercise built around it, with a fully worked solution explained line by line.

Explain the difference between AI pair programming and vibe coding, then give one concrete habit that keeps an AI coding assistant from replacing genuine learning.

Build a small example graph as an adjacency list, adjacency matrix, or both, comparing memory usage and lookup cost between representations.

Explain a Python code snippet line by line or through its Python-specific idioms, such as comprehensions and decorators, with comparisons to a familiar language.

Explain variables and core data types in a chosen language, including typing behavior and type coercion, or check pasted variable declarations for type issues.

Generate a short buggy code snippet with one planted bug, then reveal it through a three-step hint ladder ending at the exact line and fix.

Generate a step-by-step data lesson formatted as real notebook cells, alternating markdown explanations with runnable code for a chosen topic.

Explain the math behind AI models, vectors, matrices, gradient descent, using small worked examples tied to what each computation actually does inside a model.

Generate a step-by-step build guide for a classic first-course exercise, rock-paper-scissors, a calculator, a number guessing game, broken into stages that produce a runnable checkpoint.

Explain the divide, conquer, and combine pattern underneath merge sort, quicksort, or binary search, tracing each step on a concrete input.

Explain any git command or sequence of commands through git's three-place mental model of working directory, staging area, and commit history.

Generate two small related tables and a real SQL join challenge to solve, with a fully explained solution showing exactly which rows matched and why.

Trace a recursive function call by call, showing the stack build and unwind, or generate a fresh recursion practice problem to trace by hand.

Explain a common security vulnerability with a broken code example and its fix side by side, showing the specific habit that closes the gap.

Generate a step-by-step conversion between bits, bytes, kilobytes, megabytes, gigabytes, and terabytes, explaining why storage math uses base 2 instead of base 10.

Trace a single page load through client-side rendering and then server-side rendering, showing exactly what appears on screen at each moment to compare the two.

Determine which part of a semantic version number to bump for a real code change, with reasoning tied to its actual impact on dependent code.

Explain a core data structure through a matching analogy, a short code example, a realistic scenario where it wins, and a common beginner mistake.

Trace what compiling versus interpreting actually does to a pasted code snippet, comparing what happens before the program runs against what happens while it runs.

Turn code or a plain-English algorithm description into a flowchart of its steps, decision branches, and loops, rendered as Mermaid syntax or an ASCII diagram.

Explain how to normalize a messy table design step by step, from first through third normal form, naming the specific rule violation before each fix.