I've used CakePHP for quite a while now, so here are the things I find most problematic about it:

Auth and ACL functionality

Many superficial reviews point this out as a strength of CakePHP. It is definitely NOT a strong point, because the included ACL is too darn complex. In particular, the ACL functionality has multiple different modes: actions mode (e.g. read, write permissions), CRUD (e.g. create, read, update, delete permissions) mode (both DB-based) and a file based mode.

These modes each require different types of database table setup in terms of how you will structure the permissions. Unfortunately, doing that is also rather complex because the ACL stores the rights using the MPTT (Modified Preorder Tree Traversal) method. If you aren't using MPTT elsewhere, then that's another thing to figure out, and manually figuring out what is going on is quite painful. I also remember reading someone gripe about the number of queries it generates.

Furthermore, there is a large number of tables and keeping these in sync is left as an exercise to the implementer. In particular, while creating a new user will update the appropriate ARO table rows, subsequent updates the user or groups will need to have their ARO synchronization implemented manually since Cake's magic does not handle these parts.

Code generation

It is easy to get started with generating models, views, controllers and tests, but code generation is a rather minor benefit in my opinion, since once you get past the first version of the program you will still end up writing more UI code and scrapping most of the generated code.

A minor annoyance is that the generated controllers and views separate the view and edit actions, which is in many cases not really necessary. You can often use the edit view for viewing data - which leads to less code to maintain (one view vs. two views). Here is how you can do that (CakePHP tips booklet).

Scaffolding

Scaffolding is nice in the first five minutes. However, in particular with models it tends to get in your way when you least expect it. In particular, the scaffolding for plugins is easy to trigger accidentally because CakePHP expects a particular naming scheme - and then you end up wondering why the models you just created don't seem to have any of the functions you added.

I've ended up patching the core so that CakePHP dies if it tries to load a scaffolded model - and that has made these bugs easier to prevent. Here is how I did it.

Furthermore, the scaffolding gets things wrong in complex cases - for a simple example, an hasOne and a hasMany have identical table structures, so it isn't possible to correctly determine which one should be used. And then there are the HABTM join tables, which you might want to retrieve as separate entities (e.g. due to relation data in the join table) in addition to the actual tables.

ORM

The most awesome part of CakePHP is the Containable behavior. The base ORM is a bit greedy, and reads all attached models - and setting the recursive param to a particular level is a very blunt tool for including/excluding attached data.

However, I really like the Containable behavior, which allows you to specify arbitrarily deep nesting paths. This is a huge time saver.

Of course, the ORM returns arrays rather than objects, which is a limitation, but one that I can live with - and PHP5 will be in the core sooner or later.

Helpers

CakePHP's Form helper is a bit of a pain in the neck if you want to use your own markup rather than whatever CakePHP wants you to use. Some unwanted markup gets added automatically. The element creation functions differ slightly from each other, which means you need to look them up (e.g. form->radio vs. form->select) from the manual quite frequently. Kohana 3 has a nicer API.

The magic, while helpful for standard forms is problematic if you really need to build a custom form. It would be better if the base Form helper were simpler and there would be an extended version which would implement things like the surrounding markup rather than having these two in the same helper.

The Paginator helper is quite nice for implementing paginated views.

Models

CakePHP does provide callbacks such as afterSave for models, but at least for now these do not actually fire in all of the "edge cases" such as in associated models. This means that one can't rely on those to actually work in all cases, which is a shame.

Is it worth it?

All in all, these are the problems I've run into using CakePHP. It's not a bad framework, there are just cases in which it is a bit too magical. I recommend keeping these things in mind when considering whether to use Cake - you might not run into any of these issues at all for some types of applications, while others will.