Interesting. Are you sure the increase in code reliability goes down to the language and not your skills? It feels quite contrary to my experience that a lower-level language would be more reliable.
The code reliability of assembly programs is better because programming algorithms in low level, the programmer controls every aspect of the execution. Notice, that excessive use of code generation macros will cancel this advantage.
Another advantage is that the bugs in assembly programs usually cause immediate crash of the program and this making the fixing easy.
Defer crashes and strange/random/undefined behavior of bugs in assembly programs is rare. IMO, this is because of reduced count of abstraction layers.
Because allow the programmer to not think (and even know) about some things and leaving them to the layer/libraries.
But every layer adds also a level of obscurity. The interaction between multiply layers is even more undefined and random.
It is OK while everything goes as expected. But when there are problems, the obscurity can make the debugging a hell.
In addition, the behavior of the bugs hidden deep in the layers (or in the way the layers interacts in between and with the application) can be really weird.
That is why, IMHO, the programmer should keep the abstraction layers to the minimal count that allows solving programming tasks with minimal effort, counting not only the coding time, but debugging and supporting time as well.
In my practice, I decided that using FASM with Fresh IDE and set of assembly libraries gives me the needed quality of the code.
For example, I don't know Lisp, so for me it is much harder to read/maintain Lisp project than assembly language project.