It's not that difficult. Lisp makes it easier, because one can look at code.

For example look at this built-in Lisp macro example, which iterates from 0 to 9 and writes the numbers.

    CL-USER> (dotimes (i 10)
               (write i))                                                                                                                                                               
    0123456789             
    NIL

Common Lisp has tools like a pretty printer for code (-> PPRINT) and a tool for expanding a macro form:

    CL-USER> (let ((*print-right-margin* 30))
               (pprint (macroexpand '(dotimes (i 10) (write i)))))                                                                                                                                    
                           
    (BLOCK NIL                                                                                                                                                                                        
      (LET ((I 0))         
        (DECLARE                                                                                                                                                                                      
         (TYPE UNSIGNED-BYTE I))
        (DECLARE (IGNORABLE I))                                                                                                                                                                       
        (TAGBODY           
          (GO #:G267)                                                                                                                                                                                 
         #:G266            
          (TAGBODY (WRITE I))                                                                                                                                                                         
          (PSETQ I (1+ I)) 
         #:G267                                                                                                                                                                                       
          (UNLESS (>= I 10)
            (GO #:G266))
          (RETURN-FROM NIL
            (PROGN NIL)))))

From above one can see that the code gets transformed in very low-level Lisp code, with a GO operator (-> a GoTo). It's a low-level loop expressed by loop made from a simple goto operator. One can look at the code and try to figure out what it is doing. One is not guessing what the expanded code looks like, one can generate the expanded code and see what it looks like.