The condition restart system combined with its relative lack of syntax, macros/reader macros and solid support for multiple paradigms (functional, imperative, OOP (not in the poo sense, real OOP)). It allows you to write an arbitrary language with arbitrary syntax straight into your lisp (for example, when haskell and lisp got a rivalry going at the beginning, it took just one person to write the entire haskell type discipline into lisp, an effort that was repeated tons of times, whereas haskell needed dozens of eggheads to do the same). This is fantastic to extend the language (e.g. if you want literal hashtable syntax which is sadly not available by default) and to write DSLs (to greatly speedup development). Additionally, the syntax is trivial to parse (because there's not really any syntax, you're pretty much writing an AST straight up), which is great to implement it on new hardware. The condition/restart system means you can run an expensive task (e.g. scientific simulation) and even if you have a bug somewhere that only shows up after 20 hours of runtime, you won't lose ANY of your work, you can just fix the code and continue on the exact iteration where you left off. Iteration itself is expensive? No problem, you can hotpatch the code right then and there and keep going at the error prompt.
The lack of syntax also means you can very easily refactor. Consider:
(+ 1 (* 2 3))
In other languages, substituting the arguments (1 and (* 2 3)) might require putting up parens, brackets, semi-colons, breaking down the code on multiple lines, or worse: it might not be possible. In lisp, this is just
(+ (if (> x 5) 2 6) 3)
You can thus perform refactoring that requires complex tooling in other languages just with a simple "between parentheses" substitution or "word" substitution. No extra tools needed.