Blog

MTMR Designer: Visual Touch Bar Designer for macOS

A visual drag-and-drop designer for macOS Touch Bar presets that eliminates manual JSON editing. Built with React 19 + Vite, featuring 39 element types, real-time preview, and direct MTMR integration.

Coding with AI Made Me Worse (Here's How I Fixed It)

The hidden cost of AI assistants: skill atrophy. Recognizing the problem and relearning how to think without a crutch.

The API-First Startup Trap: Building Something Nobody Asked For

A confession. I built APIs for imaginary users. Don't make my mistake. Build the UI first, validate with real people, then abstract.

Browser Extensions: The Platform Nobody Talks About

Building for the browser as a platform. Extensions are the new apps, and they're weirdly fun to build. Here's what makes them special.

Building git-drive: Turn Any External Drive Into a Git Backup

I built git-drive to solve a simple problem: backing up my code to external drives without the cloud. Here's how it works and what I learned building it.

My Infrastructure Costs $5/Month (And Yours Is $500 for the Same Traffic)

How to run a real production app on pocket change. The art of not over-engineering your stack when you're small.

The Great JavaScript Framework Consolidation

React, Vue, Svelte, Solid—they're all converging on the same patterns. Signals everywhere. The end of the framework wars might look surprisingly similar.

LeetCode is Dead (And AI Killed It)

The coding interview is broken. When ChatGPT can solve any LeetCode medium in seconds, what are we actually testing? A rant about hiring in the AI era.

The Microservices Hangover: Why Monoliths Are Cool Again

We spent a decade breaking things apart. Now we're gluing them back together. The industry pendulum swings back, and I'm not mad about it.

I Replaced My Entire Backend with Edge Functions (Mistakes Were Made)

The journey of going all-in on serverless edge. What worked, what failed, and why I still have a VPS for some things.

SQLite is Eating the World (And Postgres Is Sweating)

Everyone's putting SQLite everywhere now—browsers, edge functions, even servers. The little database that could is taking over, and the reasons why might surprise you.

Supply Chain Attacks Are Coming for Your node_modules

The npm ecosystem is a security nightmare. Real stories, real vulnerabilities, and how to protect yourself from malicious packages.

10 Modern CSS Layout Techniques Every Frontend Developer Must Know in 2026

Container queries, :has(), clamp() for responsive typography, and 7 more modern CSS patterns with real-world use cases, pros/cons, and code examples.

CISA Adds 5 Actively Exploited Vulnerabilities to KEV Catalog

CISA's Known Exploited Vulnerabilities catalog expanded with 5 new entries in late January 2026, including Microsoft Office, SmarterMail, and GNU InetUtils flaws. Here's what's being exploited in the wild and how to defend against it.

Next.js 16.1 Security Alert: Critical React Server Components Vulnerabilities

Next.js 16.1 patches critical vulnerabilities in React Server Components with CVSS scores up to 10.0. Here's what's at risk, who's affected, and how to patch immediately.

4 CSS Features Every Front-End Developer Should Know in 2026

Scroll state queries, typographic whitespace trimming, sibling-index() staggering, and type-safe attr() landed in browsers in 2025. Here's how to use them in production today.

NVIDIA's Physical AI Models: The Missing Link Between LLMs and Robotics

NVIDIA just released new Physical AI models that bridge the gap between language understanding and real-world manipulation. Here's how they're enabling the next generation of autonomous robots.

SAP S/4HANA Critical SQL Injection: CVE-2026-0501 Scores 9.9 CVSS

SAP's January 2026 security update patches a critical SQL injection vulnerability in S/4HANA with a CVSS score of 9.9. Here's the technical breakdown, exploitation scenarios, and why this matters for enterprise systems.

.NET and .NET Framework January 2026 Servicing Updates: What Changed

Microsoft released January 2026 servicing updates for .NET and .NET Framework with non-security fixes. Here's what changed, performance improvements, and whether you need to update.

Why DuckDB is Taking Over Data Analytics: A Deep Dive

DuckDB is being hailed as the 'SQLite for Analytics.' In this comprehensive guide, we explore its architecture, performance benchmarks, and why it's changing the data engineering landscape.

Microsoft Patch Tuesday January 2026: 114 Fixes Including Actively Exploited Zero-Day

Microsoft's first Patch Tuesday of 2026 patches 114 vulnerabilities including a Desktop Window Manager zero-day being exploited in the wild. Here's what developers need to know and patch immediately.

Moonshot AI's Kimi K2.5: The Agent Swarm Revolution That Changes Everything

China's Moonshot AI just dropped a 1 trillion parameter open-source model that orchestrates 100 parallel agents. Here's why K2.5's agent swarm architecture is a paradigm shift for AI development.

Slimming Down Your Bundle: Removing Unused CSS with PurgeCSS (The Deep Dive)

CSS bloat is a silent performance killer. In this deep dive, we explore how PurgeCSS works at the AST level, advanced configuration strategies, and how to safely strip unused styles from massive production apps.

Practical Tips for Writing High-Performance JavaScript: A Deep Dive

JavaScript is fast, but bad code is slow. This comprehensive guide covers V8 internals, memory management, event loop optimization, and advanced patterns for keeping 60fps.

The AI Reality Check: 2026 Marks the End of Empty Promises

AI is moving from hype to pragmatism. Here's what actually works in production, what's still vaporware, and how developers should navigate the transition.

TypeScript 7 Native Compiler: 10x Faster Builds with Go Rewrite

Microsoft rewrote the TypeScript compiler in Go, and it's 10x faster. VS Code builds drop from 77s to 7.5s. Here's the technical breakdown, breaking changes, and migration strategy.

Visual Studio 2026: Full .NET 10 Support, MCP Servers, and What Actually Matters

Visual Studio 2026 shipped January 20 with .NET 10, C# 14, TypeScript 7 preview, and MCP server integration. Here's what's genuinely useful vs. marketing fluff.

I Built an iTunes 7 Clone Because Modern Music Apps Lost Their Soul

Brushed metal, glowing LCDs, column browsers. A deep dive into how I recreated the peak of 2006 Apple design using Next.js, CSS gradients, and the Web Audio API.

Clawdbot: Your AI Assistant in Your Pocket (Not Just Another Chatbot)

I've been running an AI assistant through WhatsApp for months. Here's why Clawdbot is the bridge I didn't know I needed.

CSS @scope Is Finally Baseline — Time to Rethink CSS-in-JS?

Native style scoping landed in all browsers. Here's what it means for React developers who've been shipping runtime CSS.

CSS Scroll-State Queries: Delete Your IntersectionObserver

Chrome 133 just dropped scroll-state queries. Sticky detection, scroll snapping feedback, overflow indicators—all pure CSS now.

Tailwind Labs Laid Off 75% of Their Team Because AI Ate Their Business

The framework we all love just had to gut its engineering team. AI didn't kill CSS—it killed the business model.

WebRTC Demystified: Building Real-Time Apps in the Browser

The most powerful API nobody understands. Let's fix that.

CSS Anchor Positioning: Tooltips and Popovers Done Right

Position elements relative to other elements with pure CSS. No JavaScript positioning libraries. No getBoundingClientRect(). The future of UI is here.

CSS Scroll-Driven Animations: Delete Your JavaScript

Parallax, reveal effects, progress bars - all in pure CSS now. No IntersectionObserver. No scroll listeners. No jank.

DevTools Console Utilities You Didn't Know Existed

Hidden console commands that will make you feel like a debugging wizard. $_, $0, debug(), monitor() - the secret sauce Chrome didn't tell you about.

T3.Chat: What Happens When Actual Devs Build AI Interfaces

Theo built the T3 stack. Now he's building AI chat. It shows.

AI Coding Assistants: What They're Actually Good At

I use AI assistants daily. Here's where they help, where they fail, and how I actually use them.

Building Typesafe APIs with tRPC (A Practical Guide)

End-to-end type safety without code generation. Here's how I use tRPC in production.

Building Performant React Animations with Framer Motion

Master Framer Motion from basics to advanced techniques - useAnimate, layout animations, gesture handling, SVG morphing, and performance optimization.

CSS Container Queries: The Complete Guide

Everything you need to know about container queries - syntax, use cases, fallbacks, combining with custom properties, and real-world patterns.

Fine-Tuning Models Is a Waste of Time (Usually)

Everyone wants to fine-tune. Almost nobody should. Here's when it actually makes sense, and what to do instead.

AI Agents Are Overhyped But I'm Building One Anyway

Agent frameworks promise autonomous AI that solves complex problems. The reality? Fragile loops and hallucinated tool calls. But there's potential.

React 19 Features That Actually Matter (And Which Are Hype)

After months with React 19, here's what's real and what's marketing.

Introducing Qortr: The Modern Room Booking Platform I Built

I built Qortr to solve the frustrating experience of booking meeting rooms and coworking spaces. Here's why it exists and how it works.

Turbopack, SWC, Biome: The Rust Revolution in JS Tooling

JavaScript tools written in Rust are 10-100x faster. Here's what's happening and why.

Voice AI in 2025: Why Siri Still Sucks

Whisper, ElevenLabs, and voice cloning are incredible. So why does asking Siri to set a timer still fail? The state of voice AI explained.

The AI Tools I Actually Pay For (And Why)

No affiliate links, no sponsored content. Just the AI tools I've paid for with my own money after trying dozens of alternatives.

Playwright vs Cypress: An Honest Comparison in 2025

I've used both in production. Here's which one I reach for (and when).

The Real Cost of Running AI in Production

Token pricing looks cheap until you're processing 100k requests/day. Here's what AI actually costs at scale, and how to not go broke.

Edge Computing: Cutting Through the Hype

The edge is real, but it's not magic. Here's when it actually helps.

Building Desktop Apps with Tauri and SolidJS

Why I switched from Electron to Tauri for native macOS apps, and what I learned building floatnote and josetunes.

Signals: Why Every Framework Is Copying This Pattern

From Solid to Angular to Svelte, signals are taking over. Here's why.

AI Code Review: My Bot Found 47 Bugs (12 Were Real)

I built an AI code reviewer and ran it on our codebase. The results were humbling—for both the AI and our code quality.

React Server Components Explained (For Real This Time)

RSC confused me for months. Here's the mental model that finally made it click.

Bun vs Node vs Deno: Picking Your JS Runtime

Three runtimes, different philosophies. Here's how to choose.

I Built a RAG System. Here's Why You Probably Shouldn't.

Vector databases, embeddings, chunking strategies—I went down the RAG rabbit hole so you don't have to. Here's when it's worth it (rarely).

The View Transitions API Changes Everything for SPAs

Native page transitions in the browser. No libraries. No hacks. Finally.

Building Projax - A Developer's Project Dashboard

How I built a cross-platform project management tool with CLI, TUI, desktop app, and VS Code extension.

CSS :has() - The Parent Selector We Waited 20 Years For

CSS finally lets us select parents based on children. This changes everything.

Prompt Engineering Is Not a Real Job (But These Techniques Work)

Prompt engineer is a made-up title. But writing effective prompts? That's a real skill. Here's what actually works.

TypeScript 5.x Features You're Sleeping On

The const type parameter alone changed how I write generics. Here's what else you're missing.

Monorepos: When They Help, When They Hurt

I've used monorepos and polyrepos. Here's how to know which is right for your team.

SSR vs SSG vs ISR: Choosing the Right Rendering Strategy

Three acronyms, three mental models. Here's when to use each.

AI Image Generation Is Broken (And How I Use It Anyway)

DALL-E gives me nightmares, Midjourney costs too much, and Stable Diffusion requires a PhD. Here's how I actually use AI images.

The shadcn/ui Approach: Why Copy-Paste Beats npm install

shadcn/ui flipped the component library model. Here's why that matters.

Web Components in 2025: Finally Ready for Primetime?

I've been skeptical of Web Components for years. Here's why I'm reconsidering.

Local LLMs vs Cloud APIs: When Privacy Actually Matters

Running AI locally isn't just for paranoid nerds. Here's when it makes sense, what it costs, and how to actually do it.

Why Your Bundle Is Still Huge (And How to Actually Fix It)

I shaved 400KB off a production bundle last month. Here's everything I learned.

htmx: Is the Return to Simplicity Actually Simpler?

I built the same app in htmx and React. Here's my honest take.

Why Every React Dev Should Learn a Little Rust

Not to write Rust professionally. To understand your tools—and become a better developer.

Why I Stopped Using Create React App (And What I Use Instead)

CRA served us well for years. But it's 2025, and there are better options.

Remote Work After 5 Years: What Actually Works

I've been fully remote since before it was cool. Here's what I've learned about productivity, communication, and not losing my mind.

The Stack That Actually Ships

After 21 years and dozens of tech stacks, here's what I actually use to ship products in 2025.

Publishing Your First npm Package: A Practical Guide

I've published several npm packages including too-bored, gappa-comments, and ace CLI. Here's everything I wish I knew before my first publish.

Why I Still Use Next.js in 2025 (And You Probably Should Too)

Despite the hype around new frameworks, Next.js remains my go-to. Here's my honest take after shipping dozens of production apps.

Building Accessible Web Applications (It's Not That Hard)

Accessibility isn't a feature. It's a baseline. And it's way easier than most developers think.

Creating CLI Tools for React Development

How I built ace, a CLI tool for bootstrapping React applications with sensible defaults.

From jQuery to React: A 20-Year JavaScript Journey

I started coding when jQuery was revolutionary. Here's how JavaScript development changed, and what stayed the same.

The Art of Code Review: What 20 Years Taught Me

Code review is a skill. Most people are bad at it. Here's how to get better—whether you're giving feedback or receiving it.

WebRTC Debugging War Stories: Hard-Won Lessons from Production Video Conferencing

Debugging Production at 3 AM: War Stories and Lessons

Every developer has 3 AM debugging stories. Here are mine, and what they taught me about building resilient systems.

The Senior Engineer's Guide to Surviving Startup Chaos

After 21 years in software, here's what I wish someone told me about navigating the chaos of fast-moving companies.

Pre-Publish Security Scanning: How I Almost Leaked API Keys (and Built pubsafe)

Building a Search Engine with Bun: The angine Deep Dive

Publishing npm Packages: Hard Lessons from too-bored, ace, and Beyond

Building Beautiful Terminal UIs with Ink: React for the Command Line