Developer Way

How to turn a real-world 300k-line codebase into an AI-friendly playground, where AI coders ship features and engineers don't go insane.

What are AI tools and agents really, and how do they keep Context in check?

How does AI actually remember things between messages, and why does it forget halfway through?

Can AI actually debug complex React/Next.js issues?

Can React Server Actions replace fetch for client-side data fetching?

A practical guide to analyzing and reducing JavaScript bundle size.

A data-driven comparison of CSR, SSR, and RSC under the same app and test setup, focusing on initial-load performance and the impact of client- vs server-side data fetching (including Streaming + Suspense).

Learn how to manage state in modern React apps, what is remote, URL, local, and shared state, and when you actually need a state management library.

Why do we need Context/Redux/Zustand in React, what is the purpose of Local Storage, its limitations, and when to use it.

Investigating performance of Tailwind vs Linaria frameworks, with a focus on initial load and interaction performance.

Explore step-by-step how Server-Side Rendering (SSR), pre-rendering, hydration, and Static Site Generation (SSG) work in React, their costs, performance impact, benefits, and trade-offs.

Intro to Performance Flame Graphs.

Exploring Core Web Vitals, Chrome performance panel, what initial load performance is, which metrics measure it, and how cache control and different networking conditions influence it.

Exploring the impact of React Compiler on initial load and interaction performance.

My step-by-step process for implementing a new feature from an idea to a production-ready solution using Modal Dialog as an example.

Investigating CSS animations in React by building some useful components like slide-in drawers, expandable search field, and fancy hover effects.

Looking into what the new CSS :has selector is and how it can be used to improve our React code.

Investigating whether we can forget about memoization in React, now that the React Compiler is open-sourced.

Did you know that React Compiler is not actually React 19?

Looking into what React Concurrent Rendering is, what hooks like useTransition and useDeferredValue do, what are the benefits and downsides of using them.

Deep dive into closures in JavaScript and React: how they appear, why we need them, what stale closures are, and how to prevent and fix them in React

How CSS positioning works, what is Stacking Context, how to escape overflow:hidden with CSS, why we can't do everything with CSS and need Portals, how Portals work

Looking in detail into how React reconciliation algorithm works.

How to change elements base on DOM measurements: what is the problem with useEffect, how useLayoutEffect fixes it, what is browser painting, and how SSR plays a role here

Looking into why we need access to DOM in React, how Refs can help with that, what are useRef, forwardRef and useImperativeHandle hooks, and how to use them properly.

Looking into how to catch and handle errors in React: usages, patterns and caveats of try/catch and ErrorBoundary, what's possible, what's not, and how to catch async errors with ErrorBoundary

Deep dive into debounce and throttle in React.

Deep dive into Promises and data fetching in React: what is a Promise, how and why Promises can cause race conditions and what to do about it.

Deep dive into data fetching in React.

Sneak peek behind the scenes.

Looking into PureComponent and the problem it solved, how it can be replaced now in the hooks & functional components world, and discovering an interesting quirk of React re-renders behavior

React re-renders "cheatsheet".

Looking into what is React Element, exploring various children vs parents relationship in React, and how they affect re-renders

What is the purpose of useMemo and useCallback hooks, mistakes and best practices in using them, and why removing most of them might be a good idea.

How to organize React projects in a way that is scalable, structured, modular, consistent and logical.

Looking into how React "key" attribute works, how to use it correctly, how to improve performance of lists with it, and why array index as key is a good idea sometimes

What is components composition?

Looking into how refs work when not attached to DOM and how to use them to implement advanced usePrevious hook to get the previous state or props value.

What is a React higher-order component?

Exploring how to pass React components as props, why we would want to do it, and what is the best pattern for the job

De-mystifying Context and its influence on React apps' performance.

Exploring performance implications of custom React hooks and how not to shoot yourself in the foot when writing or using them.

Looking into patterns that lead to poor performance of React apps, why they are bad, and how to recognise and avoid them.

Exploring how to discriminate unions properly and how this pattern can be useful for React developers' everyday professional life.

Learning while coding what is the purpose of exhaustiveness checking, how the narrowing of types works and when typescript enums could be useful.

Diving into advanced typescript concepts and understanding how and why we need things like type guards, keyof, typeof, is, as const and indexed types.

Looking into why we need generics in Typescript, and how to use them to develop re-usable React components.

How would you deal with something like relocating to another country and becoming digital nomad?

A simple trick that allows you to write in typescript and consume right away custom eslint rules.

Those tricks can speed up your yarn install by up to 50%