Improve clarity and add helpful documentation

- Add floating point precision note to let/const exercise
- Add MDN links for null and undefined
- Add hint about nested loops for star staircase pattern
- Add callout explaining callbacks and higher-order functions
- Note that TypeScript provides type info, so JSDoc is for descriptions
- Clarify never type exercise to explicitly mention using throwError function

Author: kentcdodds

exercises/02.variables/01.problem.let-and-const/README.mdx

@@ -19,4 +19,14 @@ const API_URL = 'https://api.example.com'
 
 📜 [MDN - const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const)
 
+<callout-info>
+	You might notice JavaScript sometimes produces surprising decimal results like
+	`0.1 + 0.2 = 0.30000000000000004`. This is due to how computers store decimal
+	numbers in binary (floating point representation). It happens in most
+	programming languages, not just JavaScript. For currency calculations in real
+	apps, consider working in cents (integers) or using specialized libraries.
+</callout-info>
+
+📜 [MDN - Number representation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#number_encoding)
+
 🐨 Once you've completed the exercise, run `node index.ts` in the playground to test your work!

exercises/03.primitive-types/03.problem.null-and-undefined/README.mdx

@@ -38,4 +38,8 @@ console.log(value !== undefined ? 'Has value: ' + value : 'No value')
 
 📜 [TypeScript Handbook - Null and Undefined](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#null-and-undefined)
 
+📜 [MDN - null](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/null)
+
+📜 [MDN - undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)
+
 🐨 Once you've completed the exercise, run `node index.ts` in the playground to test your work!

exercises/04.control-flow/03.problem.loops/README.mdx

@@ -26,6 +26,20 @@ for (...) {
 }
 ```
 
+💰 You'll need **two loops** for this exercise—an outer loop for each row, and
+an inner loop to build the stars for that row. This is called a "nested loop":
+
+```ts
+for (let row = 1; row <= 5; row++) {
+	// inner loop builds stars for this row
+	for (let star = 0; star < row; star++) {
+		// add a star
+	}
+}
+```
+
 📜 [MDN - for statement](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for)
 
+📜 [MDN - for...of](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of) (an alternative loop syntax you'll see in the wild)
+
 🐨 Once you've completed the exercise, run `node index.ts` in the playground to test your work!

exercises/05.functions/04.problem.arrow-functions/README.mdx

@@ -52,6 +52,14 @@ function applyToNumber(
 const result = applyToNumber(5, (n) => n + 1) // 6
 ```
 
+<callout-info>
+	A **callback** is a function you pass to another function to be called later.
+	In the example above, `(n) => n + 1` is a callback—we're passing it to
+	`applyToNumber`, which calls it with the value `5`. Functions that accept
+	other functions as arguments are called **higher-order functions**. You'll use
+	this pattern a lot with array methods like `map`, `filter`, and `reduce`.
+</callout-info>
+
 📜 [Function Forms](https://kentcdodds.com/blog/function-forms)
 
 🐨 Once you've completed the exercise, run `node index.ts` in the playground to test your work!

exercises/05.functions/05.problem.jsdoc/README.mdx

@@ -25,6 +25,13 @@ function calculateArea(width: number, height: number): number {
 When you hover over `calculateArea` anywhere in your codebase, you'll see this
 documentation!
 
+<callout-info>
+	Since TypeScript already provides type information (parameter types, return
+	types), JSDoc is primarily useful for **descriptions** and **examples** in
+	TypeScript projects. The `@param` and `@returns` tags add human-readable
+	explanations that go beyond what types alone can convey.
+</callout-info>
+
 ## Common JSDoc Tags
 
 | Tag        | Purpose                              |

exercises/06.void-and-never/02.problem.never-type/README.mdx

@@ -15,8 +15,17 @@ is one that always throws or exits early.
 🐨 Open <InlineFile file="index.ts" /> and:
 
 1. Create a `throwError` function that throws and returns `never`
-2. Create a `parseNumber` function that converts a string to a number
-3. Create an `ensurePositive` function that throws if the number is negative
+2. Create a `parseNumber` function that converts a string to a number, using
+   `throwError("Invalid number")` if the input can't be parsed
+3. Create an `ensurePositive` function that returns the number if positive, or
+   uses `throwError("Number must be positive")` if negative
+
+<callout-info>
+	The key learning here is that `parseNumber` and `ensurePositive` should
+	**use** the `throwError` function rather than throwing directly. This
+	demonstrates how TypeScript's flow analysis understands that code after a
+	`never`-returning function call is unreachable.
+</callout-info>
 
 <callout-info>
 	`Number(value)` converts a string to a number. If the string can't be parsed,