I have been writing grep -rn and find . -name for the better part of twenty years. They are wired into my fingers below the level of conscious thought. So it took an embarrassingly long time to admit that I had quietly stopped typing them, and that for everyday searching I now reach for rg and fd without thinking, the same way I used to reach for the old ones.
This is not a tools-are-cool post. I am suspicious of those, because most "you must switch to this" tooling is a lateral move dressed up as progress, and I have wasted enough weekends rebuilding a working setup to chase a marginal improvement. So let me be specific about what actually changed and where the old tools still earn their keep.
What ripgrep fixed that I had stopped noticing
The headline is speed, and yes, rg is genuinely fast. It is fast enough that searching a large monorepo feels free rather than something you brace for. But raw speed was not what converted me. The thing that converted me was the defaults.
rg respects .gitignore by default. That one decision removes an enormous amount of daily friction. With grep -r I was forever wading through node_modules, build output, vendored dependencies and .git internals, and the actual match I wanted was buried somewhere on page four. My standard grep had grown a tail of exclusions I copy-pasted around:
grep -rn --exclude-dir={.git,node_modules,vendor,dist} "handleRequest" .
With ripgrep that is just:
rg handleRequest
It already skips the noise, it already recurses, it already shows line numbers, and it already highlights the match in colour. Every flag I used to bolt onto grep to make it behave like I wanted is the out-of-the-box behaviour. That is the whole pitch, really. It does the thing I was already trying to make grep do, and it does it without me typing five flags I had memorised out of resentment.
There is a deeper point hiding in that. The friction of a tool is not really its peak capability, it is what the common case costs you. grep can do everything I want; it just makes me ask for all of it explicitly, every single time, and that small recurring tax is exactly the thing you stop noticing because you have always paid it. It was only when I had an alternative whose defaults matched my habits that I realised how much of my grep usage was boilerplate I had internalised. You do not feel a tax you have been paying for twenty years. You feel the absence of it when it suddenly stops.
The other quiet win is that it understands file types. rg -t go panic searches only Go files. rg -t py only Python. When you are trying to find where a string is defined versus where it is logged versus where it appears in a test fixture, narrowing by type is exactly the cut you want, and doing it with find ... -name '*.go' | xargs grep is the kind of pipeline I can write but would rather not, especially when a filename has a space in it and the whole thing falls over.
fd, and the death of the find incantation
find is a magnificent, baroque, deeply unfriendly tool. I respect it enormously and I have never once remembered its syntax on the first try. The argument order is a tiny domain-specific language all of its own, the -name matching is not what you expect coming from a shell, and deleting matches safely means remembering -print0 and xargs -0 or the -delete primary and hoping you got the predicate right.
There is a specific moment I have lived through more times than I would like to admit: I want to find some files and run a command on each, I half-remember the find syntax, I get the predicate slightly wrong, and either nothing matches or, worse, too much matches and I have run a command on files I did not mean to. The cognitive load of find is high enough that I would frequently stop, open a browser, and look up the exact incantation for the thing I had done a hundred times before. That is a tool failing me, not me failing the tool.
fd is what find would be if it had been designed after we collectively learned that ergonomics matter. To find every Markdown file:
fd -e md
To find directories called cache and act on them, the syntax reads like a sentence rather than a logic puzzle. It is regex by default, it respects .gitignore like ripgrep does, and it is colourised and parallel without being asked. The combination of fd to select files and rg to search inside them covers, I would guess, ninety-five percent of what I used to do with find and grep between them.
Where I kept the old tools
This is the part the enthusiastic blog posts leave out, so here it is plainly: I have not uninstalled anything, and I am not going to.
On a server I do not own, grep and find are there and rg and fd are not. That matters more than any feature. When I am SSH'd into a box at three in the morning chasing a production problem, I am going to use what is already installed, and the muscle memory for the old tools needs to stay sharp precisely because I cannot rely on the new ones being present. POSIX tools are a lingua franca. The nice tools are a local dialect I enjoy at home.
find also still wins when I genuinely need its power: acting on files by modification time, by permission, by ownership, executing a command per match with -exec, pruning whole subtrees with real predicate logic. fd covers the common path beautifully and deliberately does not try to be all of find. When I am past the common path, I go back to the original and accept the syntax tax.
And in scripts that other people will run on machines I cannot predict, I default to the portable tools. A clever script that assumes rg is installed is a script that breaks on a colleague's laptop, and I have been that colleague often enough to have learned the lesson.
So this is not a story about old tools being bad. grep and find are not bad. They are forty years old and still load-bearing across the entire industry, which is more than almost any software can say. The story is smaller than that: for the interactive, exploratory, "where on earth is this string" work I do dozens of times a day, the newer tools removed enough small frictions that my fingers changed their own habits before I noticed. The old tools earned a permanent place in the back of the toolbox, the way the manual screwdriver stays in the drawer even after you buy the cordless one.