Were developers using monitors like e.g. "Supermon+64", "Merlin 64" or "Monitor$C000" and cartridges like "Final Cartridge", "Action Replay" (both of these were not available until the mid-80s or later, I think)?
Or games were written on more powerful computers (e.g. GEOS was), then compiled to 6502 machine language and transferred to C64?
The HES MON 64 cartridge, by Terry Peterson, seems to have been available as early as 1982 (same year as the C64). This, according to the copyright notice on the manual. While it is referred to as a "ML Monitor", it really comprises all the basic utility software you'd need to create assembly language programs on a C64.
HES MON 64 can be used to assemble code using its built-in assembler. You don't get fancy features like macros and advanced symbol management, but you can write assembly without those. The less advanced your assembly routines are, the less you will miss such features.
Additionally, the cartridge has a disassembler and a whole wealth of debugging commands, including breakpoints. You could get quite far with just knowledge of assembly and having mastered the commands supported by this simple cartridge.
I am referencing this particular cartridge because it is the one utility cartridge that I remember being very widely used by C64 programmers. It may even be seen reasonably as the main precursor to the many ML monitors that came after, and worked very similarly. For example, by the 1985 release of the C128, Commodore put a roughly equivalent ML Monitor into the firmware of their new machine.
Since these utilities reside in ROM on the cartridge, they don't hijack any significant RAM from the C64. Pretty much the whole 64K is available for programming code & data.
What's radically different here from the normal edit, compile/assemble, run/debug cycle you are used to is that you aren't bothering with source code files. Rather, you use the assembler to "write" your code directly into the machine's memory as ML, wherever in memory it needs to reside. Same with data. Then, you use other commands in the ML Monitor to "save" that memory, raw to disk or tape, as your finished program.
When you need to resume work later, you load the raw program back into memory, and can use the Disassembler to inspect, edit, execute, and debug. It sounds primitive, but it actually flows pretty smoothly. Nothing is wasted in terms of the computer resources available, and the utilities are all so "lightweight" that the operations all happen reasonably fast.
I guess the answer is "all of the above, and more". I was just a kid with a C-64 in his bedroom at the time, but from my recollection:
Cross compilers / assemblers existed; they were sometimes mentioned in magazine articles, usually involving a minicomputer, in the late 80s also a PC. However, this was rare and expensive, and limited to big companies.
Most people would develop on the C-64 itself, usually using some sort of integrated editor / assembler / linker. There were quite a few; the ones I used came from magazines like Input 64 ("INPUT ASS") or 64'er.
There were also compilers for BASIC and other high-level languages. PASCAL and COMAL come to mind.
Most developers would also have a monitor programs like the ones you mention in a modified kernal or on a cartridge, but for debugging rather than coding. (Though I knew some people who could code simple assembly languages programs directly in hex).
