Loading
Arguments I keep having on X, grouped by what they're actually about. Mostly replies — that's where the interesting disagreements happen.
Generated code is cheap now; code someone can still reason about at 3am is not. Most of what I argue about here is the difference between the two.
The failure mode of AI-generated code was never another model reading it — it's the on-call engineer grepping through six layers of abstraction invented for what should have been a one-off script.
Hyperefficient and unreadable is just technical debt with better benchmarks: we write readable code so the next person can trust it without re-deriving it.
The best frontend engineers in two years won't be the ones who avoided abstractions — they'll be the ones who can explain them to an agent precisely enough to get clean output.
React stopped rewarding the habits it used to require. Some of this is settled; some of it I am still working out with the people building it.
Related reading →A year of wrapping every callback in useCallback became obsolete when the React Compiler shipped stable — and if you started a Next.js project since v15, you're already running it.
With Waku, Next and RedwoodSDK all shipping RSC independently, is the wire protocol actually converging, or is everyone hand-rolling their own underneath?
Keeping it an extension of JSX rather than a new language is the right call for adoption — what pushed the decision to drop lazy destructuring?
Most of what I do on X is reply. These are exchanges with the people who actually build the tools — where the interesting disagreements happen and where being wrong in public is cheapest.
Layers being the blocker for Module Federation and RSC at the same time is why nobody has shipped this yet — and whether that work is Rspack internals or bleeds into webpack too.
Asking whether RSC serialization actually survives crossing Module Federation boundaries, or whether that is still unsolved.
Diff design tokens like a schema, not a screenshot: flatten to values and diff the JSON, because pixel diffs choke on antialiasing and flag shifts nobody cares about.
Charting libraries have been stuck choosing canvas or DOM for years; mixing SVG and canvas behind a single API is the first sane answer to that.
Almost every performance win I've shipped came from finding the actual bottleneck, which is rarely the one the convention blames. The rest is attribution error.
Related reading →On an inherited Next.js app the LCP element wasn't an image at all — it was a dashboard card waiting on three sequential API calls. Moving the fetch server-side cut load time 40%.
Non-determinism ruins attribution everywhere, not just in LLM work: ship one change, watch LCP drop, and a CSS trick becomes gospel when the real cause was a cache warmup.
Rust keeps getting credit for wins that came from the rewrite itself finally fixing the N+1 query or the synchronous IO nobody wanted to touch.
Good architecture is mostly knowing which problem you actually have yet. Most of these are arguments against solving the one you don't.
Related reading →Clean architecture with zero users means you built for a codebase that doesn't exist yet — ship the ugly version, let someone complain, then refactor around real usage.
The timeout isn't the bug — doing the work synchronously in the request path is. Queue it, fan out in batches with a worker pool, and retry per batch instead of per user.
Ghostscript compiled to WebAssembly compresses a 24MB PDF to 3.9MB in four seconds in the browser: JS-only tools cap around 10-20% where Ghostscript hits 70-85%.