It depends on the system as there are different levels.

1. Promote comments above code. So the syntax for comments is the default. A simple notion is a markdown file where the process to create the program is to concatenate all the code blocks in order of appearance. Everything else is irrelevant to the code generated, but relevant to the developer. The idea here is to just promote communication of the reasons why and basic philosophy that leads to the code. The what should largely be easily readable from well-written code, but the reason for this choice versus that choice is what the comments want.

2. Reorder code. So each code block has a name and can be inserted in other code blocks. Order is irrelevant. This allows one to have, say, conditional logic easily readable without the actual code in between being executed. Functions can serve this purpose too, but the advantage of this style is that one can see the woven code together and read it as a whole in addition to this separated version. It helps prevent functions from being used purely as a reordering mechanism and to have functions being used only when its features are truly needed, such as repeatedly calling the same code. This allows for an in-between of avoiding copy-and-paste and avoiding unnecessary function calls (too many can lead to bouncing all over the place to see what is actually being executed).

The first two together is what is generally taken to be the mains of literate programming. This third one, however, is what I love about it.

3. Arbitrarily changing the code bits before insertion. This allows a lot of little DSL applications, easily inserting code from one language into another (e.g., writing markdown that converts into HTML that is embedded in a JS render function). This can also be used to do copy-paste-modify on a programmatic level. I often find this step to be one just before making an actual function, but somehow it helps me step through it all more easily.

4. Arbitrarily arranging inputs and outputs. Basically, write code entirely the way you (or your team, but probably just you) want to write it. If you want HTML, JS, and CSS all located together in functional units but put into separate files, no problem. If you want them coded in separate files but them brought into one HTML file, no problem. You want to manage configuration, installation, compiling, ..., no problem. You can write these files all separately, together, in pieces of relevance, etc. The danger is of course that your preferred style will not match others, but the hope of the original comment before code will allow people to follow. Essentially, you can read a top-level project management file that tells you where to look for all the other bits and it is faithful because this is how the system is being created.

---
A system that I created that does all of that is https://github.com/jostylr/literate-programming It does work and I tweak every now and then, but it certainly is not in an ideal state. It is a npm installable command line program and there is a 10% written book linked to from the README (free to read on Leanpub in HTML style). Almost every command is documented in there, but just barely.

It is a markdown-based tool. I had experimented with creating a different tool called pieceful-programming which would allow for changing the basic literate style (say instead of markdown, using asciidoc). But I did not complete it (yet?).

I used my tool for web programming, allowing me to freely arrange backend and frontend code as I see fit.