🎁 Cosden Code now has a free tier
I opened up a new free tier of Cosden Code, The first two lessons of every module are now free so people can get a real feel for the platform, the teaching style, the built-in IDE, and the AI mentor, before going further. It's meant to be hands-on from day one, try it yourself before committing (no credit card required), especially with TypeScript, projects, and a ton of new courses dropping early this year.

🧱 Building Type-Safe Compound Components
Compound components are powerful, but only when you pick the right abstraction. This article breaks down when compound components actually make sense, why Select-style APIs are often the wrong example, and how fixed layout or dynamic data should push you toward props or slots instead. The real payoff comes in the second half, where it walks through a TypeScript-first pattern for building truly type-safe compound components using a factory approach that preserves flexibility without sacrificing inference.

🦥 Why Your React App Feels Slow
This Reddit post digs into why React apps can feel slow even after adding memo everywhere. The discussion quickly converges on a shared takeaway, memoization is rarely the first fix - issues like state living too high, wide re-renders, list rendering without virtualization, and network waterfalls tend to dominate real-world profiles. Replies add concrete examples (virtualized lists, localized state, selector-based stores) and reinforce a common theme, fix render cost and data flow before fighting rerenders.

🫱 Data Fetching Patterns in React Server Components
This is a clear, practical walkthrough of how data fetching actually changes with React Server Components, and why the old “fetch in useEffect” mental model breaks down at scale. It contrasts CSR, SSR, and RSC through real request timelines, then digs into where data should live, how to avoid waterfalls and hydration bloat, and when to rely on framework deduplication vs React’s cache(). The most useful part is the pattern breakdown for server-owned, client-owned, and shared data, with concrete guidance on props, Context, server actions, and query hydration. If you’re building with RSC and still unsure why things feel faster (or heavier), this article is a really good read.

👀 How React Server Components Actually Work
Dan Abramov introduces RSC Explorer, a hands-on tool that lets you step through how React Server Components actually work under the hood. Instead of abstract diagrams, it visualizes the RSC protocol in real time, showing how JSX streams from server to client, how Suspense fills in “holes,” and how server actions and refreshes preserve client state.

➡ Theo moved T3 Chat off of NextJS and onto TanStack Start
Theo breaks down why he moved T3 Chat off Next.js and onto TanStack Start. The discussion taps into a broader shift some teams are feeling. Interestingly, this mirrors a similar decision I made with Cosden Code also recently migrating to TanStack Start after hitting comparable constraints. You can check my version of the video below!

In this video, I'm going to share with you the result of my migration from Next.js to Tanstack Start on my new platform, Cosden Code. I'm happy to say that the migration was successful and my app is much better off with Tanstack.

Migrating from Next.js to TanStack Start means going from a server-first framework to a client-first framework. Instead of fetching your data in server components and everything being asynchronous, you're working with client components and React Query.

Ultimately, the choice of framework completely depends on the application that you're building and what your needs actually are. For my specific use case, Tanstack Start is a much better fit.

Quick Links

🧠 The Missing Skill for Using Coding Agents Well
This essay explores why some developers get outsized value from coding agents while others bounce off them entirely, and argues the difference isn’t the model, but the user. Using a week-long example, it shows how agents excel at incremental work but fall apart without clear constraints, feedback loops, and context. The big takeaway is that effective agent use looks a lot like good engineering, breaking problems into steps, defining what “done” means, and letting reality push back.

🕺 Why Building for the Web Feels Fun Again
This is a reflective take on how modern web development grew more complex than any one person could comfortably hold, and how AI has shifted that balance back. Mattias argues that tools like Claude and Codex don’t remove standards or judgment, they restore leverage, letting solo developers span frontend, backend, and infra again without drowning in tooling.

🦁 How Twitch Tamed a Million Lines of TypeScript
This is a rare, concrete look at how engineering standards actually break down at scale, even with TypeScript, linting, tests, and ownership in place. Drawing from Twitch’s million-line monorepo, Josh shows how exceptions quietly accumulate. The core idea isn’t stricter rules, but making deviations explicit, reviewable, and part of a feedback loop. If you’ve ever wondered how big teams keep code quality, give this quick post a read.

🔎 How To Review Code
This is a long-earned perspective on what code reviews are actually for once you move past syntax and style. Drawing on decades of experience, Matthias reframes reviews as systems thinking, risk management, and communication, not line by line critique. The emphasis is on naming, architecture, and saying “no” when it matters, while staying respectful and constructive. If you want reviews that improve codebases and teams over time, not just merge PRs faster, read this post.

📖 The Prompt Engineering Playbook for Programmers
This is a practical field guide to working effectively with AI coding assistants, written for developers who want reliability, not magic. Addy breaks prompt engineering down into repeatable patterns for debugging, refactoring, and building features, showing why context, constraints, and iteration matter more than clever wording. The throughline is clear, AI works best when treated like a junior engineer that needs clear goals, examples, and feedback loops.