Episode 2 — React Frontend Architecture NextJS / 2.10 — Advanced Reusability Patterns

2.10.b — Render props pattern: sharing logic through a function prop

Learning outcomes

Implement render props and children as a function variants.
Compare render props to hooks for logic reuse.
Avoid stale closures and unnecessary re-renders.

Shape A — `render` prop

import * as React from "react";

type MouseState = { x: number; y: number };

export function MouseTracker({ render }: { render: (s: MouseState) => React.ReactNode }) {
  const [pos, setPos] = React.useState<MouseState>({ x: 0, y: 0 });

  React.useEffect(() => {
    const onMove = (e: MouseEvent) => setPos({ x: e.clientX, y: e.clientY });
    window.addEventListener("mousemove", onMove);
    return () => window.removeEventListener("mousemove", onMove);
  }, []);

  return <>{render(pos)}</>;
}

Shape B — `children` function

import * as React from "react";

export function Data({ children }: { children: (state: { loading: boolean }) => React.ReactNode }) {
  const [loading, setLoading] = React.useState(true);
  React.useEffect(() => {
    const t = setTimeout(() => setLoading(false), 500);
    return () => clearTimeout(t);
  }, []);
  return <>{children({ loading })}</>;
}

Mental model

The container owns state and side effects; the consumer owns rendering via a function—inversion of control.

Hooks overlap

Many render-prop libraries became useX() hooks exposing the same state machine. Render props remain valuable for:

highly polymorphic rendering without dictating component tree
integrating with non-hook consumers

Appendix — Scenario bank (basic → advanced)

Each card: symptom → cause → fix → interview phrase.

RP1-001 — Render props #1

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 13.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-002 — Render props #2

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 26.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-003 — Render props #3

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 39.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-004 — Render props #4

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 52.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-005 — Render props #5

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 65.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-006 — Render props #6

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 78.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-007 — Render props #7

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 91.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-008 — Render props #8

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 104.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-009 — Render props #9

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 117.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-010 — Render props #10

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 130.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-011 — Render props #11

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 143.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-012 — Render props #12

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 156.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-013 — Render props #13

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 169.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-014 — Render props #14

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 182.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-015 — Render props #15

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 195.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-016 — Render props #16

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 8.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-017 — Render props #17

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 21.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-018 — Render props #18

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 34.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-019 — Render props #19

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 47.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-020 — Render props #20

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 60.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-021 — Render props #21

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 73.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-022 — Render props #22

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 86.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-023 — Render props #23

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 99.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-024 — Render props #24

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 112.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-025 — Render props #25

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 125.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-026 — Render props #26

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 138.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-027 — Render props #27

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 151.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-028 — Render props #28

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 164.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-029 — Render props #29

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 177.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-030 — Render props #30

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 190.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-031 — Render props #31

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 3.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-032 — Render props #32

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 16.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-033 — Render props #33

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 29.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-034 — Render props #34

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 42.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-035 — Render props #35

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 55.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-036 — Render props #36

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 68.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-037 — Render props #37

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 81.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-038 — Render props #38

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 94.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-039 — Render props #39

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 107.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-040 — Render props #40

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 120.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-041 — Render props #41

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 133.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-042 — Render props #42

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 146.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-043 — Render props #43

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 159.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-044 — Render props #44

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 172.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-045 — Render props #45

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 185.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-046 — Render props #46

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 198.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-047 — Render props #47

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 11.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-048 — Render props #48

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 24.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-049 — Render props #49

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 37.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-050 — Render props #50

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 50.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-051 — Render props #51

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 63.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-052 — Render props #52

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 76.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-053 — Render props #53

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 89.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-054 — Render props #54

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 102.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-055 — Render props #55

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 115.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-056 — Render props #56

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 128.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-057 — Render props #57

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 141.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-058 — Render props #58

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 154.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-059 — Render props #59

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 167.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-060 — Render props #60

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 180.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-061 — Render props #61

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 193.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-062 — Render props #62

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 6.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-063 — Render props #63

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 19.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-064 — Render props #64

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 32.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-065 — Render props #65

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 45.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-066 — Render props #66

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 58.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-067 — Render props #67

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 71.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-068 — Render props #68

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 84.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-069 — Render props #69

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 97.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-070 — Render props #70

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 110.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-071 — Render props #71

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 123.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-072 — Render props #72

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 136.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-073 — Render props #73

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 149.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-074 — Render props #74

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 162.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-075 — Render props #75

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 175.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-076 — Render props #76

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 188.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-077 — Render props #77

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 1.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-078 — Render props #78

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 14.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-079 — Render props #79

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 27.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-080 — Render props #80

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 40.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-081 — Render props #81

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 53.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-082 — Render props #82

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 66.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-083 — Render props #83

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 79.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-084 — Render props #84

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 92.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-085 — Render props #85

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 105.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-086 — Render props #86

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 118.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-087 — Render props #87

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 131.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-088 — Render props #88

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 144.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-089 — Render props #89

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 157.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-090 — Render props #90

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 170.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-091 — Render props #91

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 183.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-092 — Render props #92

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 196.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-093 — Render props #93

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 9.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-094 — Render props #94

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 22.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-095 — Render props #95

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 35.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-096 — Render props #96

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 48.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-097 — Render props #97

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 61.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-098 — Render props #98

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 74.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-099 — Render props #99

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 87.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-100 — Render props #100

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 100.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-101 — Render props #101

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 113.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-102 — Render props #102

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 126.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-103 — Render props #103

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 139.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-104 — Render props #104

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 152.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-105 — Render props #105

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 165.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-106 — Render props #106

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 178.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-107 — Render props #107

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 191.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-108 — Render props #108

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 4.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-109 — Render props #109

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 17.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-110 — Render props #110

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 30.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-111 — Render props #111

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 43.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-112 — Render props #112

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 56.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-113 — Render props #113

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 69.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-114 — Render props #114

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 82.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-115 — Render props #115

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 95.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-116 — Render props #116

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 108.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-117 — Render props #117

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 121.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-118 — Render props #118

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 134.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-119 — Render props #119

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 147.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-120 — Render props #120

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 160.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-121 — Render props #121

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 173.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-122 — Render props #122

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 186.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-123 — Render props #123

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 199.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-124 — Render props #124

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 12.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-125 — Render props #125

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 25.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-126 — Render props #126

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 38.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-127 — Render props #127

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 51.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-128 — Render props #128

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 64.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-129 — Render props #129

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 77.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-130 — Render props #130

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 90.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-131 — Render props #131

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 103.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-132 — Render props #132

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 116.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-133 — Render props #133

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 129.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-134 — Render props #134

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 142.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-135 — Render props #135

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 155.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-136 — Render props #136

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 168.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-137 — Render props #137

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 181.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-138 — Render props #138

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 194.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-139 — Render props #139

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 7.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-140 — Render props #140

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 20.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-141 — Render props #141

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 33.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-142 — Render props #142

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 46.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-143 — Render props #143

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 59.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-144 — Render props #144

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 72.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-145 — Render props #145

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 85.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-146 — Render props #146

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 98.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-147 — Render props #147

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 111.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-148 — Render props #148

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 124.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-149 — Render props #149

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 137.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-150 — Render props #150

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 150.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-151 — Render props #151

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 163.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-152 — Render props #152

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 176.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-153 — Render props #153

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 189.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-154 — Render props #154

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 2.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-155 — Render props #155

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 15.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-156 — Render props #156

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 28.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-157 — Render props #157

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 41.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-158 — Render props #158

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 54.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-159 — Render props #159

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 67.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-160 — Render props #160

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 80.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-161 — Render props #161

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 93.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-162 — Render props #162

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 106.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Too many responsibilities in one render-prop container component.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-163 — Render props #163

Level: Beginner
Symptom: confusing devtools component names or ref warnings after refactor 119.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: State lives in parent but render prop child expects stable closure—stale UI.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-164 — Render props #164

Level: Beginner+
Symptom: confusing devtools component names or ref warnings after refactor 132.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop API ambiguous: children vs render prop naming inconsistency.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-165 — Render props #165

Level: Intermediate
Symptom: confusing devtools component names or ref warnings after refactor 145.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Performance: parent re-renders re-invoke render function unnecessarily without split.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-166 — Render props #166

Level: Intermediate+
Symptom: confusing devtools component names or ref warnings after refactor 158.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop used to sneak side effects into render path.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-167 — Render props #167

Level: Advanced
Symptom: confusing devtools component names or ref warnings after refactor 171.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Deeply nested render props create callback pyramid (‘callback hell’ visually).
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

RP1-168 — Render props #168

Level: Advanced+
Symptom: confusing devtools component names or ref warnings after refactor 184.
API symptom: consumers cannot access the right state without importing internals.
Root cause class: Render prop recreated inline causing child pure memo useless.
Primary remediation: Stabilize render prop with useCallback when profiling proves it; split components.
Verify: unit tests + Storybook variants + a11y keyboard path unchanged.
Interview one-liner: Render props invert control: the library calls your function with state, you return UI.

<< 2.10 Overview