2025–2026
1,145 posts
2026 326
October 2026
- 5 prototype stress tests for better UX design
- Jev vs. LLMs: Is the 200x speedup real?
- How to turn regulatory requirements into product requirements
- React Markdown alternatives: Benchmarking 3 streaming renderers
- How do coding agents make TDD more practical?
- Top 5 AI code review tools in 2026
- Are fixed user flows becoming obsolete?
- Teaching AI agents your design system: Building a component contract with Google’s OKF
- Comparing the top React toast libraries [2026 update]
- Can Framer replace your web design stack in 2026?
- How Tecovas automates bug fixes with LogRocket’s Galileo AI
- Goodhart’s Law: How optimizing for metrics can hurt your product
- What is OctaneJS? A compiler-first alternative to React
- The next UX era: 3 big predictions revisited for 2026
- Vercel’s vgpu: A WebGPU library built for AI agents
- Comparing the best Node.js unit testing frameworks
- Exploring the top React date pickers
- AI-first helpdesks: The UX shift businesses can’t ignore
- Traditional GPT vs. looping Transformers: Key differences
- Human-centered design: Principles and applications
- How I stopped hassling my friends to test my apps, and just asked Grok Bot instead
- How PMs can use AI and Markdown to preserve product context
- AI dev tool power rankings & comparison [Oct. 2026]
- Chrome vs. Safari vs. Firefox: AI debugging MCPs tested
- Keeping UX human: Balancing the tradeoffs of AI in design
- 10 React features that let you delete old code in 2026
- Your UX copy style guide has a new audience
- How Meilisearch uses LogRocket’s MCP to improve free trial experience and feature adoption
- The top 10 AI agent frameworks to know in 2026
- How to resolve cross-functional conflict in AI product development
- Choosing the best color combinations for UX design
- Enhancing UX design with lateral thinking techniques
- The 13 best Tailwind CSS component libraries
- Using Jev to route messages and reduce LLM calls
- Why I stopped treating AI adoption like a tool rollout
September 2026
- When prompt boxes fail: Designing AI interfaces around user intent
- Information architecture: A guide for UX designers
- Vibe coding gone wrong: 5 of the biggest vibe coding failures
- Importing Adobe Illustrator files into Figma
- React ViewTransition vs. Motion: Comparing animation approaches
- What growth design actually looks like in 2026
- Using a proto-persona for UX design
- The foldable iPhone: Technical novelty or product innovation?
- How to run a design thinking workshop
- Cline + Ollama: A fully local AI coding agent
- The UX designer’s guide to responsible CRO
- We thought users needed a robo advisor. We were wrong.
- TanStack Charts vs. Recharts vs. Chart.js: I found out which is best
- 10 uncomfortable UX lessons from real design mistakes
- Rust React Compiler vs Babel: Is 10x speed real?
- Agentic AI security: The trade-offs PMs must own before launch
- TanStack Markdown vs react-markdown: Which is better?
- What to do when brand archetypes don’t help you write UX copy
- What is Nub? The Rust toolkit making Node.js 20x faster
- React Native Track Player vs. Expo Audio
- How to define AI features that deliver real user value
- How to find quality UX research participants in the age of AI
- I tested 5 AI tools for refactoring CSS: Here’s what I learned
- 6 alternatives to navigation menus (with real product examples)
- What is a profit and loss (P&L) statement? Examples and template
- The case against intuitive design in enterprise software
- Building a Next.js text summarizer with Trigger.dev and Gemini AI
August 2026
- Building a browser-based receipt scanner with LiteRT.js
- How do you visualize a TypeScript dependency graph?
- 5 Claude Code best practices for senior developers
- Designing products for AI agents: A PM’s guide to agent usability
- Should you ditch Figma for an open-source design tool?
- Skills vs. MCP tools for AI agents: When to use which
- Your React app doesn’t need all that JavaScript
- How I cut down stakeholder rework with better UX storytelling
- How a senior PM uses LogRocket’s MCP to catch bugs before they become support tickets
- cnfast vs cn(): Is the 7x speedup real in React?
- How much AI knowledge do product managers really need?
- Interaction in HCI: Principles, types, and examples
- Building multi-turn AI agents with Genkit’s Agents API
- How to build AI-ready Nuxt apps in 2026
- Why I never skip prototyping anymore
- Building an AI chat app in Nuxt with the Vercel AI SDK and Cloudflare Workers AI
- Where should AI go in your UI? A UX guide to AI feature placement
- Astryx vs. shadcn/ui: Testing Meta’s AI-friendly React design system with Claude Code
- Stop writing AI requirements like traditional product requirements
- How to add a harm score to product prioritization
- 10 best AI agent skills for senior engineers in 2026
- Why Google is probably going to win the AI race
- Best React scheduler component libraries
- How to build a real time voice AI agent in the browser
- How to find the invisible product features users won’t ask for
- How I vibe-coded 2 Chrome extensions without being a developer
- Comparing AI agent sandbox platforms: E2B, Modal, Daytona, and more
- How to use Vercel eve: The Next.js framework for AI agents
- Understanding user stories in UX design: A practical guide
- How to implement JWT authentication in NestJS
July 2026
- A deep dive into React Fiber
- Skybridge: Build ChatGPT apps and MCP connectors
- How AI changed the way I approach design critiques
- Human-in-the-loop AI: Who owns the decision?
- What is the Double Diamond design process?
- Getting started with Meilisearch: A complete guide
- pnpm vs. npm: Which package manager should you use?
- Tailwind CSS vs. StyleX: A real migration with 20 components
- Build a REST API with Node.js, Express, and MySQL
- JWT authentication: Best practices and when to use it
- How to replace screen recordings with Remotion
- How to use Chrome’s Modern Web Guidance to prevent AI agents from writing legacy frontend code
- How to choose and adapt product management frameworks
- Essential GUI design principles for creating intuitive interfaces
- How to clean up AI-generated code with Fallow
- Why I joined the Daily UI challenge after 5 years in UX, and what it taught me
- 3 examples of great login screen designs
- How to secure full-stack projects from NPM attacks
- The top 15 MCP servers for your AI projects
- Designing streaks that drive retention without burning users out
- Skeuomorphism in UX: Definition, examples, and relevance today
- How to use CSS contrast-color() for auto-contrast
- How to build an agent harness with Claude Code
- How to use a technical debt register
- Memo format guide: How to write a memo with examples
- Designing quality signals when AI makes everything look credible
- How to create awesome staggered animations in CSS
- Finding unused and ghost dependencies with Knip
- How to take over an existing product as a product manager
- Storybook MCP for AI-aware component libraries
- A UX designer’s guide to modern inclusive design
- How to fix RSC hydration mismatches in Next.js
- Why evals are essential for AI product managers
June 2026
- Why npm dependencies are a bigger security risk than your code
- I let React Compiler handle memoization: Here’s what actually broke
- What if the research said yes and the product failed anyway?
- TanStack Start RSC vs. Next.js RSC: Performance, DX, and production readiness
- Is the PRD dead? How to choose the right level of documentation
- Introducing self-improving software: LogRocket finds issues, agents fix them
- Frontend Wrapped H1 2026: The nine biggest storylines so far
- I shipped AI-generated React code: 4 bugs I fixed
- AI made design faster, but did it make it less intentional?
- How to build a virtual engineering team with Gemini CLI subagents
- Debug Next.js apps with AI agents and next-browser
- How PMs can use communication and AI to prevent duplicate work
- Full-stack and server-side UX experiments: Testing beyond the frontend
- Stop hardcoding LLM SDKs: Dynamic LLM routing with OpenRouter and Next.js
- What is TSRX?: What JSX would look like if it were designed today
- Why your freemium model has too many conversion points
- Bayesian UX testing: A clearer way to interpret A/B test results
- How to add authentication to a React Native app with Better Auth
- How to check username availability at scale with Bloom filters
- An advanced guide to Nuxt testing and mocking
- How PMs misread acquisition spikes (and what to measure instead)
- Multi-armed bandits in UX experiments: Faster testing with smarter traffic splits
- Introducing the LogRocket MCP: Take the blindfold off your AI agents
- Penguins and pasta: What I learned from making an app in 4 weeks with AI
- Build a headless table engine in Vue 3
- Best React chart libraries in 2026: Features, performance, and use cases
May 2026
- I benchmarked Claude Code and OpenCode on a heavy refactor: The reality of agentic CLI workflows
- The 5 Claude skills for React I can’t live without
- Stop calling product managers “CEOs of the product”
- AI agent simulations for UX testing: When to use simulated vs. real users
- Stop trying to one-shot: How to prompt Claude better
- How to build advanced forms in Next.js using a rule engine
- The human side of AI: A CTO’s take on fear, trust, and identity in the AI age
- A/B testing vs. multivariate testing: When to use each UX testing method
- How to catch the novelty effect in A/B testing
- Context rot is slowing down your AI agent: How to fix it
- TypeScript utility types you’re probably underusing
- Design engineering then vs. now: How AI is reshaping the designer-developer divide
- TypeScript v6 is here: A full migration guide
- Data security blocking AI adoption? A PM playbook
- LaunchPod: How AI Helped Me Ship 9 Months of Product in 5 Days
- Vite+ guide: One CLI for JavaScript tooling
- Why are AI companies buying the teams behind your favorite dev tools?
- AI-assisted development governance: A practical guide
- The project that made me question the UX process
- How to rethink scope creep as strategic flexibility
- LaunchPod: AI Agents Fail for 2 Reasons. Crowdsourcing Solved Both.
- Understanding A/B testing in UX research
- How to build your first MCP server with Node.js
- Using Next.js security headers to strengthen app security
- AI dev tool power rankings & comparison [May 2026]
- Exploring Agent Browser: AI agents on the web
- Friction is a design tool, not a UX problem
- How to write agent-friendly API documentation
April 2026
- How to build a local AI proxy to redact PII before LLMs
- Graph RAG explained: Relationship-aware retrieval
- Is AI making product managers more average?
- Native CSS stagger animations with sibling-index()
- Cross-product navigation is broken — here’s how to fix it
- Why useEffect breaks AI streaming responses in React
- Feature factory vs. product discovery: A 3-lens framework for PMs
- Figma AI in 2026: Everything it can do — and what it still can’t
- What if you could lay out UI without CSS? Meet Pretext
- Why real-time frontends break at scale and how to fix them
- I tested every major auth library for Next.js in 2026: Here’s what you should use
- Why multimodal UX is a more practical future than Zero UI
- LaunchPod: AI Isn’t Breaking PM Teams. Overload is. Explained by Stanford PhD & CPO
- When to move API logic out of Next.js
- Moving beyond CI/CD with Dokploy
- 4 product team structures and when each works best
- Astro vs Next.js: When SSG beats React for content sites
- I replaced my entire test suite with AI agents: Here’s what actually broke
- 5 principles for designing context-aware multimodal UX
- The DX shift no one noticed: Web interoperability
- How PMs can use code-style reasoning to make better decisions
- I let Claude review my PRs: What it caught and missed
- Why CSS art disappeared from frontend culture
- The React pattern everyone uses that quietly kills performance
- How to design seamless context switching in multimodal UX
- 20 free Flutter templates for great mobile apps
- The Replay (4/1/26): Images are slowing your React app, cutting token spend, and more
- How a yes culture breaks prioritization in product teams
- How to optimize images in React for better web performance
March 2026
- vinext explained: Cloudflare’s Vite-based Next.js replacement
- 3 UX research trends product teams can’t ignore in 2026
- How to fix memory leaks in React applications
- How to make your website agent-ready with Google’s Web MCP
- CRUD REST API with Node.js, Express, and PostgreSQL
- Why adding voice isn’t multimodal UX
- The Replay (3/25/26): Senior dev hiring woes, what AI agents miss, and more
- Systems thinking: What PMs can learn from urban planning
- The hidden skills gap in senior dev hiring (and how to screen for it)
- Does the Speculation Rules API boost web speed? I tested it
- Context engineering for IDEs: Agents.md & agent skills
- Exploring Heroku alternatives for deploying Node.js apps
- How to align AI-generated designs with your design system
- Node.js project architecture best practices
- TypeScript at scale in 2026: What senior engineers should know
- The Replay (3/18/26): Hiring in the AI era, coding isn’t dead, and more
- How to stop tracking outputs and start driving outcomes
- Thinking beats coding: How to hire the right engineers in the AI era
- Exploring Vercel’s JSON Render: build dynamic UI from structured data
- Stop wasting money on AI: 10 ways to cut token usage
- Stop fighting forms: The schema-driven approach to validation
- Does splitting work across AI agents actually save time? I tested it.
- The Replay (3/11/26): AI education failures, Prisma Next, and more
- What to do when product-market fit starts to break
- Your engineering team’s AI training is probably failing: How to fix it
- 5 reasons your AI app fails in production (and how to fix it)
- Speed kills: It’s time to retire ESLint and migrate to Oxlint
- Can adaptive interfaces evolve autonomously based on user behavior? What risks come with that?
- Introducing Ask Galileo: AI that answers any question about your users’ experience in seconds
- Why engineering knowledge disappears as teams scale (and how to fight it)
- The LLM context problem in 2026: strategies for memory, relevance, and scale
- Why product managers must become product builders in 2026
- The Replay (3/4/26): Eng knowledge gaps, OpenClaw, and more
- Open Claw, AI agents, and the future of developer workflows
- Headless UI alternatives: Radix Primitives vs. React Aria vs. Ark UI vs. Base UI
- Designing a fully local RAG with small language models setup
February 2026
- 10 usability heuristics for designing secure and frictionless 2FA
- LaunchPod: The $500M Lesson from Amazon’s Homepage Redesign
- How to solve coordination problems in Islands architecture
- Designing account recovery UX for 2FA-protected accounts
- Signal Forms: Angular’s best quality of life update in years
- How PMs can use session replay without violating user privacy
- The Replay (2/25/26): Signal Forms, Ralph to the rescue, and more
- Google & Shopify’s UCP: How AI agents sell online
- 2FA UX patterns: Designing setup flows for SMS, authenticator apps, and biometrics
- 6 React Server Component performance pitfalls in Next.js
- Making sense of web rendering patterns (SSR, CSR, static, islands)
- LaunchPod: Smarter AI Models Won’t Fix Your Deployment
- How to design 2FA: Comparing methods, user flows, and recovery strategies
- CSS @container scroll-state: Replace JS scroll listeners now
- Anti-libraryism: 10 web APIs that replace modern JavaScript libraries
- How developer platforms fail (and how yours won’t)
- The Replay (2/18/26): Copilot workarounds, platform pitfalls, and more
- Can’t use Claude at work? How I recreated “Skills” in GitHub Copilot
- Automation vs. AI: A practical decision framework for PMs
- How Ralph makes Claude Code actually finish tasks
- UI patterns for async workflows, background jobs, and data pipelines
- How to solve package validation pain with Publint
- The Replay (2/11/26): React performance wins, fine-grained frameworks, and more
- A complete guide to React performance optimization
- 3 AI shockwaves reshaping product management in 2026
- Fine Grained Everything, and what comes after React Server Components
- Fortifying your stack with Cloudflare: A security playbook
- From custom integrations to A2UI: A better way to ship agent UIs
- Linear vs. non-linear design: Which is better and when?
- LaunchPod: Using AI to Preserve 140 Years of History at the LA Times
- Linear design vs. minimalism, brutalism, and neumorphism
- LLM routing in production: Choosing the right model for every request
- How do you implement accessible linear design across light and dark modes?
- UX designers don’t need to be data scientists — but they must challenge data
- Remix vs. Next.js vs. SvelteKit
- The Replay (2/4/26): AI-first leadership, Tailwind layoffs, and more
- What it actually means to be an AI-first engineering organization
- Why great product leaders say no (and average ones burn out)
- Which UI libraries/frameworks support the Linear aesthetic?
- Customer vs. user: Why the difference matters in product decisions
- How to build agentic frontend applications with CopilotKit
- Dokploy vs Coolify: Why Dokploy wins in production
- Shadcn UI adoption guide: Overview, examples, and alternatives
January 2026
- Cache components in Next.js: Faster pages with partial pre-rendering
- Implementing local-first agentic AI: A practical guide
- A guide to async/await in TypeScript
- The Replay (1/28/26): Anti-frameworkism, dev superpowers, and more
- How PMs decide on incremental vs. drastic product changes
- Building AI apps that remember: Mem0 vs Supermemory
- How to animate SVG with CSS: Tutorial with examples
- A dev’s guide to Tailwind CSS in 2026
- AI is fast at UX copy — that’s exactly the problem
- Comparing the best React animation libraries for 2026
- Why your AI agent needs a task queue (and how to build one)
- Multi factor authentication design: Security meets usability in UI/UX design
- The Replay (1/21/26): Booming CSS, Tauri 2.0, and more
- CSS in 2026: The new features reshaping frontend development
- How poor chunking increases AI costs and weakens accuracy
- Why AI coding tools shift the real bottleneck to review
- Why most design specs fail developers — and how to fix yours
- Your security team blocked Cursor and Claude Code—time to switch to OpenCode
- How to use React Router v7 in React apps
- What are the key challenges in scaling MFA for large organizations?
- LaunchPod: April Dunford’s 1 Killer Question to Expose Weak AI Product Positioning
- TanStack AI vs. Vercel AI SDK: Choosing the right AI library for React
- Authentication with React Router v7: A complete guide
- A developer’s guide to designing AI-ready frontend architecture
- Build a Next.js 16 PWA with true offline support
- How to design AI features that actually improve user experience
- The Replay (1/14/26): Deterministic agents, Angular v21, and more
- AI-powered Slack workflows for PMs who hate dashboards
- How to build deterministic agentic AI with state machines in n8n
- What are the accessibility considerations when designing MFA?
- 6 fast (native) alternatives for VSCode
- Moving beyond RxJS: A guide to TanStack Pacer
- 19 ChatGPT prompts for faster, better UX research
- The Replay (1/7/26): React’s biggest problem, TanStack’s evolution, and more
- How to stop forgetting your wins and actually get promoted
- React has finally solved its biggest problem: The joys of useEffectEvent
- Don’t ship another chat UI. Build real AI with AG-UI
- Anti-frameworkism: Choosing native web APIs over frameworks
- What are the best authentication methods for modern apps?
2025 819
December 2025
- AI wireframe generators compared: Visily, UX Pilot, Uizard, and Figma Make
- Should you bet on Valdi instead of React Native?
- Why more rules can actually increase team autonomy
- The 8 trends that will define web development in 2026
- AI-first debugging: Tools and techniques for faster root cause analysis
- What are the common security risks in MFA design?
- Container queries in 2026: Powerful, but not a silver bullet
- Server Components vs. Islands Architecture: The performance showdown
- How to build agentic AI when your data can’t leave the network
- How to use AI as a sparring partner in your ideation process
- Frontend Wrapped 2025: The 10 storylines that defined the year
- Getting started with NativeWind: Tailwind for React Native
- The 10 best React Native UI libraries of 2026
- How to type React children correctly in TypeScript
- The complete guide to internationalization in Next.js
- Vite vs. Webpack for react apps in 2025: A senior engineer’s perspective
- Vitest 4 adoption guide: Overview and migrating from Jest
- Types vs. interfaces in TypeScript
- I tested 5 AI CLI tools: Here’s how they stack up
- Designing for dependency management in UX
- The Replay (12/17/25): React2Shell, Shopify Winter ‘26, and more
- How to quickly estimate the revenue impact of new product ideas
- React2Shell exploit: What happened and lessons learned
- Angular vs. React vs. Vue.js: A performance guide for 2026
- Drizzle and React Native (Expo): Local SQLite setup
- 5 weird web APIs that’ll make you fall back in love with the browser
- Is a hero section necessary?
- The state of AI in UX design: What’s working today (and what isn’t)
- The Replay (12/10/25): Fixing AI code, over-engineering JavaScript, and more
- How to use TOON to reduce your token usage by 60%
- Stop trying to be a hero: How delegation makes you a better PM
- Fixing AI-generated code: 5 ways to debug, test, and ship safely
- How to create Liquid Glass effects with CSS and SVG
- tRPC vs oRPC: Which is better for your next TypeScript project, and why?
- A developer’s guide to Antigravity and Gemini 3
- 10 best hero section examples and what makes them effective
- Bun 1.3: Is it time for devs to rethink the Node stack?
- Stop using JavaScript to solve CSS problems
- UX for reversible actions: A decision framework for designing with recovery in mind
- The Replay (12/3/25): React’s next era, AI code review tools, and more
- The next era of React has arrived: Here’s what you need to know
- Why you should treat data as inventory, not infrastructure
- What should be in a hero section?
- Tanstack DB 0.5 Query-Driven Sync: Loading data will never be the same
- Error boundaries are broken – signals can fix them
November 2025
- How to speed up long lists with TanStack Virtual
- Why you should set up CI/CD from day one for your apps
- Top 5 AI code review tools in 2025
- How to create fancy corners using CSS corner-shape
- The Replay (11/26/25): An AI reality check, Prisma v7, and more
- Ripple over React? Evaluating the newest JS framework
- You don’t need AI for everything: A reality check for developers
- UX research sample size: How small is small enough?
- How to ensure your expert C# knowledge doesn’t make you a TypeScript noob
- Slide decks are boring. Here’s how I share ideas instead
- How to scale CSS in micro frontends (without losing your mind)
- How do I make an accessible, performant hero section?
- Is retro design making a comeback?
- What defines 90s website design?
- How can nostalgia improve UX engagement?
- How can designers use retro web aesthetics without hurting usability?
- What is maximalism in 90s web design?
- How did 90s web design influence modern UX?
- 4 Figma AI plugins I use in my day-to-day workflow as a UX designer
- Using retro designs from 90s websites to inspire modern UX
- How to use ChatGPT Atlas for frontend debugging, testing, and more
- Why composition – not reactivity – leads UI’s future
- Not all AI PMs are the same: 5 roles you’ll really see
- The Replay (11/19/25): React 19.2 async, GitHub Octoverse, and more
- React 19.2: The async shift is finally here
- 14 cognitive principles every UX designer should know
- Offline-first frontend apps in 2025: IndexedDB and SQLite in the browser and beyond
- How PMs can build custom AI agents to make life easier
- Real-time AI in Next.js: How to stream responses with the Vercel AI SDK
- How to fix React routing loopholes with the React Router Middleware
- Modal design in UX: When to use them and when to skip them
- How I used Mastra to build a prize-winning RAG agent
- Ensuring frontend data integrity with TanStack DB transactions
- A PM playbook for failing fast: What (and what not) to do
- The Replay (11/12/25): useEffect mistakes, speculation API, and more
- 15 common useEffect mistakes to avoid in your React apps
- How to structure Figma files for MCP and AI-powered code generation
- The next phase of dev: Building for MCP and the open web
- Why traditional SaaS playbooks fail for AI-native products
- You’ve authenticated your user, but have you authorized your agent?
- FTC’s AI chatbot crackdown: A developer compliance guide
- When to use CSS text-wrap: balance vs. text-wrap: pretty
- Remix 3 ditched React: Should you stick with it?
- Autogen vs. Crew AI: Choosing the right agentic framework
- Overusing AI is ruining UX — here’s how to avoid the trap
- Prompt engineering vs. prompt design: The UX perspective on AI personality
- The Replay (11/5/25): Developer elitism, REST APIs, and more
- 5 strategies for managing technical debt before it’s too late
- It’s time to break the cycle of developer elitism
- How to make UX initiatives matter to PMs
- I tried OpenAI’s AgentKit: Does it make Zapier and n8n obsolete?
- A Jarvis for everyone: AI agents as new interfaces
- How to run your AI products like a portfolio, not a project
- Why frontend devs should care about platform engineering
- How I built an AI productivity assistant with Vercel AI Elements
October 2025
- How to use CSS line-clamp to trim lines of text
- 7 custom React Hooks every developer should be using
- How to get engineers involved in product development earlier
- Is Promise.all still relevant in 2025?
- The Replay (10/29/25): Tiny AI agents, Next.js 16, and more
- Next.js 16: What’s new, and what it means for frontend devs
- Is Llama really as bad as people say? I put Meta’s AI to the test
- Small language models: Why the future of AI agents might be tiny
- You’re doing vibe coding wrong: Here’s how to do it right
- Exploring spec-driven development with the new GitHub Spec Kit
- 10 AI prompt templates for better product workshops
- The different ways to use CSS :has() , with examples
- Kombai AI: The AI agent built for frontend development
- Don’t ship blind: A practical checklist for internal launch readiness
- The Replay (10/22/25): AI-assisted coding, Wasm 3.0, and more
- Where AI-assisted coding accelerates development — and where it doesn’t
- Exploring the human-AI balance in UX content design
- Debugging with Chrome DevTools MCP: Giving AI eyes in the browser
- Goodbye, useState? Smarter state modeling for modern React apps
- A guide to balancing strong leadership with a collaborative spirit
- AI meets Apple’s HIG: Actual results from my redesign project
- Why third-party integrations break in React 19 — And how to future-proof them
- React useEffectEvent : Goodbye to stale closure headaches
- I tried Shadcn CLI 3.0 — here’s what I learned
- Why is Zod so slow?
- Why PMs need to master qualitative tests now more than ever
- The Replay (10/15/25): AI’s accessibility problem, React 19.2, and more
- AI has an accessibility problem: What devs can do about it
- Want to run your AI model locally? Here’s what you should know
- Tools and tactics for staying organized as a product manager
- Stop writing REST APIs from scratch in 2025
- Good DX isn’t enough: Why your component library still fails your team
- Building trust into UX: What I learned from Airbnb, PayPal, and more
- The real cost of overpromising on AI and what to do instead
- React 19.2 is here: Activity API, useEffectEvent , and more
- Hooks vs. Signals: The great reactivity convergence explained
- How to decide how deep your UX redesign should go
- Exploring the new Chakra UI MCP Server
- LangChain.js is overrated; Build your AI agent with a simple fetch call
- 5 steps to get your product team back on track
- The Replay (10/8/25): Data enrichment, CSS is back, TypeScript 5.9
- 7+ UX skills that won’t trend on LinkedIn (but will get you hired)
- Goodbye, messy data: An engineer’s guide to scalable data enrichment
- Making a case for slower UX: When to prioritize story over speed
- DesignCoder and the future of AI-generated UI
- Should you use if() functions in CSS?
- Why great narratives beat OKRs in early-stage products
- TypeScript vs Zod: Clearing up validation confusion
- We got Wasm 3.0 before GTA 6: Meet the web’s new engine
- How to use AI to build accurate ShadCN components
- How we turned a broken order form into a 95% ticket reduction
- The best way to structure Rust web services
- How I cut product waste fast with this ECRS workshop
- A spec-first workflow for building with agentic AI
- How to use TanStack DB to build reactive, offline-ready React apps
September 2025
- A step-by-step guide to building a full-stack app with TanStack Start
- Leading the transition from product to platform
- Query strings are underrated: Using the URL as your app’s state container
- Yes, you should upgrade to TypeScript 5.9 — here’s why
- Is Better Auth the key to solving authentication headaches?
- What using a screen reader taught me about real web accessibility
- How the full-stack product lead is changing the industry
- 6 easy ways to level up Claude Code
- Choosing the right React Router v7 mode for your project
- Product-led FinOps: Cut waste, reinvest, and build better
- CSS @function: Dynamic logic without Sass or JavaScript
- Environment-aware model routing: Build smarter AI apps with AI SDK
- React Server Components broke my app and I still don’t know why
- Task switching slowed my users down. Here’s how I fixed it
- How to build smarter frontend chatbots with RAG and LangChain.js
- How to stop being an unintentional bottleneck for your team
- Empty states in UX done right: 4 inspiring examples
- How to stop your AI agents from hallucinating: A guide to n8n’s Eval Node
- Secure your AI-generated projects with these security practices
- Let’s kill vibe coding and bring back prompt engineering
- Why PMs should stop chasing the “right” planning window
- Frontend developers are burned out, not lazy
- Can native web APIs replace custom components in 2025?
- Too many tools: How to manage frontend tool overload
- 5 ways product managers can steward cross-pollination
- I tried Google Stitch. Here’s what I loved (and hated) about it
- What you actually need to build and ship AI-powered apps in 2025
- File-based routing in React Router v7 – Why keep it optional?
- MCP is replacing the browser: Here’s how devs should prepare
- Steal my startup approved growth workshop agenda
- Effective rendering with Selective SSR in TanStack Start
- How Cursor project rules can improve Next.js app development
- 5 support page redesigns that transformed help desk UX
- Don’t vibe code your backend: The hidden dangers of BaaS
- Don’t let AI erase the next generation of dev leaders
- daisyUI 5 is here: What’s new and what to expect
- Building real-time state management with React and Fluent-State
- AI coding tools still suck at context — here’s how to work around it
- The silent shift to Vite: What it means for your stack
- How to consolidate your product management tools
August 2025
- What happens when dev communities die: Stack Overflow’s slow collapse
- How to build a multimodal AI app with voice and vision in Next.js
- How I learned to treat AI like a partner, not a threat
- I tried out Kiro: Here’s what I learned
- Why Go design patterns still matter
- How to define customer segments that actually matter
- How to protect your AI agent from prompt injection attacks
- Stop using templates — do this instead
- Qwen3-Coder: Is this Agentic CLI smarter than senior devs?
- A guide to using AI to drive measurable business value
- Agentic AI for 5x less: Why Kimi K2 is a frontend game-changer
- Motion design is cool, but can hurt users — here’s how I fixed it
- Why you shouldn’t ignore niche app user types
- We asked 200 PMs: Is product management an art or a science?
- Does Gemini CLI fall short? Here’s how Codex compares
- Is Next.js still developer-friendly?
- Using daily quests within your product design to boost retention
- Nuxt 4.0 is here: What’s new and what to expect
- How to make sense of your product data with an evidence map
- Using Grok 4 in the frontend development: Here’s what I’ve learned
- AI personas you can use to support your entire UX process
- The deep internals of event delegation: When bubbling isn’t enough
- AI dev tool power rankings & comparison [August 2025 edition]
- Shipping alone isn’t enough: Here’s how to make your work visible
- Why users ignore notifications (and how to fix it)
- How I use a metrics tree to align, prioritize, and track progress
- React’s use() API is about to make useContext obsolete
- I’ve designed AI assistants — Here’s what actually works
- A guide to designing successful product management workshops
- Fix over-caching with Dynamic IO caching in Next.js 15
- UX analytics changed my career — here’s how it can change yours
- How to build autonomous teams that still see the bigger picture
- LLMs are facing a QA crisis: Here’s how we could solve it
July 2025
- Windsurf vs. Cursor: When to choose the challenger
- The attention crisis: How to lead teams in a 40-second world
- Surprises and trends from this year’s Design Tools Survey results
- Designing AI products that work for both users and the enterprise
- Next.js 15.4 is here: What’s new and what to expect
- Build interactive React UIs for LLM outputs using llm-ui
- How to manage 20+ stakeholders without losing your mind
- Why I think v0 is a great prototyping tool for designers
- How I debug faster with these Chrome DevTools Console features
- Catch frontend issues before users using chaos engineering
- How a UX redesign increased redemptions by over 58 percent
- Deno 2.4 is here: What’s new and what to expect
- Migrating Tanstack Start from Vinxi to Vite
- Why PMs must help architect distribution, not just adapt to it
- What are the AI-proof skills every frontend developer needs?
- Here’s how I’d design a mega menu — with 3 great examples
- Angular has grown up — and the best is yet to come
- 5 books that transformed my day-to-day life as a PM
- Iterator helpers: The most underrated feature in ES2025
- Leader Spotlight: Creating an environment of genuine curiosity, with Nora Keller
- Leader Spotlight: Navigating a complete product redesign, with Tyler Stone
- 12 UX design examples that show how to stop user errors before they happen
- How to build better AI apps in React with MediaPipe’s latest APIs
- AI won’t fix bad thinking — use it to challenge you instead
- How to build unified AI interfaces using the Vercel AI SDK
- How to prep for a software dev interview: Advice from a dev leader
- Leader Spotlight: Building an audience-segmented product strategy, with Chrissie Lamond
- What to do when users just want the old version back
- Next.js real-time video streaming: HLS.js and alternatives
- AI compliance: A core product competency you shouldn’t skip
- Leader Spotlight: Designing for trust and managing user expectations, with Rachel Bentley
- A guide to UX documentation: Recording your design process
- Leader Spotlight: Scaling an ecommerce business within a broader organization, with Michal Ochnicki
- When is low-code the right choice? Here’s how to decide
- Comparing AI app builders — Firebase Studio vs. Lovable vs. Replit
- Leader Spotlight: Building an effortlessly personal healthcare experience, with Christina Valls
- Why I don’t trust WCAG 2.2 and what I’m hoping for from 3.0
- Gemini CLI tutorial — Will it replace Windsurf and Cursor?
- React & TypeScript: 10 patterns for writing better code
- Stress-testing AI products: A red-teaming playbook
- Leader Spotlight: Building a human-focused AI product, with Cory Bishop
- I designed by committee — and here’s what went wrong
- 5 product leaders on reducing friction in mobile-first experiences
- Leader Spotlight: Emphasizing clear, thoughtful documentation, with Jim Naylor
- Designers write good copy — but not the kind users actually need
- A PM’s guide to calculated risk-taking
- Leader Spotlight: Improving predictability using agile, with Emmett Ryan
- Checkbox UI design: Best practices and examples
- A guide to wrapper vs. container classes in CSS
- Leader Spotlight: Balance vs. compromise in product management, with Suvrat Joshi
- How to build a web-based AI agent with Stagehand and Gemini
- I’ve designed with data — here’s what we’re getting wrong
- Getting started with Claude 4 API: A developer’s walkthrough
- Designing drag and drop UIs: Best practices and patterns
- What scarcity taught me about designing for attention
- AI dev tool power rankings & comparison [July 2025 edition]
- Pivot or perish: Why product agility determines market survival
- Leader Spotlight: Human empathy in the age of AI, with Thach Nguyen
- How API client automation can save you hours in development
- Where your focus is actually going (and how to get it back)
- Leader Spotlight: Data-driven vs. human-centered decision making for product design, with Rumana Hafesjee
June 2025
- Adopting Apple’s Liquid Glass: Examples and best practices
- I tried Figma Make — here’s what it gets right (and what’s still broken)
- SOLID series: Understanding the Interface Segregation Principle (ISP)
- Leader Spotlight: Making informed partnership and acquisition decisions, with Trey Courtney
- Leader Spotlight: Adopting and championing responsible AI, with Asma Syeda
- How HTML’s <selectedcontent> element improves dropdowns
- How to get faster data access in Node.js with Valkey
- I’ve designed AI search — here’s what works
- How to properly handle rejected promises in TypeScript
- The most valuable hard skills for product managers in 2025
- Leader Spotlight: Quantifying the unquantifiable, with Paul Weston
- I’ve overdesigned before — here’s what I’ve learned about doing less
- Your AI has agency — here’s how to architect its frontend
- How to future-proof your PM career with emotional intelligence
- Leader Spotlight: Honing a relationship-first mindset, with Lars Rieger
- Leader Spotlight: Embracing lifelong learning, with Jie Cheng
- UX burnout is real — here’s how to spot and prevent it
- How to design apps with Apple Intelligence in mind
- How to optimize your Next.js app with after()
- A complete guide to AdTech for product managers
- Leader Spotlight: Balancing creativity with scalable execution, with Adrienne Wang
- How to design nondestructive cancel buttons
- Design is being devalued — and we’re letting it happen
- JavaScript loops explained, and best practices
- Leader Spotlight: Leading product in a nonprofit organization, with Don Boulia
- 8 reasons your Next.js app is slow — and how to fix them
- How to truncate text in CSS (single and multi-line)
- Leader Spotlight: Balancing trust and speed in digital banking, with Jyoti Menon
- How to use the Interest Invoker API for better, more accessible UX
- How to build and deploy a web app with Bolt
- How agile became a checkbox exercise, and how to get unstuck
- Liquid Glass is here — how should designers respond?
- Frontend devs: Here’s how to get the most out of Cursor
- Lovable AI is blowing up UX workflows — here’s how
- A PM’s guide to handling product crises like a pro
- When to use OpenAI vs. open source LLMs in production
- UX designers vs. developers: Who really owns accessibility (A11y) in UX design?
- Skipping product discovery: When it’s better to go ahead and ship
- Leader Spotlight: Cascading down a product-led culture, with Mike Fantigrassi
- Designing a landing page with the UX rule of thirds
- Fine-tuning vs. RAG: Which AI strategy fits your frontend project?
- Leader Spotlight: Elevating healthcare through evolving technology, with Rob Helton
- 7 common CSS navigation menu mistakes and how to fix them
- If your research isn’t inclusive, neither is your design
- TanStack Start vs. Next.js: Choosing the right full-stack React framework
- Angular v20 might seem boring — Here are 6 reasons it’s not
- How to use AI tools for your customer discovery
- Leader Spotlight: Building a scalable, flexible LMS, with Matthew Pizzi
- A complete guide to UX design techniques
- Vibe-based UI building with Google Stitch — Is this the future of frontend?
- Get Vercel-level deployment without Vercel-level prices
- I asked ChatGPT to help me design — here’s what worked
- Top 5 Next.js alternatives for React developers
- How to define a good retention metric for your product
- Leader Spotlight: The right and wrong approach to product-market fit, with Charlie Kaplan
- What is a toast notification? Best practices for UX
- TanStack Form vs. React Hook Form
- Leader Spotlight: Taking lessons from big tech to healthcare, with Sriharsh Boddapati
- Linear design: The SaaS design trend that’s boring and bettering UI
- What are design constraints? — The power of limitations in design
- SOLID Series: Liskov Substitution Principle (LSP)
- Modern CSS carousels: No JavaScript required
- Leader Spotlight: How digital experiences enhance in-person moments, with Adam Reed
- I used to dread big design projects — until I figured this out
- Six habits that changed my PM-engineering partnerships
- Leader Spotlight: Helping teams navigate personal change, with Alicia Littleton
- Creating a design philosophy — for yourself and for your company
- UXers don’t need to code — but vibe coding might still be worth it
- Leader Spotlight: Creating solutions for both patients and providers, with Daric Snyder
- When to use Flexbox and when to use CSS Grid
- Using CSS breakpoints for fluid, future-proof layouts
- How to use Relume AI to design wireframes fast
- React forwardRef explained: Usage, alternatives, and React 19 update
- How to use the useEffect hook in React: A complete guide
- Improving frontend workflows with in-browser database tools
- Why switching to weekly research sprints was a game-changer
- Leader Spotlight: The components of a good feature brief, with Monique Piras
- How to iterate over enums in TypeScript (with code examples)
- How to import SVGs into your Next.js apps: A 2025 guide
- 10+ ways AI helps me validate ideas without interviews or surveys
- Leader Spotlight: Meeting healthcare consumers where they are, with Aditya Raju
May 2025
- 7 design feedback questions to retire — and what to ask instead
- Designing LLM-first products, not just features
- Leader Spotlight: Optimizing the user journey for automotive customers, with Biren Shah
- 10 UX design challenges to level up your skillset
- Build a React AI image generator with Hugging Face Diffusers
- Gemini 2.5 and the future of AI reasoning for frontend devs
- How AI prototyping tools are changing PM workflows
- Leader Spotlight: Structuring teams around two different user groups, with Espen Scheuer
- Exploring the top Rust web frameworks
- Design debt is slowing you down — even if you don’t see it yet
- How to use the CSS cursor property
- How to build a React + TypeScript app with Vite
- How to use Claude to build a web app
- Enhancing LLMs with function calling and the OpenAI API
- Leader Spotlight: Outcome-driven vs. output-driven product development, with Itzik Mitzmacher
- How to design bottom sheets for optimized user experience
- Tips for design system documentation you’ll actually use
- Top 6 CSS frameworks every frontend developer should know in 2025
- How picking up Canva can level up your PM work
- Leader Spotlight: Being intentional about innovation, with Shayani Roy
- Shadows in UI design: Tips and best practices
- A crash course in Next.js middleware
- How AI is changing debugging with Google Gemini
- 10 Node.js 24 features you’re probably not using
- 6 CSS animation libraries to bring your project to life in 2025
- How AI is changing customer acquisition
- Leader Spotlight: Building and growing a lasting community, with Derek Pharr
- Understanding Next.js’s middleware vulnerability
- UX isn’t complete without content design — here’s why
- What does a UX manager really do?
- How to build a secure file upload system in Astro
- Why no one reads your product docs, and how to fix it
- Leader Spotlight: Re-thinking manual processes with AI, with Jim Ferguson
- Why URL state matters: A guide to useSearchParams in React
- How design specialties can work against your career
- Node.js 24 is here: What’s new and what to expect
- Building an agentic AI workflow with Ollama and React
- 3 case studies of why speed isn’t always best for your product
- Leader Spotlight: Rethinking product discovery in B2B SaaS, with Jean-Yves Simon
- Cookie UX: How to ask users for their cookies
- Monorepos vs. Polyrepos: Which one fits your use case?
- Leader Spotlight: Building trust on both sides of a marketplace, with Joyce Schofield
- Neumorphic design: What it is and how to use it effectively
- SOLID series: The Open-Closed Principle
- AI-powered e2e testing: Getting started with Shortest
- Profit center vs. cost center: How company structure affects engineering
- How UX designers can influence AI behavior (and why they must)
- How to pass a TypeScript function as a parameter
- Create fast, modern API docs using Docusaurus
- A checklist for mastering Expo SDK 53
- How product leaders adapt frameworks like the 5 Whys
- Leader Spotlight: Seeing the art of what’s possible, with Tamara Milne
- How to pick your battles as a designer
- Leveraging Lighthouse audits to optimize web performance
- Async standups: Pros, cons, do they make sense for you?
- Leader Spotlight: Trust as the currency of product management, with Sara Rossio
- Figma Config 2025: What’s new, what’s next, and what you should be doing
- Building multi-region infrastructure with AWS
- The 9 best FaunaDB alternatives for 2025
- PM mentorship: The missing skill in product leadership
- Leader Spotlight: Deriving product strategy from customer listening, with Ezinne Udezue
- 10 usability testing tools for your UX team
- Best design collaboration tools — and how to actually pick one that fits
- React WebSocket tutorial: Real-time messaging with WebSockets and Socket.IO
- Atomic design components in UI design
- React View Transitions and Activity API tutorial: Animate an AirBnB clone
- gRPC vs. REST: Choosing the best API design approach
- Leader Spotlight: Curating the art museum digital experience, with Colin Brooks
- Why some designers stay stuck at mid-level — And the truth about design titles
- Why Go wasn’t the right choice for the TypeScript compiler
- How and when to use type casting in TypeScript
- How to format dates in JavaScript: Methods, libraries, and best practices
- Your MVP didn’t fail; you didn’t set it up to teach you anything
- Leader Spotlight: Engaging and retaining a growing fan base, with Dev Ward
- The anti-persona: Learning from users who churn fast
- How to use the Tailwind Typography plugin
- Running TypeScript in Node.js: tsx vs. ts-node vs. native
- Apple lost to Epic Games: What’s next for mobile products?
- Leader Spotlight: Creating comprehensive product requirements, with Rangarakesh Kanchamreddy
- How to work on great products in low UX maturity environments
- Authentication and authorization in Astro
- How to use custom fonts in Tailwind CSS
- How outlier users spark product breakthroughs
- Leader Spotlight: Structuring unstructured chaos, with Michael Tuccinard
- When feature comparison charts hurt UX — and what to use instead
- Here’s why everyone’s going crazy over Zod 4
- Building functional UI from design mockups with Penpot
- Creating custom mouse cursors with CSS
- Conceptual design: Definition, step-by-step breakdown
- Best JavaScript and HTML5 game engines (updated for 2025)
- Is over-simplified UX making your product boring?
- React Compiler RC: What it means for React devs
- Understanding Anthropic’s Model Context Protocol (MCP)
- Using Uizard Autodesigner 2.0 for fast wireframes
- 9 non-UX skills every UX designer should learn
- Choosing the best access control model for your frontend
- Leader Spotlight: The importance of remaining open-minded, with Aislinn Wright
April 2025
- Applying the UX honeycomb for a modern website
- Will AI take designers’ jobs?
- Is OpenNext really the key to Next.js portability?
- SOLID series: Single Responsibility Principle (SRP)
- How to effectively manage design teams as a PM
- Leader Spotlight: Aligning customer feedback and expectations, with Ryan Poppa
- Axios POST requests: Handling errors, authentication, and best practices
- Creating server-driven web apps with htmx
- Style guide vs. design system: Why the difference matters
- The 9 best Create React App alternatives
- Will AI replace PMs? How to future-proof your role
- Leader Spotlight: How acquisitions are like product management, with Ylang Nguyen
- Designing free trials that actually convert: Personal fav tips
- 6 hidden gems in the JavaScript API you should be using
- Leader Spotlight: Creating a modern customer journey, with Oren Halperin
- How to configure Next.js environmental variables
- useActionState in React: A practical guide with examples
- 15 UX design frameworks: Which to use and when
- Three.js vs. Babylon.js: Which is better for 3D web development?
- Revisiting competitive analysis in the age of AI
- Leader Spotlight: Balancing data with judgement, with Mike Korenugin
- Leader Spotlight: Enabling merchants to make faster, smarter decisions, with Priya Lakshminarayanan
- Designing better tooltips for improved UX
- How to use the Next.js Image component to optimize images
- Fintech UX design: What the best finance apps get right
- The right way to implement AI into your frontend development workflow
- React Hook Form vs. React 19: Should you still use RHF in 2025?
- Leader Spotlight: Hiring and scaling a remote-first team, with Phil Freo
- How to deploy React apps to GitHub Pages
- Leader Spotlight: Customer experience as a non-negotiable for scale, with Nick Fisk
- We can finally move elements in the browser with the moveBefore() API
- Signal vs. noise: How to identify the metrics that truly matter
- Card interface design: Tutorial, examples, and best practices
- UX frameworks lie — Here’s what real users do
- Building responsive websites fast: A Float UI tutorial
- Conducting a UX benchmarking study step by step
- What is glassmorphism? How to create glassmorphic designs
- React-Toastify (2025 update): Setup, styling & real-world use cases
- 5 best open source tools for cross-browser CSS testing
- How to handle data fetching with React Suspense
- Leader Spotlight: Building a partnership between stakeholders and product, with Tony Schumacher
- Users hate waiting: Here’s how to make loading screens a bit enjoyable
- Use TypeScript instead of Python for ETL pipelines
- 4 practical lessons from dealing with feature creep
- Leader Spotlight: Driving initiatives with believers, with Aliza Carpio
- Designing button states: Tutorial and best practices
- Skeleton loading screen design — How to improve perceived performance
- Why typography still matters in UX design
- TypeScript is going Go: Why it’s the pragmatic choice
- 6 retrieval augmented generation (RAG) techniques you should know
- High-performance design teams: Your competitive edge in UX
- How to build cross-platform mobile applications using Lynx.js
- 5 lessons learned from ecommerce product managers
- Leader Spotlight: ‘Keeping it simple is hard, and making it hard is simple,’ with Dipto Chakravarty
- Designing better advanced search UIs: UX best practices
- Why micro-disappointments break UX — and what to do about it
- 40 essential UI elements every UX designer should know
- Struggling with your PDF report workflow? Try this
- A guide to the MUI grid system
- New design patterns for products with AI features
- Using Figma’s auto layout
- Building progressive web apps using Rust
- A guide to using SVGs in React
- Post-churn UX could be your silent growth lever: Here’s how
- What is AI code generation and how does it work?
- A case against MVPs: Why I’ve grown to hate “The Lean Startup”
- Dealing with the challenges of the agile methodology in UX design
- What is vibe coding? And is it worth the hype?
- Level up your TypeScript with Record types
- An introduction to the TanStack Start framework
- 10 Figma courses to advance your UX career
- The ‘real’ designer debate: Why it’s missing the point
- The 10 best AI coding tools for 2025
- Why good intentions can go wrong in product management
- How to add custom fonts in React Native
- Research operations (ResearchOps): Why smarter beats more
- How to use the React useRef Hook effectively
- Better form design: UX tips, tools, and tutorial
- How to eliminate render-blocking resources — CSS and JavaScript
- Mocking complex APIs with Mirage JS
- The 8 best Go web frameworks for 2025: Updated list
- How much choice should we give users in AI-powered designs?
- Game development for frontend: Building with Excalibur.js
- Why you should stop obsessing over story points
- Leader Spotlight: Diving into details without micromanaging, with Noah Manger
- What are affordances in UX design?
- How to conduct a feasibility study: Step-by-step guide with examples
- Flat, brutalist, glassy: Do UX design trends even matter?
- Angular vs. React: Which one should you choose?
- What does keeping the lights on (KTLO) mean?
- Leader Spotlight: Balancing long-term strategy with short-term iterations, with Aslan Sevi
- Axios in JavaScript: How to make GET , POST , PUT , and DELETE requests
- Brand archetype vs. persona: How brand work guides UX design
- How AI is shaping the future of 3D web development
- How to troubleshoot exit code 1 in Docker
- Axios vs. Fetch (2025 update): Which should you use for HTTP requests?
- The future of user experiences: Products without UI
- Leader Spotlight: Leading with authenticity, with Brit Tucker
March 2025
- How to use the Next.js Link component to optimize navigation
- Leader Spotlight: The importance of adopting a dual mindset, with Reeba Mathen
- Using Figma’s instance swap and other component properties
- A complete guide to TanStack Table (formerly React Table)
- JavaScript prototypes: How objects inherit properties and methods
- How to set up TypeScript with Node.js and Express
- Faceted filtering for better ecommerce experiences
- What is the difference between a .ts and .tsx file extension?
- How to use try...catch for error handling in JavaScript
- Balancing process vs. product mindsets for product success
- Leader Spotlight: Fostering authentic relationships, with Michelle Dunivan
- DesignOps explained: Making UX teams work smarter
- Designing for instant feedback: The Doherty Threshold in UX
- Use case template: Downloadable example & how to write one
- What is pair programming – and should you try it?
- Leader Spotlight: Cybersecurity products for enterprises vs. consumers, with Amit Sharma
- Aligning stakeholders with a design kick-off meeting
- How to use docker exec to interact with running containers
- Sources and solutions for handling stakeholder conflicts
- How to use a prioritization matrix to build the right product features
- Leader Spotlight: Thinking from a clinician’s perspective, with Deepti Mehtani
- How to use the array filter() method in JavaScript
- CSS vertical alignment: Best practices and examples
- How to win clients with a Flutter web demo that feels real
- TypeScript is getting a 10x faster compiler — here’s what it means for developers
- Progressive disclosure in UX design: Types and use cases
- Did Duolingo kill UX design? Don’t take it too seriously
- How to manage JavaScript closures in React
- How to use CSS variables like a pro
- An app designer’s guide to responsive mobile UX
- How to make text look clickable: A UX guide
- Will AI take developers’ jobs?
- The build trap: Dangers of a feature factory mindset
- The top 10 React Native charts libraries for 2025
- Retro-futuristic UX designs: Bringing back the future
- Bash vs. Zsh: Key differences and when to use each
- Sample RACI chart: Best practices and downloadable templates
- Leader Spotlight: Effective product management in the media industry, with Mariah Craddick
- Why all designers should learn to facilitate productive conversations
- How to use the Swiper.js slider library
- 4 strategies for AI personalization that actually work
- Leader Spotlight: How improv comedy influences product management, with Kevin Erdner
- Empathy mapping in UX: How to put yourself in users’ shoes
- How to conduct user research for (almost) free
- A complete guide to Fetch API in JavaScript
- A designer’s guide to UX workshop types and how to run them
- Leader Spotlight: The role of storytelling in change management, with Isaac Szymanczyk
- Tree testing: A valuable UX research method
- Eye tracking: A worthwhile investment or an unnecessary expense?
- TypeScript enums: Usage, advantages, and best practices
- Leader Spotlight: Building and maintaining mission-critical software, with Rick Agajanian
- Healthcare UX: Solving design challenges with real-world impact
- How to handle react-scripts in a fast-changing React landscape
- How to delete local and remote branches in Git
- The shift towards using AI in your daily work
- Leader Spotlight: Optimizing conversions and loyalty in beauty brands, with Victoria Katsarou
- Tesler’s Law: The danger of oversimplifying complex products
- The complete guide to the AbortController API
- Beyond chat: Rethinking how we use LLMs
- A guide to building product features users don’t know to ask for
- Leader Spotlight: Guiding decisions with low-lift, low-risk methods, with Whitney Coggeshall
- A guide to image overlays in CSS
- How to use EJS to template your Node.js application
- Dark mode UI design: Best practices and examples
- How to check out a remote branch in Git: A step-by-step guide
- How to build your personal brand as a product manager
- Leader Spotlight: Investing in product-led growth, with Mike Ly
- How to switch Node.js versions: A cross-platform guide for NVM and alternatives
- How to conduct a heuristic evaluation for UX/UI designs
- Sustainable UX: Prioritizing sustainability vs. engagement
- How to install and use NVM
- Leader Spotlight: Shaping product within the cybersecurity space, with Rumna Mishra
- Using contextual inquiry in UX research
- Breaking free from templates in UX design: How to design beyond the obvious
- JavaScript’s sort() method: From basics to custom sorting
- Running a cognitive walkthrough for usability testing: Guide + template
- Optimizing Shopify Checkout with LogRocket session replay
- Migrating to Valkey from Redis
- 3 product management skills to learn in 2025
- What is Fitts’ law? UI examples and best practices
- GraphQL vs. REST APIs: What’s the difference between them
- Storytelling frameworks in UI: Hero’s Journey vs. Pixar
- Generative vs. agentic AI: The next wave of the AI revolution
- Leader Spotlight: Aligning marketing, product, and UX, with Brian Fugere
- Maximalism in UI design: A bold alternative to minimalism
- How to use CSS to hide scrollbars without impacting scrolling
- 16 React component libraries and kits for improved UI
- TypeScript vs. JavaScript: Differences and use cases for each
- Super apps: The ultimate growth playbook or a tech mirage?
- Understanding UUIDs in Node.js
- Pure components in React: Using PureComponent and React.memo
- Object-oriented UX (OOUX): A structured approach to UX design
- Goodbye, Skype: A product insider’s take on the iconic app’s fall
- React Select: A comprehensive guide
- Leader Spotlight: Managing deterministic vs. probabilistic software, with Eugene Mandel
February 2025
- User personas: Common mistakes and how to avoid them
- Build a custom React Native Turbo Module for Android
- Why backlog management is dangerous for most teams
- Leader Spotlight: Evaluating build, buy, or ally decisions, with Brad Power
- How to measure round-trip time (RTT) using cURL
- React.memo explained: When to use it (and when not to)
- React useCallback: When and how to use it for better performance
- What is the virtual DOM in React?
- How T-layouts enhance mobile and responsive web design
- A practical guide to switch statements in JavaScript
- Building a reusable multi-step form with React Hook Form and Zod
- Are you making these 8 mistakes as a product manager?
- Leader Spotlight: Leveraging the best of product and engineering, with Vamsee Chamakura
- JavaScript dictionary: How to use objects and maps for key-value pairs
- Open vs. closed vs. hybrid card sorting for UX research
- A guide to the CSS grid-template-columns property
- Why you should consider talking to non-users for UX research
- A guide to Node.js readable streams
- Will AI agents replace SaaS?
- Leader Spotlight: Improving patient outcomes with healthcare tech, with Matt Moore
- UX user interviews: Tips, best practices, and resources
- Avoiding pitfalls of AI for designers: Guiding principles
- Advanced React state management using URL parameters
- The 10 best Docker alternatives to consider
- Carousel UXs: How and when to use them effectively
- Is your UX team working on the most important research initiatives?
- How to use the ternary operator in JavaScript
- Using tsup to bundle your TypeScript package
- Pagination vs. infinite scroll: Making the right decision for UX
- How to use React higher-order components
- Defining your UX skillset: T-shaped vs. I-shaped vs. M-shaped vs. X-shaped
- Understanding the dependency inversion principle (DIP)
- Building a Telegram bot with grammY
- Frequentist vs. Bayesian statistics for A/B testing
- Leader Spotlight: Innovation in theory vs. in practice, with Luc Lam
- Styling with the CSS box-shadow property
- Adaptive vs. responsive design: Which is better for UX?
- A complete guide to TypeScript enums in React Native
- A guide to measuring invisible product metrics
- Leader Spotlight: The evolution of ecommerce and branding, with Steve Wertz
- 3 ways to implement infinite scroll in React (with code examples)
- Creating React animations in Motion (formerly Framer Motion)
- Toggle button design: Examples and best UI practices
- What are the event loop and call stack in JavaScript?
- Margin of error vs. confidence intervals for data-driven decisions
- React Context tutorial: Complete guide with practical examples
- How and when to use JavaScript arrow functions
- Within vs. between-subjects in UX research design
- How to check for null , undefined , or empty values in JavaScript
- What is the MERN stack? Overview with examples
- Can breadcrumbs replace back arrows in UX design?
- Leveraging parallel computing in Node.js
- A guide to product data management (PDM)
- Leader Spotlight: The role of skepticism and curiosity in product, with Sara Sell
- Search bar UI: Best practices, modern trends, and examples
- A guide to modern frontend architecture patterns
- Managing customer discovery interview data for better insights
- Leader Spotlight: Building technology to advance modern surgery, with Jonathan Conta
- Code to design: Switching up your UX workflow
- A guide to graceful degradation in web development
- When to use continuous discovery vs. research projects
- Natural vs. reverse scrolling: Which scroll direction to use
- The ROI of UX design: What designers need to know about ROI
- Implementing scroll-aware UI state with CSS
- Building high-performance websites using htmx and Go
- How to improve UX with a scroll-select box
- Banish the chaos: Organizing your design system effectively
- Deploying Next.js apps with Deno Deploy
- A guide to leveraging AI for market research
- Debunking your UX user research misconceptions
- A guide to Object.groupBy : An alternative to Array.reduce
- Key fintech terms for product managers
- Best CI/CD tools for React Native
- Leader Spotlight: Overcoming barriers for women in tech, with Anne Baskakova
- Are graphic designers perfect for designing UX?
- How to use Chrome DevTools for API mocking
- The evolving role of healthcare technology product managers
- Leader Spotlight: Breaking down barriers, with Priya Raghunatha
- The UX design process: 7 actionable steps
- Reducing the two UX gulfs: Gulf of execution and gulf of evaluation
- StackAuth: An open source Auth0 alternative
January 2025
- Error message examples: How to craft clear, effective UX messaging
- 25 UX case study examples to inspire your next design project
- How to implement view transitions in multi-page apps
- .NET MAUI 9 brings new improvements to Blazor
- Navigating the drama triangle: Resolving product team conflicts
- Leader Spotlight: Building an organization’s code of conduct, with Maksym Kunytsia
- Top React countdown component libraries
- UX interview vs. UX research questions: Have you been doing it right?
- Implementing React Islands in static web applications
- Page fold UX: Above-the-fold website UX needs to change
- Are agile frameworks doomed?
- Leader Spotlight: Setting career expectations and goals, with Andrew Cheng
- Onlook: A React visual editor
- Site abandonment in UX design: Could it really be good?
- Leader Spotlight: Becoming a UX culture epicenter, with Chris Holland
- React windowing vs. component recycling
- Bite-sized bento grid UX designs: Think outside the lunchbox
- A comprehensive guide to JavaScript generators
- Understanding tones of voice for better UX writing
- Agile Manifesto: The 4 values and 12 principles explained
- Solving micro-frontend challenges with Module Federation
- What is a product wedge? Driving market success
- Leader Spotlight: Showing and proving your value prop, with Mikal Lewis
- Fiedler’s contingency theory of leadership: Definition, examples
- Which icons to NOT use in 2025
- TypeScript object destructuring and you
- Leader Spotlight: Seeing big impacts from small changes, with Jake Sisskind
- How to get started with React-Bootstrap: Tutorial and tips
- How response bias vs. Hawthorne effect impact user research
- Using Firebase for ASP.NET authentication
- Product-led vs. sales-led growth: Choosing the right strategy
- Leader Spotlight: Making global products feel local, with Parminder Mann
- What is quality function deployment? 4 phases and practical examples
- Nuxt state management and hydration with useState
- Fibonacci story points: A practical guide to agile estimation
- Competitive analysis in UX design: Why and how to do it (with templates)
- Leader Spotlight: Bridging product and OEM engineering teams, with Randolph D’Souza
- Sustainable web design trends in digital UX design
- React Native list components: FlashList , FlatList , and more
- Preventing project bloat as a product manager
- Leader Spotlight: Learning how to have hard conversations, with Mahesh Guruswamy
- Designing swipe-to-delete and swipe-to-reveal interactions
- Building an AI agent for your frontend project
- Leader Spotlight: Zooming out and widening your aperture, with Vaarrun Bimbhat
- Should navigation bars be sticky or fixed?
- Building a UI in 60 seconds with Shadcn and Framer AI
- Customer-valued prioritization methods for effective PMs
- Leader Spotlight: Tech-led as a differentiating strategy, with Cristina Fuser
- Leader Spotlight: The importance of rapid learning and moving forward, with Jack Litchfield
- React Hooks cheat sheet: Best practices with examples
- Building pathways for co-designing UI/UX: Ideas and tools
- Server-side rendering with React Router v7
- Leader Spotlight: The value of visual mapping, with Suzanne Ackerman
- Generating PDFs in React with react-pdf
- How to write a UX/Ul case study: A step-by-step guide with examples
- Designing “no results found” pages that can engage users
- How to master JavaScript debugging for web apps
- Full-stack product manager vs. frontend product manager
- Leader Spotlight: Balancing long-term goals with flexibility, with Sowmya Sundararagavan
- Building a data-driven UX research plan in 6 steps
- A deep dive into Angular’s FormArray container
- Feasibility study template: Download and edit
- Leader Spotlight: Applying D2C strategies to build internal tools, with Julie Swanke
- The Fetch API is finally stable in Node.js
- Designing a smart ‘Complete Your Profile’ UI for apps
- Handling React loading states with React Loading Skeleton
- How to create a successful product education strategy
- Leader Spotlight: Evaluating opportunities to extend your brand, with Miles Kronby
- Choosing the right scrolling design pattern for better UX
- A guide to understanding program and product managers
- Leader Spotlight: Removing friction in the mobile shopping experience, with David Cost
- Mastering charts and database visualization with ChartDB
- What is a product teardown? Process, tools, and other insights
- Create a responsive navbar with React and CSS
- Integrating CX design with UX for the better
- JavaScript scroll snap events for scroll-triggered animations
- How to create AI-generated personas for enhanced product design
- Implementing JWT authentication in Laravel 11