My thing is I go simple. I'm good, maybe messy. Finally see enough / think I know a good abstraction and pull the trigger and later I find out ... oh man I was wrong. Knowing when you know is the hard part.
I've got some abstractions out there I wrote early on when I didn't think I coded well and they have lived for years and saved tons of time.
So many times I've taken code that was a mess because someone tried blindly DRY code for the sake of being DRY and rub abstractions on top of it and I've reverted the code back to being simple copypasta and its become so much more clearer and robust. Then you can look at the result and a simple abstraction may pop out which can reduce enough code duplication that the result is satisfactory (it may require a bit more boilerplate in the subclasses or whatever, but nothing likely to be brittle under future fixes).
The nice thing about dealing with an overly-DRY codebase is you can unwind the abstractions.
But an underly-DRY codebase... good luck. Copypasta tends to accumulate minor differences and figuring out if those minor differences matters can become very time consuming.
All the libraries I love and use the most have tons of parameters but they are really well documented including their parameters' interactions with each other.
I don't mean well-considered and documented libraries, I mean the thing where someone goes to DRY up a codebase and keeps thinking "oh, if I just add a parameter this function can also handle this one-off case over here..." over, and over, and over, until you've got this function with a name that makes it look straightforward but for some reason it wants three strings, two of which should actually be nulled in most cases (and god help you if you fill in a value when you don't need them), an integer for unclear reasons but it's the same value in every call you can find, and half a dozen booleans that you'll have to go read the source to figure out, because some of them do more than the variable name in the signature implies.
Good intentions at every step, but a Frankenstein's monster of a function (or entire class, sometimes) in the end
It's the DRY equivalent of having 20 slightly-different copypastes all over a codebase.
If it's unclear, then it's poor code or poor documentation or both. Sane developers will provide a way to obtain default or common configurations rather than forcing you to figure out the 100 different tunable options.
I've got some abstractions out there I wrote early on when I didn't think I coded well and they have lived for years and saved tons of time.
Others don't live long :(