Perhaps one of the highest bars to entry to learning and becoming proficient with C is that the tooling, though actually being of very high quality, takes a while to get comfortable with. Though even a whole class would be unlikely to bestow confidence in the whole environment, I think this first session should begin by introducing the compiler.
For this class, we will be using clang. Additionally, we will be moving forward under the asumption that the students all have access to a relatively new version though nothing we mention is likely to be specific to the latest version.
We will introduce three flags that we will be advising all students to use: -Weverything, -Werror and -std=c11.
More flags will be discussed later as we broach more significant topics (e.g., -fstack-protector-strong).
We will not require students to use a specific text editor; however, we should encourage students to research which text editors are available and choose one they think works well for them. We should place some restrictions (e.g., it needs to be able to handle line-endings correctly (i.e., Microsoft Wordpad will not work)), but they will be general and still need to be worked out.
There are, at least, two other tools we should mention to students, though I do not believe we will be introducing them in this session: valgrind and gdb (or lldb). We should say what they are for and offer students some reading on them to be done, perhaps, before the next class. A canned intro of segfaulting code and some light instructions of how to debug/fix it? (see jy2wong)
Before the class is over, we should aim to have students have correctly compiled and run their own "Hello, World!" program. We should introduce the concepts line-by-line to construct the program.
The above, even though it is actually not as simple as it could be (e.g., we will introduce puts() after this), is a valid C11 "Hello, World!" that introduces several important concepts and syntax and is mostly best-practice.
We will also be using make and Makefiles. Ideally, we would provide a very simple Makefile that provides the most basic setup possible while still being correct. It should include a rule to build the first project so that users can see how their first running of the compiler translates into a simple Makefile.
Now that we have seen some of the basic syntax, we should start covering types.
We will try to cover all the scalar types, arrays and structs. cf. https://en.wikipedia.org/wiki/C_data_types
We will also cover implicit promotion, casting and unions.
This might be a good time to do a FizzBuzz implementation. We will need to introduce a couple more operators (% and ==) and a few control flow semantics for and if. But since this is not a class for programming beginners, it should be refresher for them.
This class will begin by covering C's memory model, and introducing pointers. Ideally, we will be able to describe pointers in a fairly simple way (they are memory addresses represented by unsigned integers the same size as the word size on the machine).
In addition to introducing pointers, we will introduce the operators -> and .. We will also revisit  and introduce * and define all four operators (which is pretty easy to do since they are all roughly identical). This lets us leverage a couple of the well-known fun examples of things like 2["abc"] being equal to 'c'.
Given that we have introduced structs and arrays, we will cover exactly how strings work in C and should mess with them. Now seems like a good time to do some fun with IO. The typical IO introduction project is a guessing game.
Most C classes fail to adequately prepare people for one of---if not the---most annoying/tricky thing of C: undefined behavior.
This class should discuss it at length, offer examples of it, and give lots of useful resources and readings. It should also offer some examples of what the compiler can do to help the programmer (e.g., foreshadow clang 3.8's -fsanitize-trap=undefined)
We covered the Memory Model already in the pointers class, but we should also discuss actually working with memory management (namely with malloc() and free()).
We have already seen a few small libraries, let's introduce some others. I do not know yet what libraries we should introduce, because we still want them to be simple; perhaps jansson or libcurl (recommended since I know these two quite well)?
By this point, the projects will clearly have reached a point where they cannot be completed during the class, so this will need to be a culminating project to be completed by the student for their own enjoyment. TBD.