In short - nothing. Templates are used with APP files, not hand-coded projects. So in this case, unfortunately, completely useless to you.
As a bit of background;
The term “Clarion” applies to many things. The IDE certainly. And the language. And you can certainly write “normal” code in the language, using the IDE, compile that to an Exe and run it. The language itself is reasonably clean, and has some nice features (including complex data types like QUEUE’s, FILE’s (Tables), VIEWs, WINDOWs and REPORT’s.)
Most people though do not use the language in this way. (Some do - some have very large hand-coded projects.) Most people use another “Clarion” thing - called the Application Generator (or AppGen for short.) To some people, if you talk about Clarion you are talking about AppGen.
AppGen takes a dictionary, and templates, and “user settings” for input and generates CLWs (etc) for output. The compiler (the bit you are using) then takes those CLW’s and compiles them in the normal way.
At first glance AppGen could easily be dismissed as another “code generator”, but in truth it’s an exceptionally powerful layer which focus’s on code reuse. It is, if you like, a “meta” language - (called the Template Language). Folks proficient in the template language are able to write code in such a way that it can be reuses in “any” application. Most often Templates simplify the task of instantiating objects, initialising them, and then having them interact with the rest of the procedure (or application.)
Most programmers do not write templates. You do not need to write templates to make use of AppGen since the system comes with a bunch of existing templates. I would suggest that perhaps 98% of Clarion developers have never written a template, and never will.
Using this system a less-proficient developer can add code to their system that they would not have been able to write themselves. They are, in effect, leveraging the code-quality of the supplier at both the “class” level but also at the “integrating into your program” level. There exist several, really successful, developers who write very little, or none-at-all, code of their own. Some (and they wouldn’t mind me saying this) would not be able to write a single line of code if you asked them to. This may seem strange (shouldn’t programmers write code?) - but Clarion has always been more focused on the result (shipping programs, getting paid) than on the process (getting programmers to write a lot of code.)
Of course the quality of the generated code is as good as the quality of the templates. The better your templates, the better your code. Not surprisingly, given the 25 years since Clarion for Windows appeared, there are a lot of templates floating around - some free, some commercial. The standard of template code, just like any code, varies.
Incidentally the use of templates does not restrict you to “only that code” - you are able to “embed” your own code into the generated code using the “embeditor”. Templates have techniques for creating places for you to do this (“embed points”) so Apps, and templates, are not the “end of the journey” but the beginning of it.
A “perfect” app would be one that maximises the use of “generic” (reusable) code - via templates and classes, and then adds the minimal amount of embed code possible to make the program you are wanting to make.