Should that be read as 1/10th the effort it would take you in any other language (because of your long history with lisp), or do you suppose it would apply to arbitrary other competent people?
Like let's say we could make a few clones of you and start them all out on identical lives except that their early choice of language is different: one gets Haskell, another gets Forth, another Python, Ruby, etc.
In this scenario you're saying you'd bet on the clone who went with Lisp being most productive?
I can say this though: the ability to meta-abstract the language is a HUGE lever that no other language has. And one can also observe subsets of Common Lisp being continually re-invented in other languages. So CL must have gotten something right.
It's disingenuous to imply that every other language is simply "reinventing Lisp". The Lisp community itself spent decades figuring out elements that are now considered basic, like lexical scope. Lisp is just a ball of mud that can absorb any idea in its vicinity, and Lisp programmers like to retcon history to make every idea theirs.
It's not even slightly disingenuous to imply that every other language is simply "reinventing Lisp".
"if" statements existed in FORTRAN (hell, even FLOW-MATIC), which preceded Lisp. The earliest Lisp implementations didn't have garbage collection, and while mark-and-sweep was being developed for Lisp there were other high-level peers like APL experimenting with similar ideas. Same deal for dynamic typing. First-class functions were explored in the Lambda Calculus decades before Lisp programmers applied them, and mathematics has known about recursion since antiquity. Programmers were expressing recursive algorithms in machine language in the 50s.
None of this sprung fully-formed from the head of John McCarthy: Lisp borrowed from a rich preceding tradition of mathematics and computer science, and the rest of the world wasn't twiddling their thumbs while McCarthy worked on his machine-algebra system.
Of course recursion and first-class functions were known to mathematics. But we were discussing programming languages, not mathematics. And specifically high-level languages, back when there was a lot of skepticism as to whether they were even a good idea. Fortran got there first. Lisp was second and provided the existence proof that abstract features Fortran didn't even attempt were nevertheless viable. And then it went on to become the standard language of AI.
Sure, there was a lot of creativity happening back then, and Lisp didn't cause that creativity to happen. But being the second-oldest programming language and the first viable implementation of so many high-level features made Lisp a crucial development in the history of computing that's still quite relevant today.
But overall, I think Lisp is an extremely productive language. In the last decades, a lot of modern languages have implemented a lot of Lisp features, so getting closer in productivity, without quite reaching it. Consequentely, the productivity factor depends on which langauge you compare Lisp with. But compared to languages like C++, the productivity gain is really large.
For me, beyond the overall language qualities, there are two especial productivity boosters in Lisp: the ability for incremental and interactive development and to create domain specific abstractions. There are many dynamic languages, but so far I haven't seen one which as easily allows you to do interactive development. That is the ability to update single functions while your application is running. That speeds up the cycle of changing the code and testing it by orders of magnitude.