The biggest advantage of using SBCL over other Common Lisp implemnetations is that it has very good support for Common Lisp types:

https://www.sbcl.org/manual/index.html#Handling-of-Types

I "(declaim)" the types of my exported functions (at least) which makes life much easier when consuming the library's API, and when you make a mistake (either in the caller or the implementation) you'll get either an error or a warning when you compile the function. The types also show up in the documentation in SLIME and can (but is not guaranteed to, you can check with (time) and (disassemble) and (sb-profile)) make code much faster... specially if you need a lot of numeric computation, declaring the types of the numbers as `fixnum` or `single-float` (you may need to explicitly restrict the range of the numbers too to get the best Assembly) your code can run much faster as that will let it compile to basically what C would do, as it avoids the Lisp numerical tower slowing things down.

Quick comparison between CL with types and Typed Python as both are dynamic languages with types added later in?

Common Lisp has always had types and type declarations (e.g. `the` in the hyperspec[1]) as it's part of the specification. It was not added later as far as I know.

However, `declaim` and `declare` were left very underspecified so they tend to be very implementation-specific, though there are libraries that make types more portable[2][3].

[1] http://www.lispworks.com/documentation/HyperSpec/Body/s_the....

[2] https://github.com/lisp-maintainers/defstar

[3] https://github.com/ruricolist/serapeum/blob/master/REFERENCE...