defining it prescisely is difficult, but i think there's something there worth being curious about!
when i write a big program, one nice thing i can do is look at the code and notice bugs and fix them. i can also ofc use the program normally and notice bugs. but the former is often more efficient for finding certain kinds of bugs, just because randomly bumping into the bug might be really hard. even if I am learning from my experience of where i previously found bugs to try and develop a mental model of ways the code might be flawed (i.e RL), my life would still be a lot easier if I've already seen the code.
the thing with NNs is that looking at the weights doesn't help you over the naive RL baseline in the same way as looking at the code of even a very large complex software project. this should be kind of surprising if we thought looking at the weights + algo gave us complete understanding! also, there are (admittedly unprincipled, hacky) transformations of weights/acts that give us a better mental model and therefore slightly more ability to find bugs in the models.
even if you don't want to call this thing understanding, it should be clear that there is a thing that is missing that helps our ability to make systems more robust
(there's one slight wrinkle which is because NNs are differentiable, you can do gradient based attacks, which destroys RL for attacking image models. but they don't work very well on transformer LMs, even if you do some tricks like GCG to get around the discreteness of the input space, so that in practice RL is SOTA for automatic red teaming.)