Episode 2 — React Frontend Architecture NextJS / 2.16 — Performance Optimization in React

2.16.c — `useCallback`: stable function references

Learning outcomes

Explain when function identity matters in React.
Pair useCallback with memo intentionally, not superstitiously.
Debug stale closures caused by incorrect dependency arrays.

What `useCallback` does

useCallback(fn, deps) returns a memoized version of fn that stays referentially stable until deps change.

import React, { useCallback, useState } from "react";

export function Parent() {
  const [count, setCount] = useState(0);

  const inc = useCallback(() => setCount((c) => c + 1), []);

  return <MemoChild onInc={inc} count={count} />;
}

const MemoChild = React.memo(function MemoChild({
  onInc,
  count,
}: {
  onInc: () => void;
  count: number;
}) {
  return (
    <button onClick={onInc}>
      count: {count}
    </button>
  );
});

Here onInc is stable, so MemoChild only re-renders when count changes (expected).

Stale closure example

const save = useCallback(() => {
  api.save({ value });
}, []); // BUG: missing `value`

This freezes the initial value. Fix deps or restructure.

When not to use `useCallback`

The function is not passed to memoized children.
It is not a dependency of other hooks.
The code becomes harder to read for no measurable win.

Team guidance

Treat useCallback as part of a component API contract when exporting library-like components: document which callbacks should be stable for performance.

Appendix — Scenario bank (basic → advanced)

These scenarios are intentionally repetitive in shape but varied in forces so you build reflexes. For each one, practice saying: symptom → root cause → fix → how you prove it in DevTools.

UCB-001 — useCallback scenario #1

Level: Beginner
User-visible symptom: UI jank when parent state updates every 13 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-002 — useCallback scenario #2

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 26 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-003 — useCallback scenario #3

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 39 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-004 — useCallback scenario #4

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 52 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-005 — useCallback scenario #5

Level: Advanced
User-visible symptom: UI jank when parent state updates every 65 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-006 — useCallback scenario #6

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 78 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-007 — useCallback scenario #7

Level: Beginner
User-visible symptom: UI jank when parent state updates every 91 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-008 — useCallback scenario #8

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 7 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-009 — useCallback scenario #9

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 20 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-010 — useCallback scenario #10

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 33 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-011 — useCallback scenario #11

Level: Advanced
User-visible symptom: UI jank when parent state updates every 46 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-012 — useCallback scenario #12

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 59 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-013 — useCallback scenario #13

Level: Beginner
User-visible symptom: UI jank when parent state updates every 72 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-014 — useCallback scenario #14

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 85 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-015 — useCallback scenario #15

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 1 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-016 — useCallback scenario #16

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 14 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-017 — useCallback scenario #17

Level: Advanced
User-visible symptom: UI jank when parent state updates every 27 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-018 — useCallback scenario #18

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 40 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-019 — useCallback scenario #19

Level: Beginner
User-visible symptom: UI jank when parent state updates every 53 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-020 — useCallback scenario #20

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 66 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-021 — useCallback scenario #21

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 79 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-022 — useCallback scenario #22

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 92 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-023 — useCallback scenario #23

Level: Advanced
User-visible symptom: UI jank when parent state updates every 8 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-024 — useCallback scenario #24

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 21 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-025 — useCallback scenario #25

Level: Beginner
User-visible symptom: UI jank when parent state updates every 34 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-026 — useCallback scenario #26

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 47 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-027 — useCallback scenario #27

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 60 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-028 — useCallback scenario #28

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 73 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-029 — useCallback scenario #29

Level: Advanced
User-visible symptom: UI jank when parent state updates every 86 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-030 — useCallback scenario #30

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 2 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-031 — useCallback scenario #31

Level: Beginner
User-visible symptom: UI jank when parent state updates every 15 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-032 — useCallback scenario #32

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 28 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-033 — useCallback scenario #33

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 41 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-034 — useCallback scenario #34

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 54 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-035 — useCallback scenario #35

Level: Advanced
User-visible symptom: UI jank when parent state updates every 67 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-036 — useCallback scenario #36

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 80 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-037 — useCallback scenario #37

Level: Beginner
User-visible symptom: UI jank when parent state updates every 93 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-038 — useCallback scenario #38

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 9 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-039 — useCallback scenario #39

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 22 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-040 — useCallback scenario #40

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 35 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-041 — useCallback scenario #41

Level: Advanced
User-visible symptom: UI jank when parent state updates every 48 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-042 — useCallback scenario #42

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 61 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-043 — useCallback scenario #43

Level: Beginner
User-visible symptom: UI jank when parent state updates every 74 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-044 — useCallback scenario #44

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 87 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-045 — useCallback scenario #45

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 3 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-046 — useCallback scenario #46

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 16 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-047 — useCallback scenario #47

Level: Advanced
User-visible symptom: UI jank when parent state updates every 29 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-048 — useCallback scenario #48

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 42 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-049 — useCallback scenario #49

Level: Beginner
User-visible symptom: UI jank when parent state updates every 55 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-050 — useCallback scenario #50

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 68 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-051 — useCallback scenario #51

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 81 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-052 — useCallback scenario #52

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 94 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-053 — useCallback scenario #53

Level: Advanced
User-visible symptom: UI jank when parent state updates every 10 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-054 — useCallback scenario #54

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 23 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-055 — useCallback scenario #55

Level: Beginner
User-visible symptom: UI jank when parent state updates every 36 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-056 — useCallback scenario #56

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 49 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-057 — useCallback scenario #57

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 62 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-058 — useCallback scenario #58

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 75 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-059 — useCallback scenario #59

Level: Advanced
User-visible symptom: UI jank when parent state updates every 88 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-060 — useCallback scenario #60

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 4 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-061 — useCallback scenario #61

Level: Beginner
User-visible symptom: UI jank when parent state updates every 17 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-062 — useCallback scenario #62

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 30 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-063 — useCallback scenario #63

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 43 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-064 — useCallback scenario #64

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 56 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-065 — useCallback scenario #65

Level: Advanced
User-visible symptom: UI jank when parent state updates every 69 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-066 — useCallback scenario #66

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 82 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-067 — useCallback scenario #67

Level: Beginner
User-visible symptom: UI jank when parent state updates every 95 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-068 — useCallback scenario #68

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 11 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-069 — useCallback scenario #69

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 24 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-070 — useCallback scenario #70

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 37 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-071 — useCallback scenario #71

Level: Advanced
User-visible symptom: UI jank when parent state updates every 50 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-072 — useCallback scenario #72

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 63 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-073 — useCallback scenario #73

Level: Beginner
User-visible symptom: UI jank when parent state updates every 76 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-074 — useCallback scenario #74

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 89 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-075 — useCallback scenario #75

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 5 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-076 — useCallback scenario #76

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 18 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-077 — useCallback scenario #77

Level: Advanced
User-visible symptom: UI jank when parent state updates every 31 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-078 — useCallback scenario #78

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 44 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-079 — useCallback scenario #79

Level: Beginner
User-visible symptom: UI jank when parent state updates every 57 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-080 — useCallback scenario #80

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 70 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-081 — useCallback scenario #81

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 83 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-082 — useCallback scenario #82

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 96 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-083 — useCallback scenario #83

Level: Advanced
User-visible symptom: UI jank when parent state updates every 12 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-084 — useCallback scenario #84

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 25 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-085 — useCallback scenario #85

Level: Beginner
User-visible symptom: UI jank when parent state updates every 38 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-086 — useCallback scenario #86

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 51 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-087 — useCallback scenario #87

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 64 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-088 — useCallback scenario #88

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 77 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-089 — useCallback scenario #89

Level: Advanced
User-visible symptom: UI jank when parent state updates every 90 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-090 — useCallback scenario #90

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 6 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-091 — useCallback scenario #91

Level: Beginner
User-visible symptom: UI jank when parent state updates every 19 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-092 — useCallback scenario #92

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 32 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-093 — useCallback scenario #93

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 45 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-094 — useCallback scenario #94

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 58 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-095 — useCallback scenario #95

Level: Advanced
User-visible symptom: UI jank when parent state updates every 71 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-096 — useCallback scenario #96

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 84 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-097 — useCallback scenario #97

Level: Beginner
User-visible symptom: UI jank when parent state updates every 0 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-098 — useCallback scenario #98

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 13 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-099 — useCallback scenario #99

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 26 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-100 — useCallback scenario #100

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 39 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-101 — useCallback scenario #101

Level: Advanced
User-visible symptom: UI jank when parent state updates every 52 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-102 — useCallback scenario #102

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 65 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-103 — useCallback scenario #103

Level: Beginner
User-visible symptom: UI jank when parent state updates every 78 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-104 — useCallback scenario #104

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 91 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-105 — useCallback scenario #105

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 7 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-106 — useCallback scenario #106

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 20 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-107 — useCallback scenario #107

Level: Advanced
User-visible symptom: UI jank when parent state updates every 33 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-108 — useCallback scenario #108

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 46 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-109 — useCallback scenario #109

Level: Beginner
User-visible symptom: UI jank when parent state updates every 59 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-110 — useCallback scenario #110

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 72 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-111 — useCallback scenario #111

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 85 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-112 — useCallback scenario #112

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 1 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-113 — useCallback scenario #113

Level: Advanced
User-visible symptom: UI jank when parent state updates every 14 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-114 — useCallback scenario #114

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 27 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-115 — useCallback scenario #115

Level: Beginner
User-visible symptom: UI jank when parent state updates every 40 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-116 — useCallback scenario #116

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 53 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-117 — useCallback scenario #117

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 66 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-118 — useCallback scenario #118

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 79 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-119 — useCallback scenario #119

Level: Advanced
User-visible symptom: UI jank when parent state updates every 92 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-120 — useCallback scenario #120

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 8 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-121 — useCallback scenario #121

Level: Beginner
User-visible symptom: UI jank when parent state updates every 21 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-122 — useCallback scenario #122

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 34 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-123 — useCallback scenario #123

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 47 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-124 — useCallback scenario #124

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 60 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-125 — useCallback scenario #125

Level: Advanced
User-visible symptom: UI jank when parent state updates every 73 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-126 — useCallback scenario #126

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 86 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-127 — useCallback scenario #127

Level: Beginner
User-visible symptom: UI jank when parent state updates every 2 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-128 — useCallback scenario #128

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 15 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-129 — useCallback scenario #129

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 28 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-130 — useCallback scenario #130

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 41 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-131 — useCallback scenario #131

Level: Advanced
User-visible symptom: UI jank when parent state updates every 54 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-132 — useCallback scenario #132

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 67 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-133 — useCallback scenario #133

Level: Beginner
User-visible symptom: UI jank when parent state updates every 80 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-134 — useCallback scenario #134

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 93 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-135 — useCallback scenario #135

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 9 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-136 — useCallback scenario #136

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 22 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-137 — useCallback scenario #137

Level: Advanced
User-visible symptom: UI jank when parent state updates every 35 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-138 — useCallback scenario #138

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 48 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-139 — useCallback scenario #139

Level: Beginner
User-visible symptom: UI jank when parent state updates every 61 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-140 — useCallback scenario #140

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 74 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-141 — useCallback scenario #141

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 87 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-142 — useCallback scenario #142

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 3 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-143 — useCallback scenario #143

Level: Advanced
User-visible symptom: UI jank when parent state updates every 16 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-144 — useCallback scenario #144

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 29 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-145 — useCallback scenario #145

Level: Beginner
User-visible symptom: UI jank when parent state updates every 42 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-146 — useCallback scenario #146

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 55 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-147 — useCallback scenario #147

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 68 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-148 — useCallback scenario #148

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 81 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-149 — useCallback scenario #149

Level: Advanced
User-visible symptom: UI jank when parent state updates every 94 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-150 — useCallback scenario #150

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 10 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-151 — useCallback scenario #151

Level: Beginner
User-visible symptom: UI jank when parent state updates every 23 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-152 — useCallback scenario #152

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 36 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-153 — useCallback scenario #153

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 49 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-154 — useCallback scenario #154

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 62 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-155 — useCallback scenario #155

Level: Advanced
User-visible symptom: UI jank when parent state updates every 75 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-156 — useCallback scenario #156

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 88 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-157 — useCallback scenario #157

Level: Beginner
User-visible symptom: UI jank when parent state updates every 4 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-158 — useCallback scenario #158

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 17 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-159 — useCallback scenario #159

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 30 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-160 — useCallback scenario #160

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 43 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-161 — useCallback scenario #161

Level: Advanced
User-visible symptom: UI jank when parent state updates every 56 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-162 — useCallback scenario #162

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 69 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-163 — useCallback scenario #163

Level: Beginner
User-visible symptom: UI jank when parent state updates every 82 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-164 — useCallback scenario #164

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 95 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-165 — useCallback scenario #165

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 11 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-166 — useCallback scenario #166

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 24 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-167 — useCallback scenario #167

Level: Advanced
User-visible symptom: UI jank when parent state updates every 37 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-168 — useCallback scenario #168

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 50 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-169 — useCallback scenario #169

Level: Beginner
User-visible symptom: UI jank when parent state updates every 63 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-170 — useCallback scenario #170

Level: Beginner+
User-visible symptom: UI jank when parent state updates every 76 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-171 — useCallback scenario #171

Level: Intermediate
User-visible symptom: UI jank when parent state updates every 89 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Use reducer patterns to batch updates and reduce handler fan-out.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-172 — useCallback scenario #172

Level: Intermediate+
User-visible symptom: UI jank when parent state updates every 5 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Add tests for stale-closure bugs when tightening deps.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-173 — useCallback scenario #173

Level: Advanced
User-visible symptom: UI jank when parent state updates every 18 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Move handler closer to state owner; avoid threading callbacks through many layers.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

UCB-174 — useCallback scenario #174

Level: Advanced+
User-visible symptom: UI jank when parent state updates every 31 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Document which props must be referentially stable as part of component API contracts.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: useCallback preserves function identity; it does not magically reduce work inside the function.

UCB-175 — useCallback scenario #175

Level: Beginner
User-visible symptom: UI jank when parent state updates every 44 ms in a dense dashboard.
Profiler hint: child subtree commits repeatedly while props look “unchanged” to humans.
Root cause class: Child memo sees new function prop each parent render due to inline lambda.
Primary remediation: Stabilize with useCallback when a child is proven memo-hot; otherwise simplify props.
Verification: capture before/after Profiler flamegraphs; watch self time and render counts.
Interview one-liner: Prefer fewer prop-drilled callbacks via composition or event buses for rare cases.

<< 2.16 Overview

2.16.c — useCallback: stable function references