It depends on your specific needs, and the strenghts and weaknesses of the particular implementations. That said, here is what first comes to my mind when thinking about different implementations:

SBCL is pretty fast, and good at number crunching. So, if you depend on heavy numerical computation, that might be the right implementation for you. Also, it has decent type inference (for a Lisp implementation).

CLISP is a relatively small, byte-compiling implementation that might be interesting for scripting.

A few years ago, I tried CCL and stuck with it, because I preferred its error messages and stack traces to the ones of other implementations, as well as its relatively low compilation times. For me, ease of interactive use is something of very high priority. If its speed is needed, I might still switch to SBCL for the deployed program. (Never needed to, though.) Also, there is the option of commercial support.

If you want to deploy on the JVM, there’s ABCL.

For embedded use, ECL.

Allegro has AllegroGraph, AllegroStore, a simple to use visual GUI builder, and much more, but not everybody likes their licensing terms.

LispWorks, seems to lend itself pretty well for end-user application programming with a nice cross-platform GUI toolkit and licensing terms that might fit small teams and single programmers better than Allegro’s. (At least it’s what I’d prefer.)

Of course, these are just broad categories and impressions. I’d suggest taking a closer look at SBCL, CCL, and CLISP, since those are IMHO the most used and best supported open source implementations, then choosing one of those. That is, unless your needs match with what ABCL or ECL have to offer.

Should it conform to the ASNI standard?

It wouldn’t be a CL implementation, if it didn’t. (There might, of course, be a few deviations in practice, but conformance should at least be the goal.)

Should it be supported by SLIME?

Sure – if you use SLIME. (In my opinion, it’s the best Lisp environment available at the moment, but to each his own.)

Do certain implementations lack good libraries, documentation, etc?

At least SBCL, CCL, Allegro, and LispWorks should be well supported by most of the libraries commonly used. CLISP comes with a pretty nice library collection itself, and should also be supported mostly.

Dan Weinreb (unfortunately he passed away last year) wrote an overview:

Lisp Survey

There are many differences between the CL implementations. It is not possible to cover all different needs (speed, size, license, price, compatibility, operating system support, …) of users for a Lisp system in one implementation. One has to find a local optimum by using one or more of the available implementations, which follow a certain philosophy:

• free, no-cost, C-based (thus widely ported): ECL, CLISP

• free, no-cost, JVM-based: ABCL

• free, no-cost, extensive native implementation: SBCL, CCL, CMUCL

• proprietary, commercial, very extensive native implementation, excellent support for GUI-based apps: Allegro CL, LispWorks

by OS/Platform:

• JVM: ABCL
• Linux: all
• Linux with GUI+IDE: Allegro CL, LispWorks
• Mac OS X with GUI+IDE: CCL or LispWorks
• MS Windows with GUI+IDE: Allegro CL or LispWorks
• Android and iOS application delivery: mocl