I've done a lot of programming on X86 since the early 90s, and have programmed lots of other architectures at low levels since then.
Yeah, when I think back to what X86 was back then ... frightening ... 16-bit programs with segments ... DOS extenders ... X87 stack based FPU programming... limited registers that seem to have different restrictions for each instruction ... indeed ... really it's pure hell when you think about it. 25 years ago I'd bow down and worship 68k and curse X86.
I used to look at 68k way back then with great envy. Dabbled enough to know it was very nice.
Worked on MIPS, PowerPC and lots of custom CPUs since then. Some were very nice with 32 registers that can be used in any way. It made ASM programming a breeze and actually understandable since you didn't have to constantly re-purpose what each of the 4 pathetic X86 registers you have available to you was for as your algorithm went into ASM.
Oddly I didn't have a huge pile of love for the PowerPPC ISA, I found even basic things like calling a function were a tad awkward.
However, when you get into modern computing, I think you would have to be nuts to write anything more than 0.01% of your code in ASM for scalar (non-SIMD) code. Visual Studio C++ for example is an incredible compiler these days, good luck beating it in a meaningful way. Compilers for other platforms are generally not as good, but going away from C++ for scalar stuff is still a bit crazy.
So the only code that typically needs non-standard programming is vector (SIMD) programming, or taking advantage of some other things a compiler can't figure out (branch hints, cache control, etc.). And even here, sane people don't use ASM programming anymore, they use intrinsics to achieve basically the same thing but let the compiler handle all the ugly register allocation.
I'd also say that most CPU's SIMD instruction sets are pretty darn similar to each other these days. These are instruction set extensions that have been added in later years, and I think designers had things figured out enough that they all look pretty similar to each other. And again, modern programming sees these accessed via intrinsics which abstracts the differences even more - no more worry about what registers allow what or what or if the left operand is read or write or whatever.
From my experience X86/64 is also more robust and forgiving than other architectures. More often you can get away with unaligned reads/writes, the memory coherence is more robust, etc. Stuff that you can get away with on X64 may require special programming on other architectures. I haven't really found that to be the case the other way around though.
So now it's X64 I bow down and worship to. I'll take my excellent Visual Studio and easily write and debug some amazingly fast code with little effort and see it run ridiculously fast on my Core i7. What the heck is not to like? It's other new platforms that I have to program that now fill me with a sense of dread.