/fact-check

name: fact-check
description: Verify technical accuracy of JavaScript concept pages by checking code examples, MDN/ECMAScript compliance, and external resources to prevent misinformation

Skill: JavaScript Fact Checker

Use this skill to verify the technical accuracy of concept documentation pages for the 33 JavaScript Concepts project. This ensures we're not spreading misinformation about JavaScript.

When to Use

• Before publishing a new concept page
• After significant edits to existing content
• When reviewing community contributions
• When updating pages with new JavaScript features
• Periodic accuracy audits of existing content

What We're Protecting Against

• Incorrect JavaScript behavior claims
• Outdated information (pre-ES6 patterns presented as current)
• Code examples that don't produce stated outputs
• Broken or misleading external resource links
• Common misconceptions stated as fact
• Browser-specific behavior presented as universal
• Inaccurate API descriptions

---

Fact-Checking Methodology

Follow these five phases in order for a complete fact check.

Phase 1: Code Example Verification

Every code example in the concept page must be verified for accuracy.

Step-by-Step Process

1. **Identify all code blocks** in the document 2. **For each code block:**

• Read the code and any output comments (e.g., `// "string"`)
• Mentally execute the code or test in a JavaScript environment
• Verify the output matches what's stated in comments
• Check that variable names and logic are correct

3. **For "wrong" examples (marked with ❌):**

• Verify they actually produce the wrong/unexpected behavior
• Confirm the explanation of why it's wrong is accurate

4. **For "correct" examples (marked with ✓):**

• Verify they work as stated
• Confirm they follow current best practices

5. **Run project tests:**

   # Run all tests
   npm test
   
   # Run tests for a specific concept
   npm test -- tests/fundamentals/call-stack/
   npm test -- tests/fundamentals/primitive-types/

6. **Check test coverage:**

• Look in `/tests/{category}/{concept-name}/`
• Verify tests exist for major code examples
• Flag examples without test coverage

Code Verification Checklist

| Check | How to Verify | |-------|---------------| | `console.log` outputs match comments | Run code or trace mentally | | Variables are correctly named/used | Read through logic | | Functions return expected values | Trace execution | | Async code resolves in stated order | Understand event loop | | Error examples actually throw | Test in try/catch | | Array/object methods return correct types | Check MDN | | `typeof` results are accurate | Test common cases | | Strict mode behavior noted if relevant | Check if example depends on it |

Common Output Mistakes to Catch

// Watch for these common mistakes:

// 1. typeof null
typeof null        // "object" (not "null"!)

// 2. Array methods that return new arrays vs mutate
const arr = [1, 2, 3]
arr.push(4)        // Returns 4 (length), not the array!
arr.map(x => x*2)  // Returns NEW array, doesn't mutate

// 3. Promise resolution order
Promise.resolve().then(() => console.log('micro'))
setTimeout(() => console.log('macro'), 0)
console.log('sync')
// Output: sync, micro, macro (NOT sync, macro, micro)

// 4. Comparison results
[] == false        // true
[] === false       // false
![]                // false (empty array is truthy!)

// 5. this binding
const obj = {
  name: 'Alice',
  greet: () => console.log(this.name)  // undefined! Arrow has no this
}

---

Phase 2: MDN Documentation Verification

All claims about JavaScript APIs, methods, and behavior should align with MDN documentation.

Step-by-Step Process

1. **Check all MDN links:**

• Click each MDN link in the document
• Verify the link returns 200 (not 404)
• Confirm the linked page matches what's being referenced

2. **Verify API descriptions:**

• Compare method signatures with MDN
• Check parameter names and types
• Verify return types
• Confirm edge case behavior

3. **Check for deprecated APIs:**

• Look for deprecation warnings on MDN
• Flag any deprecated methods being taught as current

4. **Verify browser compatibility claims:**

• Cross-reference with MDN compatibility tables
• Check Can I Use for broader support data

MDN Link Patterns

| Content Type | MDN URL Pattern | |--------------|-----------------| | Web APIs | `https://developer.mozilla.org/en-US/docs/Web/API/{APIName}` | | Global Objects | `https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/{Object}` | | Statements | `https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/{Statement}` | | Operators | `https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/{Operator}` | | HTTP | `https://developer.mozilla.org/en-US/docs/Web/HTTP` |

What to Verify Against MDN

| Claim Type | What to Check | |------------|---------------| | Method signature | Parameters, optional params, return type | | Return value | Exact type and possible values | | Side effects | Does it mutate? What does it affect? | | Exceptions | What errors can it throw? | | Browser support | Compatibility tables | | Deprecation status | Any deprecation warnings? |

---

Phase 3: ECMAScript Specification Compliance

For nuanced JavaScript behavior, verify against the ECMAScript specification.

When to Check the Spec

• Edge cases and unusual behavior
• Claims about "how JavaScript works internally"
• Type coercion rules
• Operator precedence
• Execution order guarantees
• Claims using words like "always", "never", "guaranteed"

How to Navigate the Spec

The ECMAScript specification is at: https://tc39.es/ecma262/

| Concept | Spec Section | |---------|--------------| | Type coercion | Abstract Operations (7.1) | | Equality | Abstract Equality Comparison (7.2.14),