Redux at Scale with Mark Erikson

🎧 New Señors @ Scale Episode

This week, I sat down with Mark Erikson, the maintainer of Redux — one of the most widely used state management libraries in the JavaScript ecosystem — and a senior front-end engineer at Replay.io, where he works on a time-traveling debugger. Mark got his first computer, a 286, when he was eight years old, played games and learned DOS all through junior high and high school, but never actually touched programming until a freshman C++ class hooked him. He spent four years teaching English in China after college, then landed at Northrop Grumman in 2008 working on embedded software, and a chain of projects led him through GWT, jQuery, and Backbone all the way to React and Redux.

In this episode, we dig into the @deprecated backlash that had people insulting him on the internet, why the Redux core hasn't meaningfully changed since 2016, what RTK Query actually solves, the listener middleware he's most proud of, the time he built source maps into React's own build pipeline, and how Replay's time-travel recordings now let AI agents solve test failures in minutes.

⚙️ Main Takeaways

1. A non-linear path from a 286 to maintaining Redux

Mark can point to the exact sequence of events that made him who he is today.

• The late start: He got a 286 at eight, played games, learned DOS, built computers all through school — and checked out a Learn C++ in 21 Days book from the library two or three times without ever opening it. Programming didn't click until a freshman C++ class in college.
• The detour: Four years teaching English in China after graduating, with nothing to do with programming, then his first full-time job at Northrop Grumman in Dayton in 2008, working on embedded software that emulated legacy CPUs in old aircraft.
• The turning point: In May 2009 he got pulled onto a project with a senior dev named Judd, who became a mentor. That led to a chain — GWT (a Java-to-JavaScript compiler), then jQuery, then Backbone, then React, then Redux — and "none of that would have happened if I hadn't been assigned to that project back in 2009."

2. The circle of what you know vs. the infinite circle of everything

A clean mental model for impostor syndrome and the Dunning-Kruger curve.

• The Venn diagram: Mark visualizes knowledge as a circle of what you know inside the much bigger circle of all programming knowledge.
• The paradox of growth: His circle today is "drastically bigger" than after his first classes 20-some years ago — but the more he learns, the more he realizes the outer circle is infinitely big, so what he knows is a "very, very tiny amount" by comparison.
• The honest admission: Mark feels like he sometimes lacks experience others have — he's never worked on an e-commerce site or anything with millions of users, mostly internal tools with hundreds of users that feel like desktop apps living in a browser.

3. Maintaining a widely used library is a job of many hats

Redux has always been a free-time project, never directly tied to his day job (until Replay created a natural overlap).

• The talk: Mark has given a talk a few times called Maintaining a Library in a Community — "a grab bag of things I've learned as a maintainer."
• The hats: Building features, fixing bugs, documentation, developer relations, customer support, setting the roadmap, prioritizing what to work on.
• The pressure: Users complain loudly. "It is experience driving a real project responding to user needs and trying to build it and maintain it over time."

4. The @deprecated backlash of spring 2022

The story that still sticks in his head as his "favorite slash least favorite example."

• The intent: Redux Toolkit had been out a couple of years, but people in bootcamps or following 2017 tutorials never saw the docs. So Mark marked the original createStore as @deprecated — it wouldn't break anything, just show a strike-through in the editor pointing people to the modern, better way.
• The reaction: People started yelling at him on GitHub, Twitter, and Reddit. Someone said, "You just want people to use your library instead of Dan Abramov's library."
• The rebuttal: Dan created Redux but worked on it for one year. Mark has shipped every release of Redux, Redux Toolkit, and React Redux in the six-plus years since. "Do I not have the right to say, I think this is the best way to use the library that I've built?"

5. What Redux is and why the community overused it

A short history for listeners outside the React ecosystem.

• The origin: React shipped in 2013 as just the view layer. Facebook hit trouble keeping data in sync (the classic notification-count-not-matching bug), introduced the Flux pattern, but didn't ship a full library. In 2015 Dan Abramov built Redux as a conference demo to show time travel plus Flux — people loved it, and by the end of 2015 it had killed off the other Flux libraries.
• What it does: Holds the global state used widely across components, provides patterns for how state updates and how those updates get triggered, plus dev tools showing every action, what it contained, and the resulting state — "both architectural consistency and better visibility into what was happening and why."
• The overuse: Like most shiny things, people shoved it everywhere it shouldn't go — including directly controlling form inputs from the store, "a horrible idea." A few years later everyone realized they'd used it in too many places and now had to maintain that code.

6. Redux Toolkit is the answer to the boilerplate complaints

The first-party library built on top of the core in 2018-19.

• The reframe: RTK looked at all the common problems people had, all the third-party libraries they'd built to solve them, and baked standardized solutions in — simplifying store creation, reducers and immutable updates, data fetching, and side effects.
• Pick and choose: "It's still Redux. It's still the same logic. You can migrate incrementally, but it is the better, simpler, you know, rails guarded kind of way to use Redux."
• The default: Mark rewrote the tutorials in 2020 to teach RTK as the default, and it's now the standard for building Redux apps.

7. The core gets nothing — and that's the point

A misconception worth addressing: Redux is not as verbose as the 2017 mindset assumes.

• The deliberate trade-off: Redux was never designed to be the absolute shortest way to write state updates. There's deliberate indirection — dispatch an action from the UI, keep the reducer logic separate — so you always know where to look for how data updates.
• The Zustand comparison: A typical Zustand store and a Redux Toolkit slice are "probably about the same number of lines of code." Redux's context provider, often seen as overhead, makes it easy to swap stores in tests without components caring.
• A frozen core: Redux core shipped v4 around 2018 and didn't ship v5 until December 2023 — and that was only for ESM/CommonJS compatibility and a TypeScript migration. "Nothing about the Redux core has meaningfully changed since like 2016, which makes sense because it's a really tiny library."

8. Framework agnostic in two senses

Both yes and no, in different ways.

• The runtime: Redux and Redux Toolkit are plain JavaScript and run anywhere a JS engine runs. Mark has seen them used with Vue, Angular 1, Angular 2, jQuery, Lit, web components — "it's really just an event emitter you subscribe to."
• The official adapter: React Redux is the only adapter the team officially maintained — until Corbett Crutchley joined the maintainers about a year and a half ago, having built his own Vue and Angular adapters, which now live under the Redux NPM namespace.
• The Vue lineage: Vuex took inspiration from Redux back in 2016-17, went through a few versions, and was deprecated in favor of Pinia.

9. RTK Query solves the one thing 95% of side effects actually are

The big addition to the ecosystem — which Mark didn't even build.

• The credit: His co-maintainer Lenz Weber built RTK Query. It traces back to the observation that "95% of side effects in applications are really just, I want to fetch data from the server and cache it."
• The motivation: People were tweeting that switching to React Query let them delete five to ten thousand lines of Redux code — "probably accurate." Tanner's point landed: caching server state is its own problem space deserving purpose-built tools.
• The design choices: Built on Redux Toolkit's existing pieces (async thunks, createSlice). Unlike React Query, you define a fetchBaseQuery once and endpoints pass arguments to it; it supports OpenAPI code generation that auto-generates typed endpoint definitions from a schema. Underneath it doesn't even require HTTP — it just calls an async function and tracks the promise.

10. The listener middleware is the underused gem he's proudest of

The feature that took over two years to design.

• The gap: Thunks are imperative — "just run this function, whatever it does, do it right now" — with no way to respond to dispatched actions. Sagas (generators) and observables (RxJS) cover that, but "no one knows how to read and understand RxJS code in the first place."
• The design goal: A built-in way to wait for an action, respond to it, and run side-effect logic — but mentally easier, with simpler-looking, understandable code.
• What it does: Register a handler matching a single action type, a range, or an arbitrary callback inspecting current and previous state. The effect body is like a thunk with getState and dispatch, plus async lifecycle tools like condition to pause until something you care about happens. "90% of the things that were possible with the Redux Saga library, but in a much smaller bundle size." He wrote a whole blog post on the two-year API design journey.

11. Building source maps into React's own build pipeline

A technical accomplishment Mark ties straight back to Replay.

• The problem: React never shipped source maps for production artifacts. Up through v18, dev builds were readable, but production was always pre-minified via the closure compiler — so stepping into React's internals while debugging a production app was hopeless.
• The fix: About three years ago, Mark updated React's rollup-based build pipeline to include source maps. The PR sat for eight months, Dan Abramov glanced at it then left the team, and it finally merged mid-React-19 dev cycle — then Andrew Clark reverted it a few months later in favor of unminified-but-optimized production artifacts.
• The backport: Mark backported the changes to React 18.3.1, 18.2, and 17.0.2, building those versions with source maps and publishing them as an NPM package with Webpack and Rollup plugins. Sentry was very happy — real stack traces from inside React itself.

12. Replay records the whole browser — and now hands it to agents

How a time-travel debugger works and where it's headed.

• The mechanism: Replay records the entire browser talking to the OS — user inputs, network requests, OS random calls, file reads and writes — like a seeded random number generator that makes the whole run reproducible. Recording overhead is roughly 10% slower than standard Chrome.
• Inspect like a DVR: Once recorded, you can fast-forward, rewind, and pause to inspect the DOM, React component tree, Redux actions, and how many times each line of source got hit. Replay starts a copy of the browser in the cloud and forks paused child processes at each point in time.
• Turning it over to AI: Replay shipped Replay MCP so agents can open the same time-travel recordings. Mark built a recording-overview tool that surfaces everything up front — frameworks and versions, which Playwright tests passed/failed, error messages, Redux actions, network requests, render counts. In one test, an agent went from messing around for 10-15 minutes to finding a findDOMNode is not a function error (from React Transition Group on React 19) "in like a minute or two."

🧠 What I Learned

• Mark's whole career traces to one project assignment in May 2009 at Northrop Grumman and a mentor named Judd — GWT led to jQuery led to Backbone led to React led to Redux.
• The "circle of what you know vs. the infinite circle of all knowledge" is a clean model: your knowledge grows, but the gap to everything-out-there only feels bigger.
• Maintaining a widely used library means wearing many hats — features, bugs, docs, devrel, support, roadmap — and absorbing very loud user complaints.
• The spring 2022 @deprecated on createStore was meant to gently point people to Redux Toolkit, and it triggered a wave of online abuse.
• Redux started as a 2015 conference demo for time travel plus Flux, and by year's end had killed off the other Flux libraries.
• Redux got overused — including directly driving form inputs from the store, which Mark calls "a horrible idea."
• Redux Toolkit (2018-19) baked in standardized solutions to the boilerplate complaints and is now the default; the tutorials were rewritten in 2020 to teach it first.
• The Redux core hasn't meaningfully changed since 2016 — v5 in December 2023 was only about ESM/CommonJS and a TypeScript migration.
• Redux is framework agnostic (it's basically an event emitter), and there are now official Vue and Angular adapters via Corbett Crutchley.
• RTK Query, built by Lenz Weber, targets the fact that 95% of side effects are just "fetch data and cache it" — with OpenAPI codegen and a fetchBaseQuery you define once.
• The listener middleware took over two years to design and aims to cover 90% of Redux Saga's use cases in a much smaller bundle with an easier-to-understand API.
• Mark built source maps into React's own build pipeline, got it merged, saw it reverted, then backported and published the work for React 18 and 17.
• Replay records the whole browser with ~10% overhead, and Replay MCP now lets AI agents investigate test failures and suggest fixes in minutes.

💬 Favorite Quotes

"My circle of what I know today is of course drastically bigger than it was after my first set of classes 20 some years ago. But now I realize that the circle of all programming knowledge is infinitely big."

"You just want people to use your library instead of Dan Abramov's library. And like, wait, wait, a minute. Dan created Redux, but he only worked on it for one year. I have worked on it at the time for the six plus years since then."

"Do I not have the right to say, I think this is the best way to use the library that I've built?"

"It's still Redux. It's still the same logic. You can migrate incrementally, but it is the better, simpler, you know, rails guarded kind of way to use Redux."

"Nothing about the Redux core has meaningfully changed since like 2016, which makes sense because it's a really tiny library."

"95% of side effects in applications are really just, I want to fetch data from the server and cache it."

"No one knows how to read and understand RxJS code in the first place."

🎯 Also in this Episode

• The graph of programming confidence — you think you know everything at the start, then realize you know less the more you learn
• Mark's internships: writing scripts for a company in North Carolina and building his own HTML editor for the Windows Mobile Pocket PC platform
• The notification button count bug at Facebook that motivated the Flux pattern
• The recurring "this new library just killed Redux" Twitter cycle, once or twice a week for a while
• Pinia replacing Vuex, and Dan's chat with Pinia's creator about how nicely it fits the Vue use case
• Andrew Clark reverting the React source maps PR in favor of unminified-but-optimized production artifacts
• Replay's end-to-end test product, GitHub comment bot, and the new MVP agent that auto-investigates failing tests and suggests (or even pushes) fixes
• Dan Abramov's useDeferredValue bug that Claude couldn't crack until Andrew Clark gave a hint — and Mark's agent solving it in 10 minutes with a Replay recording
• Nadia Makarevic's "Debugging with AI" blog post with three intentional bugs as an agent benchmark
• Sci-fi swap: the Honor Harrington series by David Weber ("the more exploding starships, the better the book"), The Expanse, Dune (which Dan never enjoyed), the Mass Effect video game series, and Firefly
• The unsettling realization that debugging — the thing we thought AI wouldn't take — is coming for us too

Resources

More from Mark & the Redux ecosystem:

• Redux Toolkit — The official, opinionated, batteries-included toolset for Redux
• Redux — The core library and documentation
• Mark's blog — isquaredsoftware, where the listener middleware and other deep-dive posts live
• Replay.io — Time-travel debugging that records the whole browser
• RTK Query — Built into Redux Toolkit for data fetching and caching (built by Lenz Weber)
• Redux listener middleware — Mark's preferred, underused side-effects API
• Replay MCP — Lets AI agents open and inspect time-travel recordings
• Nadia Makarevic's "Debugging with AI" blog post — three intentional bugs as an agent benchmark

Books and games mentioned:

• The Honor Harrington series by David Weber
• The Expanse
• Dune
• The Mass Effect video game series
• Firefly

🎧 Listen Now

🎧 Spotify
📺 YouTube
🍏 Apple Podcasts

Episode Length: 57 minutes on Redux's history, Redux Toolkit, RTK Query, the listener middleware, building source maps into React, and how time-travel recordings hand debugging over to AI agents.

Whether you're using Redux today, wondering whether you still should, or just curious how one person maintains a library for millions of developers in their free time, this conversation has something immediately actionable.

Happy debugging,
Dan