In order to understand the true power of Common Lisp, you must understand its greatest weakness.
Common Lisp is unrestrained power. What does this mean? Any one can make a huge mess since there are macros, eval, CLOS, etc. People coming from overly restricted languages like C++ can and will use every "powerful" feature they find to walk code, change semantics of the language, repackage built-in symbols, and do all other sorts of impossible nonsense. Why does this happen? Because when you are weak, like a C++ developer, you never learn restraint. Because of this, Common Lisp suffers from a management problem. If all your developers are using a weak language, there is only so much damage one developer can do. Here is a similar idea by Fare who pointed out that CL is a "hippie language". He has experience managing CL projects with ASDF. There was another blog post by another author about how CL is too powerful but I can't seem to find it.
If all developers could exercise restraint then perhaps Common Lisp could flourish. But this is like saying if everyone in the world was good there would be world peace. That will never, ever happen, except if your world if small enough or everyone is homogeneous. This is why Common Lisp projects start small and stay small. It's like communism, you need everyone to follow the rules. Thus the link between communism, open source, and common lisp.
However, there might be hope for a solution in a lisp that incrementally adds power [at one point the X3J13 committee was debating whether common lisp should be separated into different parts like a "core"] and/or permissions/capabilities like scheme48. I think it was Paul Graham who said that as time passes, weak languages like C++ absorb features from common lisp. Or see Greenspun's tenth rule. In common lisp, everybody gets absolute power no matter what, their is no social hierarchy, thus no government, it's anarchy. That's why fundamentally weak languages with things tacked to mimic Common Lisp on succeed economically but Common Lisp does not. Self plug: I'm trying to figure out how a lisp bytecode interpreter could have capabilities, not extensively, but similar to the JVM.
TLDR: To understand the true power of Common Lisp, you MUST exercise restraint, otherwise you will make a complete mess of things while you are inexperienced.