Question: I am currently working on an application in WPF/C# for personal use. I am not a "classically trained" programmer. Simply a hobbyist that likes to code in his spare time. Is there any accepted approach to the progression of application development? I. E.; Make it work, add fault tolerance, create a gui, then performance optimization. Or maybe should I design the entire GUI first? Basically I am going to start a new project soon and would like to have some sort of "every program needs this" checklist.

Answer: 
There's really no "every program needs this" list, because there's absolutely nothing that *every* program needs.

Some advice, though: don't "make it work", then "add fault tolerance". Defensive programming and accounting for errors should be a continuing part of development. It's much simpler (and usually more effective) if you account for errors and unexpected input *when* you're writing a piece of code rather than after it's done.

As far as whether or not to make the GUI first, answer this question: is the most important aspect of the program *what it does* or *what it looks like*? That's a serious question that, honestly, can vary from application to application (though it's usually the former that's more important). 

If functionality is more important, model your information in code and get some basic "business logic" (a term of art that represents the non-visual logic in the application that carries out the rules and operations that are fundamental to the purpose of the program) in place, then create a GUI that interacts well with it. 

If the GUI is genuinely more important, create it first and model data objects and business logic around the GUI.

I would advise you to *peruse* [this Wikipedia article](http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle). It's pretty heady (as most technical Wikipedia articles are), but it provides some good links and will give you a rough idea of how the progression of software development and maintenance moves in the "real world".
What has worked for me in the past is the following (high level) sequence:

1. Understand and record the requirements (who, what and when) - use-cases, feature list, flowcharts, service level requirements - whatever works for you (I am partial to use-cases though).
2. Understand and record the design (how) - class diagrams, sequence diagrams, screen designs, API specifications - start high level and drill down (could start development before complete drill down)
3. Implement - start with API/stubs and unit tests, then fill in the code, update unit tests and execute unit tests as you go.
4. System test - test the components operating together and fix defects. Don't forget about performance testing (check that you have met your service level requirements from step 1).
5. Package, deploy and enjoy.