Don't Imitate Understand - #2

Hello!

In this second issue of the "Don't Imitate Understand" newsletter you'll get:

Two big pieces of course news
An extension of a discussion of a term I coined that I think is vital in the age of AI-supported software development.
A bunch of interesting links!

Course News

State Management in React

I've opened a pre-sale for a new add-on to Understanding React called Understanding State Management in React.

It will cover the various types of state (like bottom-up, top-down, state machines, server, and more) and dive into the source code of popular state management libraries like Jotai, Zustand, XState, and TanStack Query.

If you already own Understanding React, you can get the add-on here. If you don't own Understanding React, you can get the whole thing bundled here.

The whole course and add-on are on sale for spring as well.

Modern JavaScript Frameworks

I'm excited to announce the waiting list is open for my upcoming course on modern JavaScript frameworks. Hydration, signals, resumability, virtual DOM, SSR, SSG, Routing, RPCs and more.

I wanted to build a course to dive into what these terms really mean. How do they work? How do frameworks implement them, and how will knowing that help you be a better developer?

The idea is not to learn to use a particular framework or library. The goal is ending framework fatigue. I want to help you learn to use any existing or future framework by understanding their core concepts, the problems they are all trying to solve, and become comfortable diving into their source code.

In the course we'll go under-the-hood of React, Vue, Angular, Solid, Svelte, Qwik, Astro, TanStack, and more.

You can join the waiting list to be notified when the course drops.

Entropy Tolerance: Why AI Won't Replace Developers

In my latest blog post, I coined a new term I think is needed in the age of software development with AI. It's an extension of what we talked about in the last newsletter, dealing with the dangers of vibe coding.

Entropy tolerance is how much uncertainty (or AI-generated 'guesswork') a software-supported process can handle.

You can read the blog post for more details, but I wanted to expound more here on why this idea shows that AI and LLMs won't replace developers, and why as a dev you should be thinking about it.

The digital age was brought about because we were able to mathematically prove that a computational machine could consistently (i.e. deterministically) give the same outputs for the same set of inputs.

For that reason, we trust computers with things like airplane autopilots. If the computer randomly did unexpected things, that lack of trust would have prevented the entire digital age.

Yet, we constantly hear talking as if non-deterministic, probabilistic systems (LLMs) will replace developers and deterministic programs. This isn't just wrong; it's dangerous.

There are many processes that we support as developers that have low entropy tolerance. That means that the effects of hallucinations, inconsistencies, and mistakes are intolerable. Imagine if an LLM ran an autopilot and hallucinated that the pilot wanted to go to an incorrect destination…or much worse.

Never forget that LLMs are sophisticated probability-based guessing machines. They don't truly reason. They guess what reasoning would look like. They are not deterministic, no matter how you tune them. That means they are inherently dangerous for use in critical processes.

As developers, we should get really good at using LLMs. They are a productivity super power. But their work needs human checks, and that isn't going away any time soon.

If a designer vibe codes some prototypes of a financial app, that's a process with high entropy tolerance, that's fine. But when it's time to build the financial app? That process has low entropy tolerance. It needs human devs to guide and check an AI's work.

AI simply will not replace developers. That's a mathematical and historical truth. Anyone saying otherwise is talking hype to investors, not to you.

Links

I have a bunch of links for you this time around:

The people who build LLMs don't really understand how they work. LLM decisions aren't currently traceable.
The AI support bot for the popular Cursor IDE hallucinated and lied.
I dropped a new YouTube video on source maps (what they are and how they work) the unsung hero of modern web development.
An interesting web app that shrinks the size of your images, but all locally (nothing sent to a server).
The complexity of modern web frameworks means a greater surface area for possible security problems. Check out the breakdown of a security issue that existed in React Router.
12 principles for building reliable LLM applications.
My recent blog post on doing rapid prototyping using LLMs. I identify a set of 9 principles that together I call GRiP.

That's it for this second issue!

You received this because you either a) signed up for the newsletter directly on tonyalicea.dev or b) get emails from dontimitateunderstand.com. If you enjoy my content, please let other people know about the newsletter! They can sign up here: https://tonyalicea.dev/newsletter/.

Happy coding!

Tony Alicea