I still use 8 bit AVRs. They're simple, dependable and familiar. I messed around with ARM some but even just setting up the environment to develop for them is far more complex
This is fully your choice, not a necessity. I have never installed any complex environment for ARM development, and my setup is simpler than on AVR. On AVR, I use:
text editor
avr-gcc
avrdude
Special custom programming device - which always gets lost, and is a separate dongle in addition to USB serial used for development work
On STM32, I use:
text editor
arm-gcc-none-eabi
stm32sprog
Ubiquitous USB serial cable for both programming* and development prints.
*) at least initially, before I write my own flasher
And that's it.
Otherwise, my flow on ARM is exactly the same it was on AVR. The only difference is, instead of 300 pages of peripheral documentation, you have 3000 pages. You have many more features to utilize, and of course it will be a bit more complex. But there is absolutely no
fundamental difference. The basis is the same - just more details.
There are many simplifications, as well. ARM core is simple to understand, the memory models are easy and bring no surprises, large number of interrupt vectors and being able to use any standard function as interrupt handler makes understanding everything easier. Having no separate "fuses" means less confusion when programming a device and trying to get it work. (At some point, you tend to "brick" an AVR by typo'ing a fuse value - at least to a state where you are not experienced enough to recover it, for example, by using a function generator as a clock source. Won't happen on STM32.)
It's great when everything's nicely memory mapped, and everything just works automatically. No need to use special instructions to store data on flash only, like on AVR, for example.
On an AVR, lighting up an LED is two lines of code (DDR and PORT register writes). On an STM32, it's three lines of code - the IO port must be turned on first, then it's the same thing.
But, I agree all the details on a modern MCU can be overwhelming. A simple, small AVR gives a good initial idea how to work with microcontrollers
in general, and then you can go on. But I recommend going ARM
before you are on the level of understanding all the quirks and internal details of the ARM core.
But my strong personal opinion is: definitely keep the simplicity of the development flow you learn on an AVR. No need to go fancy with tools and libraries - they are mostly crap anyway.
For more complex stuff, I always write my own tools, which is very rewarding.
---
In general, it's up to what peripherals you need and which MCU provides them - the core is often the most irrelevant part. But, the peripherals
tend to be exactly the strong point of modern ARM controllers, compared to an AVR. On an AVR, a 3-phase motor control output or CAN controller is a specialistic flag-ship high end thing; on STM32, they are in the cheapest entry-level part. Similarly, multiple ADCs, DACs, comparators, opamps, etc. seem to be almost a norm.
But sure, sometimes an 8-bit PIC has
just the right set of peripherals for a job an STM32 with 8 UARTS and 5 SPIs and 5 IC2S and camera interface and 2 CANs and ethernet and USB high-speed and LCD interface and JPEG codec and God know what can't do as easily.