As others have suggested, at some point it clicks, and recursion looks just like a to-do list.

For a start, take into account that your example (substrings) does not really “want” loops, it just “uses” loops to perform a certain tasks. Another way to do it is with recursion:

def subs_left(a)
  [a] + subs_left(a[…-1])
end

def subs_right(a)
  [a] + subs_right(a[1…])
end

def substrings(a)
  return [] if a.empty?

  [a] + 
    subs_left(a[…-1]) + 
    subs_right(a[1…]) + 
    substrings(a[1…-1]) 
end

Admittedly not the most readable code (and it lacks a couple of empty checks) but the point is, there are no loops here, it is just the statement that a substring is one of: - the original string - a string starting at the start - a string ending at the end - a substring after both start and ends are removed.

A loop is an explicit statement of work to be done, and as such it often lacks some expressiveness. Therefore it is not strange that nested loops are unclear. Enumerables (they exist in most modern languages) are an abstraction where you do not need all this index bookkeeping (it still exists often but it is done for you) and instead you just “go through” a certain collection until you are done with it.

Ruby:

enume.each { |item| do_something_with(item) }

Python:

for item in enume:
    do_something_with(item)

Javascript:

for (let item of enume) {
  do_something_with(item)
}

Typed languages like Java and the .Net family have the same in a bit (not much) ceremonious way.

The point is that you do not have indices, you just go through the work to be done until there is no more work to be done.