Anchit Verma

TIL: CSS color-mix() is production-ready

Mon, 02 Mar 2026 00:00:00 GMT

color-mix() has full browser support now and it's incredibly useful for generating color variations without preprocessors.

/* 50% of accent color mixed with transparent = semi-transparent accent */
background: color-mix(in srgb, var(--color-accent) 50%, transparent);

/* Darken a color by mixing with black */
border-color: color-mix(in srgb, var(--color-accent) 80%, black);

The in srgb part specifies the color space for interpolation. You can also use in oklch for perceptually uniform mixing, which tends to produce more natural-looking results.

I've been using this all over this site instead of maintaining separate color tokens for every opacity variant.

TIL: git bisect is criminally underused

Sat, 28 Feb 2026 00:00:00 GMT

git bisect binary searches your commit history to find the exact commit that introduced a bug. It's shockingly effective and I forget about it every time.

Container queries change everything

Fri, 20 Feb 2026 00:00:00 GMT

Container queries let components respond to their own size instead of the viewport. This is the missing piece for truly reusable components. Finally, a card can be responsive without knowing where it lives on the page.

The Tools We Use Shape How We Think

Wed, 18 Feb 2026 00:00:00 GMT

There's a quote often attributed to Abraham Maslow: "If all you have is a hammer, everything looks like a nail." It's become a cliche, but like most cliches, it persists because it's true.

I've been thinking about this lately in the context of software development. The frameworks we adopt, the languages we write in, the editors we use — they don't just help us build things. They shape the kinds of things we imagine building.

The editor as a lens

When I switched from a heavy IDE to a minimal text editor, something shifted. I started writing smaller functions. I relied less on auto-complete and more on memory. My code got simpler — not because I was trying to write simple code, but because the tool encouraged it.

The opposite happens too. Give someone a powerful ORM and they'll model everything as a database relation. Give them a message queue and suddenly every problem is an event.

Choosing constraints

The interesting move is choosing your constraints deliberately. Instead of reaching for the most powerful tool, sometimes the right choice is the most limited one.

A static site generator forces you to think about what actually needs to be dynamic. A language without exceptions forces you to handle errors explicitly. A deploy pipeline without rollbacks forces you to test more carefully.

These aren't limitations — they're design decisions that ripple outward.

What I'm trying to do about it

Lately, I've been making a conscious effort to rotate my tools. Not for the novelty, but to keep my thinking flexible. Write some code in a language I don't usually use. Try a different approach to a problem I've solved before.

It's uncomfortable, and it's slower. But the code that comes out the other side tends to be more thoughtful.

The tools we use shape how we think. It's worth being intentional about which ones we pick up.

Astro content collections are genuinely good

Sat, 14 Feb 2026 00:00:00 GMT

After using Astro's content collections for this site, I'm impressed by how well they handle the boring parts of content management — type-safe frontmatter validation, automatic slug generation, and collection-scoped queries.

The z.coerce.date() trick is particularly nice. You write date: 2026-02-14 in your frontmatter and Zod coerces it into a proper Date object. No parsing, no edge cases.

The mental model is simple: a collection is a directory of markdown files with a shared schema. Query it, filter it, sort it. Everything is typed.

Semantic HTML is still underrated

Tue, 10 Feb 2026 00:00:00 GMT

Using the right HTML elements gives you accessibility, SEO, and browser features for free. A <details> element is a disclosure widget without a single line of JavaScript. A <dialog> is a modal that handles focus trapping. Stop reinventing what the platform gives you.

Vertical rhythm in web typography

Fri, 30 Jan 2026 00:00:00 GMT

The trick to making a page feel well-designed even if you can't pinpoint why: derive all your spacing from your base line-height.

--space-unit: calc(var(--fs-base) * var(--leading-body));
--space-sm: calc(var(--space-unit) * 0.5);
--space-md: var(--space-unit);
--space-lg: calc(var(--space-unit) * 1.5);

Everything snaps to a consistent vertical grid. Headings, paragraphs, margins, padding — all multiples of the same base unit. It's subtle but the difference is immediately noticeable.

Writing to Understand

Sun, 25 Jan 2026 00:00:00 GMT

I used to think you needed to be an expert before you could write about something. That writing was the output of understanding. First you learn, then you explain.

I had it backwards.

The blank page as a debugging tool

The moment I try to explain something in writing, I discover the gaps. The parts I thought I understood but actually just had a vague feeling about. The connections I assumed existed but can't articulate.

Writing is not the output of thinking. Writing is thinking.

This is why rubber duck debugging works. It's why teaching is the best way to learn. The act of translating an idea from the fuzzy space in your head into concrete words forces precision.

The draft as exploration

My best technical posts started as confusion. I'd encounter something I didn't fully understand, and instead of bookmarking it for later, I'd open a blank document and start writing.

Not writing about it — writing through it. Following the thread wherever it led, asking questions on the page, trying different explanations until one clicked.

Half of these drafts never become posts. That's fine. The draft served its purpose.

Permission to be wrong

The hardest part is giving yourself permission to write something that might be wrong. Or incomplete. Or obvious to someone with more experience.

But here's the thing: writing that comes from genuine curiosity is almost always interesting, even when it's imperfect. Readers can tell the difference between someone exploring an idea honestly and someone performing expertise.

I'd rather read a thoughtful wrong take than a polished summary of conventional wisdom.

So I keep writing. Not because I have answers, but because writing is how I find them.

View Transitions API first impressions

Thu, 22 Jan 2026 00:00:00 GMT

The View Transitions API makes page transitions trivially easy. Astro supports it out of the box with <ViewTransitions />. The browser handles the cross-fade and you can customize with CSS. It feels like magic.

The :has() selector is a game changer

Thu, 15 Jan 2026 00:00:00 GMT

:has() is the parent selector CSS never had. You can now style a parent based on its children: article:has(img) targets articles that contain images. The days of adding modifier classes just for styling context are over.

The Debugging Mindset

Sat, 10 Jan 2026 00:00:00 GMT

Debugging is not about knowing the answer. It's about knowing which questions to ask. The best debuggers I've worked with share a common trait: they resist the urge to jump to conclusions. Instead, they slow down, form hypotheses, and systematically eliminate possibilities.

There's a parallel to scientific thinking here. You don't prove your theory right — you try to prove it wrong. Every bug is a mystery, and every mystery deserves a method.

Modern CLI tools written in Rust

Thu, 08 Jan 2026 00:00:00 GMT

The new generation of CLI tools is fast. ripgrep over grep, fd over find, bat over cat, eza over ls, delta for git diffs. All written in Rust, all dramatically faster and more user-friendly than their predecessors.

Native CSS nesting is here

Tue, 30 Dec 2025 00:00:00 GMT

Native CSS nesting has shipped in all major browsers. You can now write nested selectors without a preprocessor. The syntax is slightly different from Sass — you need & for non-element selectors — but the mental model is the same.

Monorepo tradeoffs in practice

Thu, 18 Dec 2025 00:00:00 GMT

Monorepos make cross-cutting changes easy and dependency management simple. But they also make CI slower, git history noisier, and ownership boundaries fuzzier. The right choice depends on your team size and how often packages change together.

On Simplicity

Mon, 15 Dec 2025 00:00:00 GMT

Every junior developer wants to write clever code. Every senior developer wants to write simple code. The difference isn't skill — it's taste. Simple code is hard because it requires you to truly understand the problem before you start solving it.

Always respect prefers-reduced-motion

Fri, 05 Dec 2025 00:00:00 GMT

If you add animations to your site, wrap them in a prefers-reduced-motion check. Some users have vestibular disorders that make motion genuinely nauseating. One media query is all it takes to be respectful.

In Praise of Friction

Thu, 20 Nov 2025 00:00:00 GMT

We spend a lot of time removing friction from our tools and workflows. Faster builds, instant deploys, one-click everything. But sometimes friction is a feature, not a bug. The pause before you push to production. The review before you merge. These moments of resistance give us space to think.

On writing small functions

Thu, 20 Nov 2025 00:00:00 GMT

A function should do one thing. If you can't name it clearly, it's probably doing too much. Small functions are easier to test, easier to read, and easier to replace. The overhead of a function call is negligible; the overhead of a confused reader is not.

The Popover API replaces a lot of JS

Sat, 08 Nov 2025 00:00:00 GMT

The Popover API (popover attribute + popovertarget) handles tooltips, dropdowns, and popovers with zero JavaScript. It manages z-index stacking, light-dismiss behavior, and focus. Another win for the platform.

Learning in Public

Tue, 28 Oct 2025 00:00:00 GMT

The idea of learning in public used to terrify me. What if I'm wrong? What if someone who knows more reads this and thinks I'm an idiot? But here's the thing: being wrong in public is one of the fastest ways to get right.

Structured logging saves debugging time

Sat, 25 Oct 2025 00:00:00 GMT

Stop logging strings. Log structured objects with consistent fields: timestamp, level, message, context. When something breaks at 3am, you'll be grateful you can filter by user_id instead of grepping through prose.

CSS cascade layers solve specificity wars

Wed, 15 Oct 2025 00:00:00 GMT

@layer lets you control the order of cascade precedence explicitly. Put your reset in a low-priority layer, component styles in the middle, and utilities on top. No more !important hacks.

Bun's test runner is surprisingly good

Wed, 08 Oct 2025 00:00:00 GMT

bun test is Jest-compatible but orders of magnitude faster. It supports TypeScript natively, has built-in mocking, and snapshot testing just works. For most projects there's no reason to reach for a separate test framework.

The Case for Small Pull Requests

Sun, 05 Oct 2025 00:00:00 GMT

The single biggest improvement most teams can make to their code review process is reducing PR size. Large PRs get rubber-stamped. Small PRs get thoughtful feedback. The math is simple: reviewers have finite attention, and the quality of review degrades exponentially with size.

OKLCH is the color space we needed

Sun, 28 Sep 2025 00:00:00 GMT

OKLCH gives you perceptually uniform colors. Unlike HSL, changing the lightness value in OKLCH actually looks like the same amount of change across hues. This makes generating consistent color palettes trivially easy.

Type Systems as Documentation

Thu, 18 Sep 2025 00:00:00 GMT

The best documentation is the kind that can't go stale. Comments lie. READMEs drift. But types? Types are checked by the compiler every single time you build. A well-designed type system doesn't just catch errors — it communicates intent.

The element handles modals properly

Mon, 15 Sep 2025 00:00:00 GMT

<dialog> with showModal() gives you focus trapping, backdrop, Escape to close, and proper accessibility — all built into the platform. Stop building modal components from scratch.

The Temporal API is coming to replace Date

Mon, 01 Sep 2025 00:00:00 GMT

JavaScript's Date object is famously broken. The Temporal API fixes everything: immutable objects, proper timezone support, duration arithmetic, and no more month-indexing-from-zero surprises.

Why Side Projects Matter

Fri, 22 Aug 2025 00:00:00 GMT

The best engineers I know all have side projects. Not because they're workaholics, but because side projects give you a space to experiment without consequences. You can try that weird architecture, use that new framework, or build something purely for the joy of building.

CSS Anchor Positioning is wild

Wed, 20 Aug 2025 00:00:00 GMT

CSS Anchor Positioning lets you tether an element to another element without JavaScript. Tooltips, dropdowns, popovers — all positionable relative to their trigger with pure CSS. The anchor() function is the future of layout.

SQLite is the most deployed database in the world

Sun, 10 Aug 2025 00:00:00 GMT

SQLite runs on every phone, every browser, and most embedded devices. It's also increasingly viable as a production web database with tools like Litestream and LiteFS for replication. Sometimes the simplest solution really is the best.

Naming Things Well

Fri, 01 Aug 2025 00:00:00 GMT

Phil Karlton said there are only two hard things in computer science: cache invalidation and naming things. He was right about naming. A good name is a tiny act of communication — it tells the next developer (or your future self) exactly what something does without having to read the implementation.

Web Components finally make sense

Mon, 28 Jul 2025 00:00:00 GMT

Web Components had a rough start, but with Declarative Shadow DOM and the ElementInternals API, they're genuinely useful now. Great for design system primitives that need to work across frameworks.

JSDoc types as a TypeScript alternative

Tue, 15 Jul 2025 00:00:00 GMT

You can get full TypeScript type checking in plain JavaScript files using JSDoc annotations. No build step, no compilation, just // @ts-check at the top of your file. Perfect for small projects where a full TS setup is overkill.

Reading Code Is a Skill

Sat, 12 Jul 2025 00:00:00 GMT

Most developers spend far more time reading code than writing it. Yet we almost never practice reading deliberately. We don't study other people's code the way writers study other writers' prose. We should.

@scope is the CSS scoping we always wanted

Tue, 01 Jul 2025 00:00:00 GMT

@scope (.card) to (.card-content) lets you scope styles to a subtree of the DOM with a lower boundary. No more BEM naming conventions or CSS modules just to avoid conflicts. The platform is catching up.

Defaults Matter More Than You Think

Wed, 25 Jun 2025 00:00:00 GMT

Most people never change the defaults. This is true of everything from phone settings to framework configurations. The people who set defaults wield enormous power — they're making decisions on behalf of everyone who never opens the settings page.

The light-dark() CSS function simplifies theming

Wed, 18 Jun 2025 00:00:00 GMT

light-dark(#fff, #111) returns the first value in light mode and the second in dark mode. Combine with color-scheme: light dark and you can theme an entire site without media queries or class toggling.

All Abstractions Leak

Tue, 10 Jun 2025 00:00:00 GMT

Joel Spolsky coined the Law of Leaky Abstractions in 2002, and it's as true today as ever. TCP pretends to be reliable until packet loss spikes. ORMs pretend SQL doesn't exist until you hit a slow query. React pretends the DOM is cheap until you render ten thousand items.

htmx makes SPAs feel unnecessary

Thu, 05 Jun 2025 00:00:00 GMT

htmx lets you add AJAX, CSS transitions, and WebSockets with HTML attributes. No JavaScript framework needed. For content-heavy sites with some interactivity, it's dramatically simpler than the React/Vue/Svelte path.

Technical Debt Is a Bad Metaphor

Wed, 28 May 2025 00:00:00 GMT

Ward Cunningham's original metaphor was about shipping early to learn faster. Somewhere along the way it became an excuse for writing bad code. Real technical debt is a strategic choice. Most of what we call debt is just mess.

Edge computing isn't always faster

Thu, 22 May 2025 00:00:00 GMT

Running code at the edge reduces latency for static responses. But if your edge function needs to talk to a database in us-east-1, you've just added a hop. Edge is great for caching and transformation, less great for data-heavy operations.

Start with a Monolith

Thu, 15 May 2025 00:00:00 GMT

The allure of microservices is strong. Independent deployments, team autonomy, technology diversity. But the costs are real: distributed tracing, eventual consistency, network partitions. If you don't have the problems microservices solve, you just have the problems they create.

Signals are taking over frontend reactivity

Thu, 08 May 2025 00:00:00 GMT

Signals are fine-grained reactive primitives. Solid, Preact, Angular, and now a TC39 proposal. Unlike React's model of re-rendering entire component trees, signals update only the specific DOM nodes that depend on changed values.

Writing Tests First Changed How I Design

Wed, 30 Apr 2025 00:00:00 GMT

I resisted TDD for years. It felt slow and backwards. Then I tried it properly for a month and something clicked. When you write the test first, you're forced to think about what your code should do before you think about how it does it.

CSS subgrid aligns nested grids perfectly

Fri, 25 Apr 2025 00:00:00 GMT

grid-template-rows: subgrid lets a child grid inherit track sizing from its parent. Card layouts where titles, descriptions, and footers all align across cards — finally possible without hacks.

Going Keyboard-Driven

Sat, 12 Apr 2025 00:00:00 GMT

I spent a month trying to minimize mouse usage. Vim keybindings everywhere, tiling window managers, terminal-first workflows. The learning curve was brutal but the payoff was real — not just speed, but a sense of flow I hadn't felt before.

Streaming HTML is underappreciated

Thu, 10 Apr 2025 00:00:00 GMT

HTTP streaming lets the browser start rendering before the full response arrives. Frameworks like Remix and Astro use this to show a shell immediately while slow data loads. First paint happens in milliseconds instead of seconds.

Testing Library's philosophy is right

Fri, 28 Mar 2025 00:00:00 GMT

"The more your tests resemble the way your software is used, the more confidence they can give you." Testing Library encourages querying by role, label, and text — not by CSS class or test ID. Tests that test behavior, not implementation.

Why Software Estimation Is Broken

Tue, 25 Mar 2025 00:00:00 GMT

Software estimation fails because we estimate effort instead of uncertainty. A task isn't hard because it takes many hours — it's hard because we don't know what we don't know. The honest answer to most estimates is a probability distribution, not a number.

Scroll-driven animations in pure CSS

Sat, 15 Mar 2025 00:00:00 GMT

animation-timeline: scroll() ties animations to scroll position with zero JavaScript. Progress bars, parallax effects, reveal animations — all declarative. The performance is excellent because it runs on the compositor thread.

Choose Boring Technology

Mon, 10 Mar 2025 00:00:00 GMT

Every company gets about three innovation tokens. Spend them on the things that differentiate your product, not on your build system. PostgreSQL, Rails, React — these are boring, and boring is a feature. Boring means documented, understood, and battle-tested.

Deno 2 goes all-in on Node compatibility

Sat, 01 Mar 2025 00:00:00 GMT

Deno 2 supports package.json, node_modules, and npm packages natively. The friction of migration is nearly gone. You get TypeScript, linting, formatting, and testing built in — no tsconfig.json, no eslint, no jest config.

Building a Healthy Code Review Culture

Thu, 20 Feb 2025 00:00:00 GMT

The difference between a team that loves code review and one that dreads it comes down to culture. Is the goal to find faults or to share knowledge? Do reviewers ask questions or make demands? The tone of your review comments shapes your entire engineering culture.

WebAssembly components are the future of plugins

Sat, 15 Feb 2025 00:00:00 GMT

The WebAssembly Component Model lets you write plugins in any language and run them sandboxed. No FFI, no shared memory bugs, just well-typed interfaces. Extism and Spin are already building plugin systems on this foundation.

Progressive Enhancement Still Matters

Wed, 05 Feb 2025 00:00:00 GMT

Progressive enhancement isn't about supporting IE6. It's about building resilient experiences that work even when things go wrong — slow networks, failed scripts, disabled JavaScript. The web is inherently unreliable. Build for that reality.

Refactoring Without Fear

Sat, 18 Jan 2025 00:00:00 GMT

The secret to confident refactoring is a good test suite. Not 100% coverage — that's a vanity metric. But tests that describe behavior, not implementation. When your tests are coupled to your code structure, refactoring means rewriting tests too, and that defeats the purpose.

Documentation-Driven Development

Sun, 05 Jan 2025 00:00:00 GMT

Before I write a line of code, I write the README. Not a polished document — just enough to describe what the thing does, how to use it, and why it exists. If the README is hard to write, the design needs more thought.

API Design Is Interface Design

Fri, 20 Dec 2024 00:00:00 GMT

We think of APIs as technical artifacts, but they're really design artifacts. Consistency, discoverability, sensible defaults, good error messages — these are the same principles that make a good GUI. Your API's users are developers, and they deserve good UX too.

A Simple Git Workflow That Scales

Thu, 05 Dec 2024 00:00:00 GMT

After trying gitflow, GitHub flow, and various hybrids, I've settled on the simplest approach: a main branch, short-lived feature branches, and frequent merges. No develop branch, no release branches. Just small changes shipped often.

CSS Is More Powerful Than You Think

Mon, 18 Nov 2024 00:00:00 GMT

Every year I'm surprised by what CSS can do without JavaScript. Scroll-driven animations, container queries, :has() selectors, subgrid, layer cascading. The language has evolved dramatically and most developers are still writing CSS like it's 2018.

Escaping Dependency Hell

Fri, 01 Nov 2024 00:00:00 GMT

Every dependency is a bet. You're betting that someone else will maintain it, that it won't introduce breaking changes, and that it won't have security vulnerabilities. Some bets are worth taking. Many aren't. The left-pad incident taught us nothing.

Observability Is Not Just Logging

Tue, 15 Oct 2024 00:00:00 GMT

You can have a million log lines and still be blind when production breaks. Observability isn't about the volume of data — it's about being able to ask arbitrary questions of your system. Structured logs, dimensional metrics, and distributed traces form a triangle that lets you navigate from symptom to cause.

Pair Programming Done Right

Tue, 01 Oct 2024 00:00:00 GMT

Most pair programming fails because people treat it as an obligation rather than a technique. Good pairing has rhythm: driver and navigator, ping-pong TDD, mob sessions for design. Bad pairing is one person typing while the other checks Slack.

Error Handling Deserves More Thought

Sun, 15 Sep 2024 00:00:00 GMT

Error handling is where most software falls apart. Not because developers don't write try-catch blocks, but because they don't think about what should actually happen when things go wrong. A generic error page is not error handling — it's error hiding.

Set a Performance Budget

Sun, 01 Sep 2024 00:00:00 GMT

Performance degrades slowly, one dependency at a time. A performance budget is a line in the sand: your JavaScript bundle can't exceed 200KB, your Largest Contentful Paint can't exceed 2.5 seconds. Without a budget, every sprint adds weight and nobody notices until it's too late.

Writing Good Changelogs

Thu, 15 Aug 2024 00:00:00 GMT

A good changelog tells you what changed, why it changed, and what you need to do about it. "Bug fixes and improvements" is not a changelog entry — it's an admission that you don't respect your users' time. Keep a changelog. Write it for humans.