Most tool roundups optimize for length. Thirty entries, one paragraph each, no opinion, and a reader who installs four things and uninstalls them by Friday.
The useful framing is different: there are a small number of categories where the right tool changes what work is possible rather than making the same work marginally faster. Those are worth the switching cost. Everything else is preference and you should keep whatever you already have.
Seven categories. Where a named tool is given it is because the category has a clear current answer, not because there is only one option.
1. A reference library that stores values, not pictures
The category most developers do not know is a category. You already collect UI you like; you are almost certainly collecting it as screenshots, which throws away every number the browser computed.
The change in shape: when your references carry their real computed CSS, "make it look like that" stops being an eyeballing exercise. You read the type ramp, the spacing scale, and the real colours instead of approximating them, and you can generate a starting implementation directly from the reference.
Options: Stele (ours) for element-level captures with structure, styles, and codegen. Raindrop if your library is really links. Eagle if it is really a lot of images. mymind if you have abandoned every previous system and need capture friction to be zero.
2. A capable clipboard and snippet layer
Unglamorous, enormous payoff. A clipboard history with search removes an entire class of small interruptions: re-copying the same token, losing something to an accidental overwrite, tabbing back to a reference for a value you had ten minutes ago.
The change in shape: you stop keeping things in short-term memory that the machine can keep for you, which is most of what "flow" actually is.
Options: Raycast (Mac) covers clipboard history, snippets, window management, and a launcher in one, which is the real argument for it. PowerToys on Windows, Alfred if you prefer it, or the built-in clipboard manager if you want zero install.
3. An AI assistant wired into the editor, used narrowly
The advice most often given here is wrong in a specific way: people evaluate AI assistants on whether they can write a feature, decide they mostly cannot, and stop. The wins are elsewhere and they are large.
Where it reliably pays: transforming one shape of data into another, writing the test you would have skipped, explaining an unfamiliar part of the codebase, mechanical refactors across many files, and turning a captured reference into a first-draft component.
The change in shape: the marginal cost of the boring version of a task drops close to zero, which changes what you are willing to attempt. Options: Claude Code, Cursor, or the assistant already in your editor. The tool matters less than the discipline of using it for the boring half and not the interesting half.
4. Local HTTPS and a real domain in development
Running on localhost:3000 quietly costs you: cookie behaviour differs, secure contexts differ, third-party embeds behave differently, and a whole class of bug is only reproducible in staging.
The change in shape: staging stops being the place where surprises live.
Options: mkcert plus a local domain, Caddy for automatic HTTPS, or a tunnel like ngrok or Cloudflare Tunnel when you need a public URL for a webhook or a phone.
5. Something that watches your bundle
Bundle size is the performance problem that regresses invisibly, because every individual addition is defensible and the total is nobody’s job.
The change in shape: a number that fails a build turns "we should look at performance sometime" into a decision you make at the moment you are adding the dependency, which is the only moment the decision is cheap.
Options: a size budget in CI, whatever your bundler’s analyzer is, and Lighthouse CI if you want the user-facing metrics rather than the bytes.
6. A contrast and accessibility checker you actually run
Not an audit tool you run before launch. Something in the loop, at the moment you pick the colour.
The change in shape: accessibility stops being a phase and becomes a constraint, which is both cheaper and produces better results because the constraint informs the design instead of correcting it.
Options: axe DevTools in the browser for the full sweep, and a contrast checker for the ten-second version. We keep a free one at /tools/contrast-checker that reports both the WCAG ratio and the APCA lightness contrast, because the two disagree in useful ways on dark backgrounds.
7. Search over your own history
Shell history, browser history, your own notes, your own captures. The single most underrated productivity axis, because the thing you need has usually already passed through your hands once.
The change in shape: you stop re-solving problems you have already solved. Most developers re-solve the same handful of problems several times a year without noticing, because the previous solution is not findable.
Options: Atuin for shell history with search and sync, a launcher with browser-history search, and a reference library with semantic search over what you saved.
Three pieces of common advice worth ignoring
Not everything popular is load-bearing.
- A perfect dotfiles setup. High effort, high maintenance, near-zero effect on output. Ship a boring config and get on with it.
- Switching editors for performance. The editor is essentially never the bottleneck. Familiarity is worth more than any benchmark difference between the current options.
- Note-taking apps as a productivity system. Notes are a real tool for thinking and a poor tool for retrieval unless the retrieval is by text. A design reference belongs in something that understands images and elements, not in a markdown file with an attachment.
How to actually adopt any of this
Adopt one, for two weeks, and pick the one that fixes a thing that annoyed you this week. Tooling adopted for a problem you do not have is uninstalled by Friday, which is why roundups with thirty entries change nothing.
If you want the shortest path: start with category one. It is the one where most people are quietly paying a cost every day and have stopped noticing, because re-deriving spacing and colour by eye from a screenshot feels like the job rather than like a tooling gap.