Systems like MS' macros require that every feature in the software be written with the intention of allowing recordability. Not impossible in LiveCode, but also not trivial.
In some contexts it's possible to use built in language features like frontScripts, mouseControl, and others to approximate some types of activity recording, but even these are made problematic by the inherent flexibility of the LiveCode language, since an author of one stack may write scripts that respond to messages in ways that are completely different from another, where details about the context of the execution, both in terms of objects at the moment and the workflow over time, can alter behavior.
My own explorations in this have been for automated testing, in which I spent only enough time to get around special challenges like handling modal dialogs but not enough to handle the critical part of results evaluation; that is, making sure that a given set of actions didn't merely not crash, but resulted in a specific outcome. I haven't yet invested the time needed to complete that last aspect, as it's a bit of work to do gracefully.
Most generalized automated testing tools take a different approach, looking only at the pixels as a representation of outcomes. Eggplant is a good example, and FWIW uses a similar language for its scripting:
http://www.testplant.com/eggplant/
For learning, over the years I've seen many different learning styles attempted, with widely varying results. I can appreciate the desire to see auto-generated scripts describing interactions, but as you learn more about LiveCode, and programming in general, I think you'll come to appreciate how such output would often differ quite starkly from the actual code used within the program being recorded.
So if the goal is to learn how to write programs in LiveCode, the best way I've seen yet is to dive in and start writing.
Start small with something simple, like reading a text file into a field and being able to save the changed text back out to the file.
Then you could add to that to support text styles, outputting formats in things like RTF, adding menus to handle text editing features, and even if you never make the world's greatest text editor you'll have learned a lot along the way.
While you're writing, read other people's code too. Some code in the community is complex, and may be difficult for newcomers to grasp readily. But there are also many examples written specifically with newcomers in mind - consider the lessons at LiveCode.com:
http://lessons.runrev.com/
In fact, there are so many examples aimed at newcomers (72 of them are included in the LiveCode installation - click the Resources button in the toolbar) that you may be able to find one that fits your particular interests. You can make a copy of it, explore the code, look up any syntax that's new to you in the Dictionary, and modify it to explore new things you can do with the language.
There are many useful things that can be done with macros, but learning about the programming language the macro system was written with isn't their strongest value.
To learn LiveCode, write LiveCode. Start small, build over time, and when you have questions you've already taken the first step in learning by joining these forums.