A whole bunch of CCL Cocoa coding involves calls to ObjC methods. For instance, the following ObjC code:
[cell drawWithFrame: frame inView: view];
will translate into this in CLL: 
(#/drawWithFrame:inView: cell frame view)
. Indeed, Objective C is designed around the record-based model (methods belong to classes), so the cell object receives the drawWithFrame:inView: message via the funny bracket syntax. On the other hand, the Lisp translation involves a generic function call with the usual funcall syntax. The dispatch occurs on the first argument (the cell), and the rest is actual arguments to the message.

This layout is obviously not optimal for readability. One could define a bracket reader-macro to simulate ObjC's message passing syntax in Lisp, but I prefer to stick to the "Lisp Way". The first argument should still be considered "special" though.

For readability (especially when the method name is long), I like to put the arguments to the message (not the receiver!) on subsequent lines. However, XEmacs's cl-indent-function will indent this as an ordinary function call, like this:
(#/drawWithFrame:inView: cell
                         frame view
which is awfull. What I want is the following indentation: 
(#/drawWithFrame:inView: cell
  frame view
This kind of indentation is normally achieved by putting a common-lisp-indent-function property of 1 on the function symbol. However, you don't want to do that on all possible ObjC message by hand (and you don't know them all in advance anyway). The following advice on common-lisp-indent-function (from the cl-indent package does the trick. It dynamically puts the property on each relevant symbol every time it is subject to indentation. A bit brute force, but it works smoothly.
(defadvice common-lisp-indent-function (before ccl-objc-bridge activate)
  "Improve indentation scheme of the CCL Objective-C bridge.
Currently, this does the following:

- All (#/doThis:withThat: ...) forms are indented as per a
lisp-indent-function property of 1. This effectively treats the first argument
(an object or a class) as special. The indentation you get is:

  (#/function arg1        instead of:        (#/function arg1
    arg2 ...)						 arg2 ...)"
  (let ((containing-form-start (elt state 1)))
    (save-excursion
      (goto-char containing-form-start)
      (forward-char 1)
      (cond ((looking-at "#/\\(\\w\\|:\\)*:")
	     ;; We're looking at a (#/doThis:withThat: ...) form. In its holy
	     ;; brokenness, common-lisp-indent-function with the help of
	     ;; parse-partial-sexp will consider that the function name in
	     ;; this form is "/functioncall:". Our trick here is to
	     ;; dynamically put a lisp-indent-function property of 1 on this
	     ;; symbol, so that the subsequent (original) indenting function
	     ;; will handle it.
	     (let* ((beg (progn (forward-char 1) (point)))
		    (sym (progn
			   (forward-sexp 1)
			   (intern (downcase (buffer-substring beg
							       (point)))))))
	       (put sym 'common-lisp-indent-function 1)))))))

One last thing and I'll be happy: I want to indent CCL's slet and slet* constructs just as let:
(put 'slet 'common-lisp-indent-function 
     '((&whole 4 &rest (&whole 1 1 2)) &body))
(put 'slet* 'common-lisp-indent-function
     '((&whole 4 &rest (&whole 1 1 2)) &body))

Et voilà !