"Subscribe" has two answers — the vanilla Redux API and the React way — and a good answer covers both.

Vanilla Redux — store.subscribe

The store exposes a low-level subscription API:

const unsubscribe = store.subscribe(() => {
  console.log("state changed:", store.getState());
});
// later:
unsubscribe();

subscribe(listener) registers a callback fired after every dispatched action, and returns an unsubscribe function. Note it doesn't tell you what changed — you call getState() and diff yourself. You rarely use this directly in a React app.

The React way — useSelector

With react-redux, you don't manually subscribe. You:

1. Wrap the app in <Provider store={store}> — this makes the store available via context and manages subscriptions.
2. In a component, call useSelector:

function Counter() {
  const value = useSelector((state) => state.counter.value);
  const dispatch = useDispatch();
  return <button onClick={() => dispatch(increment())}>{value}</button>;
}

useSelector subscribes the component to the store under the hood. After every dispatch it runs your selector, compares the result to the previous one (strict === by default), and re-renders only if that slice changed. So a component re-renders for the data it actually reads — not for every action.

Key points to mention

• Selector granularity — select the smallest slice you need. Selecting a whole object (or returning a new object/array each call) defeats the === check and causes extra re-renders. Use shallowEqual or memoized selectors (reselect / createSelector) for derived data.
• Cleanup is automatic — useSelector unsubscribes on unmount; manual store.subscribe must be unsubscribed yourself.
• Modern internals — react-redux uses React's useSyncExternalStore to subscribe safely and tear-free with concurrent rendering.

The framing

"Vanilla Redux gives you store.subscribe(listener), which fires on every action and returns an unsubscribe function — but in React you almost never use it directly. You wrap the app in <Provider> and use useSelector, which subscribes the component to the store, re-running your selector after each dispatch and re-rendering only when the selected slice changes by reference. The skill is writing narrow selectors so that comparison actually saves renders."