AI-Augmented JavaScript — Free Sample

1. An AI assistant generates a Promise-based function: `async function fetchAll(urls) { return Promise.all(urls.map(u => fetch(u).then(r => r.json()))); }`. You'll be calling it with ~500 URLs against a third-party API. What's the highest-leverage critique?

Promise.all fires all 500 requests at once; the API will likely rate-limit or fail. Replace with a concurrency-limited pool (e.g., p-limit, or a hand-rolled batching loop) before shipping. The function is fine; modern fetch handles rate limiting automatically. Add try/catch around fetch; that's the only real risk. Promise.all is wrong here — use Promise.allSettled instead so individual failures don't reject everything.

2. You're refactoring a complex React component with deeply nested state. AI suggests `const [state, setState] = useState({...largeNestedObject})` and then `setState(prev => ({...prev, nested: {...prev.nested, foo: bar}}))` for updates. What's the right judgment call?

Push back: deeply nested state is a smell — the AI's spread-update pattern is correct mechanically but masks a structural issue. Suggest splitting into multiple useState calls or moving to useReducer; verify against actual rerender cost before committing. Accept the suggestion; the spread pattern correctly produces a new object reference and triggers rerender. Reject AI's suggestion entirely and write the component without hooks. Add useMemo around the state to fix the rerender problem.

3. AI generates: `const result = items.map(async i => await processItem(i)).filter(r => r.success);`. The filter never matches. What's the most likely cause?

`.map(async ...)` returns an array of Promises, not resolved values; .filter then runs on the Promise objects (which are truthy and have no .success property). Fix: `await Promise.all(items.map(...))` before filtering. processItem is throwing silently; wrap in try/catch. The .success property name is wrong; check what processItem actually returns. Replace .map with .filter directly; combining them is anti-pattern.

4. You ask AI to write a deep-equality check. It generates: `function isEqual(a, b) { return JSON.stringify(a) === JSON.stringify(b); }`. The function passes your test cases. What's worth knowing before shipping?

JSON.stringify silently drops undefined values, functions, and Symbols; it doesn't preserve key order across all engines historically; it throws on circular references; and Date / Map / Set don't round-trip. The function works for shallow JSON-shaped objects only — explicitly document the contract or use a library like dequal/lodash.isEqual for general use. Ship it; if your tests pass, the function is correct. The function is slow; replace with === for primitives only. JSON.stringify is non-deterministic; use Object.entries instead.

5. AI generates a TypeScript generic: `function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> { return keys.reduce((acc, k) => ({ ...acc, [k]: obj[k] }), {} as Pick<T, K>); }`. The runtime behavior is correct. What's the highest-leverage type-system review?

The `{} as Pick<T, K>` cast is a type-safety escape hatch — the empty object is asserted to satisfy Pick<T, K>, but at the moment of the cast it doesn't have any of the K keys yet. Functionally fine because the reduce fills them in, but it teaches readers/AI that as-casts are acceptable. Either accept the trade-off (with comment) or rewrite using Object.fromEntries with explicit typing. The generics are correct; nothing to refine. Replace reduce with Object.fromEntries(keys.map(k => [k, obj[k]])); cleaner and avoids the cast. Remove the generics — TypeScript can infer them.

Your directional indicator

This 5-question sample gives a rough indication only. For a valid, verified Skills Passport credential, take the full 40-question assessment — it takes about 30 minutes.

Coming soon

Full assessment launching soon