Episode 2 — React Frontend Architecture NextJS / 2.13 — Global State Management

2.13.e — Avoiding overengineered state logic

<< 2.13 Overview

Learning outcomes

  1. Name smells of over-abstraction in state code.
  2. Refactor toward boring maintainable patterns under time pressure.
  3. Write a short ADR for state boundaries your team agrees on.

Smells

  • Abstraction with one usage site (generic “state engine” used once).
  • Sync useEffect chains keeping two stores aligned.
  • Impossible onboarding: new hire cannot trace how a button updates the screen.
  • Global state for values that never leave one file.

Refactor playbook

  1. Identify the smallest owner for each piece of state.
  2. Move read paths first; keep writes behind one function per domain.
  3. Delete unused layers; add tests around the new boundary.

Team practices

  • State review in PR template (local vs global justification).
  • Examples in repo: one golden pattern for modals, one for filters.

Appendix — Scenario bank (basic → advanced)

Each card: symptom → cause → fix → interview phrase. Drill five cards daily and explain aloud without reading.

GS4-001 — Overengineering #1

  • Level: Beginner
  • Symptom: subtree re-renders 13% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-002 — Overengineering #2

  • Level: Beginner+
  • Symptom: subtree re-renders 26% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-003 — Overengineering #3

  • Level: Intermediate
  • Symptom: subtree re-renders 39% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-004 — Overengineering #4

  • Level: Intermediate+
  • Symptom: subtree re-renders 52% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-005 — Overengineering #5

  • Level: Advanced
  • Symptom: subtree re-renders 65% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-006 — Overengineering #6

  • Level: Advanced+
  • Symptom: subtree re-renders 78% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-007 — Overengineering #7

  • Level: Beginner
  • Symptom: subtree re-renders 91% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-008 — Overengineering #8

  • Level: Beginner+
  • Symptom: subtree re-renders 104% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-009 — Overengineering #9

  • Level: Intermediate
  • Symptom: subtree re-renders 117% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-010 — Overengineering #10

  • Level: Intermediate+
  • Symptom: subtree re-renders 130% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-011 — Overengineering #11

  • Level: Advanced
  • Symptom: subtree re-renders 143% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-012 — Overengineering #12

  • Level: Advanced+
  • Symptom: subtree re-renders 156% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-013 — Overengineering #13

  • Level: Beginner
  • Symptom: subtree re-renders 169% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-014 — Overengineering #14

  • Level: Beginner+
  • Symptom: subtree re-renders 182% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-015 — Overengineering #15

  • Level: Intermediate
  • Symptom: subtree re-renders 195% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-016 — Overengineering #16

  • Level: Intermediate+
  • Symptom: subtree re-renders 8% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-017 — Overengineering #17

  • Level: Advanced
  • Symptom: subtree re-renders 21% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-018 — Overengineering #18

  • Level: Advanced+
  • Symptom: subtree re-renders 34% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-019 — Overengineering #19

  • Level: Beginner
  • Symptom: subtree re-renders 47% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-020 — Overengineering #20

  • Level: Beginner+
  • Symptom: subtree re-renders 60% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-021 — Overengineering #21

  • Level: Intermediate
  • Symptom: subtree re-renders 73% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-022 — Overengineering #22

  • Level: Intermediate+
  • Symptom: subtree re-renders 86% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-023 — Overengineering #23

  • Level: Advanced
  • Symptom: subtree re-renders 99% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-024 — Overengineering #24

  • Level: Advanced+
  • Symptom: subtree re-renders 112% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-025 — Overengineering #25

  • Level: Beginner
  • Symptom: subtree re-renders 125% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-026 — Overengineering #26

  • Level: Beginner+
  • Symptom: subtree re-renders 138% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-027 — Overengineering #27

  • Level: Intermediate
  • Symptom: subtree re-renders 151% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-028 — Overengineering #28

  • Level: Intermediate+
  • Symptom: subtree re-renders 164% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-029 — Overengineering #29

  • Level: Advanced
  • Symptom: subtree re-renders 177% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-030 — Overengineering #30

  • Level: Advanced+
  • Symptom: subtree re-renders 190% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-031 — Overengineering #31

  • Level: Beginner
  • Symptom: subtree re-renders 3% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-032 — Overengineering #32

  • Level: Beginner+
  • Symptom: subtree re-renders 16% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-033 — Overengineering #33

  • Level: Intermediate
  • Symptom: subtree re-renders 29% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-034 — Overengineering #34

  • Level: Intermediate+
  • Symptom: subtree re-renders 42% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-035 — Overengineering #35

  • Level: Advanced
  • Symptom: subtree re-renders 55% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-036 — Overengineering #36

  • Level: Advanced+
  • Symptom: subtree re-renders 68% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-037 — Overengineering #37

  • Level: Beginner
  • Symptom: subtree re-renders 81% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-038 — Overengineering #38

  • Level: Beginner+
  • Symptom: subtree re-renders 94% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-039 — Overengineering #39

  • Level: Intermediate
  • Symptom: subtree re-renders 107% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-040 — Overengineering #40

  • Level: Intermediate+
  • Symptom: subtree re-renders 120% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-041 — Overengineering #41

  • Level: Advanced
  • Symptom: subtree re-renders 133% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-042 — Overengineering #42

  • Level: Advanced+
  • Symptom: subtree re-renders 146% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-043 — Overengineering #43

  • Level: Beginner
  • Symptom: subtree re-renders 159% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-044 — Overengineering #44

  • Level: Beginner+
  • Symptom: subtree re-renders 172% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-045 — Overengineering #45

  • Level: Intermediate
  • Symptom: subtree re-renders 185% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-046 — Overengineering #46

  • Level: Intermediate+
  • Symptom: subtree re-renders 198% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-047 — Overengineering #47

  • Level: Advanced
  • Symptom: subtree re-renders 11% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-048 — Overengineering #48

  • Level: Advanced+
  • Symptom: subtree re-renders 24% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-049 — Overengineering #49

  • Level: Beginner
  • Symptom: subtree re-renders 37% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-050 — Overengineering #50

  • Level: Beginner+
  • Symptom: subtree re-renders 50% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-051 — Overengineering #51

  • Level: Intermediate
  • Symptom: subtree re-renders 63% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-052 — Overengineering #52

  • Level: Intermediate+
  • Symptom: subtree re-renders 76% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-053 — Overengineering #53

  • Level: Advanced
  • Symptom: subtree re-renders 89% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-054 — Overengineering #54

  • Level: Advanced+
  • Symptom: subtree re-renders 102% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-055 — Overengineering #55

  • Level: Beginner
  • Symptom: subtree re-renders 115% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-056 — Overengineering #56

  • Level: Beginner+
  • Symptom: subtree re-renders 128% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-057 — Overengineering #57

  • Level: Intermediate
  • Symptom: subtree re-renders 141% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-058 — Overengineering #58

  • Level: Intermediate+
  • Symptom: subtree re-renders 154% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-059 — Overengineering #59

  • Level: Advanced
  • Symptom: subtree re-renders 167% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-060 — Overengineering #60

  • Level: Advanced+
  • Symptom: subtree re-renders 180% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-061 — Overengineering #61

  • Level: Beginner
  • Symptom: subtree re-renders 193% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-062 — Overengineering #62

  • Level: Beginner+
  • Symptom: subtree re-renders 6% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-063 — Overengineering #63

  • Level: Intermediate
  • Symptom: subtree re-renders 19% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-064 — Overengineering #64

  • Level: Intermediate+
  • Symptom: subtree re-renders 32% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-065 — Overengineering #65

  • Level: Advanced
  • Symptom: subtree re-renders 45% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-066 — Overengineering #66

  • Level: Advanced+
  • Symptom: subtree re-renders 58% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-067 — Overengineering #67

  • Level: Beginner
  • Symptom: subtree re-renders 71% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-068 — Overengineering #68

  • Level: Beginner+
  • Symptom: subtree re-renders 84% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-069 — Overengineering #69

  • Level: Intermediate
  • Symptom: subtree re-renders 97% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-070 — Overengineering #70

  • Level: Intermediate+
  • Symptom: subtree re-renders 110% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-071 — Overengineering #71

  • Level: Advanced
  • Symptom: subtree re-renders 123% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-072 — Overengineering #72

  • Level: Advanced+
  • Symptom: subtree re-renders 136% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-073 — Overengineering #73

  • Level: Beginner
  • Symptom: subtree re-renders 149% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-074 — Overengineering #74

  • Level: Beginner+
  • Symptom: subtree re-renders 162% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-075 — Overengineering #75

  • Level: Intermediate
  • Symptom: subtree re-renders 175% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-076 — Overengineering #76

  • Level: Intermediate+
  • Symptom: subtree re-renders 188% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-077 — Overengineering #77

  • Level: Advanced
  • Symptom: subtree re-renders 1% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-078 — Overengineering #78

  • Level: Advanced+
  • Symptom: subtree re-renders 14% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-079 — Overengineering #79

  • Level: Beginner
  • Symptom: subtree re-renders 27% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-080 — Overengineering #80

  • Level: Beginner+
  • Symptom: subtree re-renders 40% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-081 — Overengineering #81

  • Level: Intermediate
  • Symptom: subtree re-renders 53% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-082 — Overengineering #82

  • Level: Intermediate+
  • Symptom: subtree re-renders 66% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-083 — Overengineering #83

  • Level: Advanced
  • Symptom: subtree re-renders 79% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-084 — Overengineering #84

  • Level: Advanced+
  • Symptom: subtree re-renders 92% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-085 — Overengineering #85

  • Level: Beginner
  • Symptom: subtree re-renders 105% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-086 — Overengineering #86

  • Level: Beginner+
  • Symptom: subtree re-renders 118% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-087 — Overengineering #87

  • Level: Intermediate
  • Symptom: subtree re-renders 131% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-088 — Overengineering #88

  • Level: Intermediate+
  • Symptom: subtree re-renders 144% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-089 — Overengineering #89

  • Level: Advanced
  • Symptom: subtree re-renders 157% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-090 — Overengineering #90

  • Level: Advanced+
  • Symptom: subtree re-renders 170% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-091 — Overengineering #91

  • Level: Beginner
  • Symptom: subtree re-renders 183% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-092 — Overengineering #92

  • Level: Beginner+
  • Symptom: subtree re-renders 196% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-093 — Overengineering #93

  • Level: Intermediate
  • Symptom: subtree re-renders 9% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-094 — Overengineering #94

  • Level: Intermediate+
  • Symptom: subtree re-renders 22% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-095 — Overengineering #95

  • Level: Advanced
  • Symptom: subtree re-renders 35% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-096 — Overengineering #96

  • Level: Advanced+
  • Symptom: subtree re-renders 48% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-097 — Overengineering #97

  • Level: Beginner
  • Symptom: subtree re-renders 61% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-098 — Overengineering #98

  • Level: Beginner+
  • Symptom: subtree re-renders 74% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-099 — Overengineering #99

  • Level: Intermediate
  • Symptom: subtree re-renders 87% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-100 — Overengineering #100

  • Level: Intermediate+
  • Symptom: subtree re-renders 100% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-101 — Overengineering #101

  • Level: Advanced
  • Symptom: subtree re-renders 113% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-102 — Overengineering #102

  • Level: Advanced+
  • Symptom: subtree re-renders 126% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-103 — Overengineering #103

  • Level: Beginner
  • Symptom: subtree re-renders 139% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-104 — Overengineering #104

  • Level: Beginner+
  • Symptom: subtree re-renders 152% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-105 — Overengineering #105

  • Level: Intermediate
  • Symptom: subtree re-renders 165% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-106 — Overengineering #106

  • Level: Intermediate+
  • Symptom: subtree re-renders 178% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-107 — Overengineering #107

  • Level: Advanced
  • Symptom: subtree re-renders 191% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-108 — Overengineering #108

  • Level: Advanced+
  • Symptom: subtree re-renders 4% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-109 — Overengineering #109

  • Level: Beginner
  • Symptom: subtree re-renders 17% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-110 — Overengineering #110

  • Level: Beginner+
  • Symptom: subtree re-renders 30% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-111 — Overengineering #111

  • Level: Intermediate
  • Symptom: subtree re-renders 43% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-112 — Overengineering #112

  • Level: Intermediate+
  • Symptom: subtree re-renders 56% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-113 — Overengineering #113

  • Level: Advanced
  • Symptom: subtree re-renders 69% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-114 — Overengineering #114

  • Level: Advanced+
  • Symptom: subtree re-renders 82% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-115 — Overengineering #115

  • Level: Beginner
  • Symptom: subtree re-renders 95% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-116 — Overengineering #116

  • Level: Beginner+
  • Symptom: subtree re-renders 108% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-117 — Overengineering #117

  • Level: Intermediate
  • Symptom: subtree re-renders 121% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-118 — Overengineering #118

  • Level: Intermediate+
  • Symptom: subtree re-renders 134% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-119 — Overengineering #119

  • Level: Advanced
  • Symptom: subtree re-renders 147% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-120 — Overengineering #120

  • Level: Advanced+
  • Symptom: subtree re-renders 160% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-121 — Overengineering #121

  • Level: Beginner
  • Symptom: subtree re-renders 173% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-122 — Overengineering #122

  • Level: Beginner+
  • Symptom: subtree re-renders 186% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-123 — Overengineering #123

  • Level: Intermediate
  • Symptom: subtree re-renders 199% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-124 — Overengineering #124

  • Level: Intermediate+
  • Symptom: subtree re-renders 12% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-125 — Overengineering #125

  • Level: Advanced
  • Symptom: subtree re-renders 25% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-126 — Overengineering #126

  • Level: Advanced+
  • Symptom: subtree re-renders 38% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-127 — Overengineering #127

  • Level: Beginner
  • Symptom: subtree re-renders 51% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-128 — Overengineering #128

  • Level: Beginner+
  • Symptom: subtree re-renders 64% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-129 — Overengineering #129

  • Level: Intermediate
  • Symptom: subtree re-renders 77% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-130 — Overengineering #130

  • Level: Intermediate+
  • Symptom: subtree re-renders 90% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-131 — Overengineering #131

  • Level: Advanced
  • Symptom: subtree re-renders 103% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-132 — Overengineering #132

  • Level: Advanced+
  • Symptom: subtree re-renders 116% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-133 — Overengineering #133

  • Level: Beginner
  • Symptom: subtree re-renders 129% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-134 — Overengineering #134

  • Level: Beginner+
  • Symptom: subtree re-renders 142% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-135 — Overengineering #135

  • Level: Intermediate
  • Symptom: subtree re-renders 155% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-136 — Overengineering #136

  • Level: Intermediate+
  • Symptom: subtree re-renders 168% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-137 — Overengineering #137

  • Level: Advanced
  • Symptom: subtree re-renders 181% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-138 — Overengineering #138

  • Level: Advanced+
  • Symptom: subtree re-renders 194% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-139 — Overengineering #139

  • Level: Beginner
  • Symptom: subtree re-renders 7% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-140 — Overengineering #140

  • Level: Beginner+
  • Symptom: subtree re-renders 20% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-141 — Overengineering #141

  • Level: Intermediate
  • Symptom: subtree re-renders 33% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-142 — Overengineering #142

  • Level: Intermediate+
  • Symptom: subtree re-renders 46% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-143 — Overengineering #143

  • Level: Advanced
  • Symptom: subtree re-renders 59% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-144 — Overengineering #144

  • Level: Advanced+
  • Symptom: subtree re-renders 72% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-145 — Overengineering #145

  • Level: Beginner
  • Symptom: subtree re-renders 85% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-146 — Overengineering #146

  • Level: Beginner+
  • Symptom: subtree re-renders 98% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-147 — Overengineering #147

  • Level: Intermediate
  • Symptom: subtree re-renders 111% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-148 — Overengineering #148

  • Level: Intermediate+
  • Symptom: subtree re-renders 124% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-149 — Overengineering #149

  • Level: Advanced
  • Symptom: subtree re-renders 137% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-150 — Overengineering #150

  • Level: Advanced+
  • Symptom: subtree re-renders 150% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-151 — Overengineering #151

  • Level: Beginner
  • Symptom: subtree re-renders 163% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-152 — Overengineering #152

  • Level: Beginner+
  • Symptom: subtree re-renders 176% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-153 — Overengineering #153

  • Level: Intermediate
  • Symptom: subtree re-renders 189% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Premature micro-stores per component reconciled by sync effects (double truth).
  • Primary remediation: Pick one source of truth; delete sync effects after migration.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-154 — Overengineering #154

  • Level: Intermediate+
  • Symptom: subtree re-renders 2% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Abstraction layers (useStoreFacadeFactory) unreadable to new hires.
  • Primary remediation: Template repos reviewed quarterly; remove unused slices and deps.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-155 — Overengineering #155

  • Level: Advanced
  • Symptom: subtree re-renders 15% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Redux middleware chain for a prototype with three screens.
  • Primary remediation: ADR for state boundaries; onboarding doc with examples.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-156 — Overengineering #156

  • Level: Advanced+
  • Symptom: subtree re-renders 28% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: FSM library introduced for a two-state toggle.
  • Primary remediation: Use boolean state or simple reducer until complexity proves itself.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-157 — Overengineering #157

  • Level: Beginner
  • Symptom: subtree re-renders 41% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Every team invents a new state taxonomy without design review.
  • Primary remediation: Start with Context or colocated hooks; migrate when pain is measured.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

GS4-158 — Overengineering #158

  • Level: Beginner+
  • Symptom: subtree re-renders 54% more than expected after a small unrelated UI change.
  • Architecture smell: unclear ownership of who may mutate shared state.
  • Root cause class: Copy-paste Redux Toolkit setup from blog without deleting unused boilerplate.
  • Primary remediation: Prefer boring patterns with grep-friendly names over clever meta-programming.
  • Proof: React DevTools highlight updates; split providers and re-measure.
  • Interview one-liner: The best state architecture is the simplest one the whole team can maintain under pressure.

<< 2.13 Overview