If APIs become copyrightable, we just have to change our strategy a little bit. Instead of making a compatible API, you write a program to modify other programs, which detects calls to the target API and transforms them to a shim that is not copyrighted, which can call either the copyrighted API or your new API.
First, as colejohnson66 pointed out, that may be a derivative work. This will depend on how your transformer actually works.
I can't think of any way to do it that does not involve having access at run time to a copy of the copyrighted API. If that copy is part of the transformer, there is a good chance the transform is a derivative work.
If the transformer does not include the copyrighted API, instead getting information about it from some external source that the user must supply at run time such as via an input file describing the API using some sort of API description language then it is much less likely to be a derivative work. Well, at least if it somewhat general, working with several APIs described in that language rather than just working with the one particular copyrighted API.
Second, even if it is not a derivative work, the people who use it to make the shim might be infringing. Usually that would not be your problem (unless you do something like indemnify your users, which I'll assume you would not be insane enough to do).
However, you have to at least consider contributory infringement. If I infringe someone's copyright using tools I got from you, and those tools have no substantial use other than infringing copyright, you can be held liable along with me for the infringement.
As with the derivative work case, if you can make the transformer general purpose so that it can be used for transforming APIs that are not copyrighted too, you should be able to avoid contributory infringement.
I'm thinking of a static analysis engine. "Look for function calls like this and replace them with calls to this shim and/or my new API." I am not sure how the shim could possibly be infringing as it would be my original work. (All new method names, all new module organization, all new namespaces. Maybe even different argument types, where possible.) There would be a version of the shim that would delegate to the original API, and another that would delegate to mine.
