diff --git a/README.md b/README.md
index 7bfe15c..15a378d 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,125 @@
 jWalterWeatherman
 =================
 
-a simple feedback and logging library for go
+A simple printing and logging library for go
+
+![Always Leave A Note](http://spf13.github.com/jwalterweatherman/and_that__s_why_you_always_leave_a_note_by_jonnyetc-d57q7um.jpg)
+Graphic by [JonnyEtc](http://jonnyetc.deviantart.com/art/And-That-s-Why-You-Always-Leave-a-Note-315311422)
+
+JWW is primarily a convenience wrapper around the
+excellent standard log library.
+
+I really wanted a very straightforward library that could seamlessly do
+the following things.
+
+1. Replace all the println, printf, etc statements thought my code with
+   something more useful
+2. Allow the user to easily control what levels are printed
+3. Allow the user to easily control what levels are logged
+4. Provide good feedback (which can easily be logged) to the user
+5. Due to 2 & 3 provide easy verbose mode for output and logs
+6. Not have any unnecessary initialization cruft. Just use it.
+
+# Usage
+
+## Step 1. Use it
+Put calls throughout your source based on type of feedback.
+
+Available Loggers are:
+
+ * TRACE
+ * DEBUG
+ * INFO
+ * WARN
+ * ERROR
+ * CRITICAL
+ * FATAL
+
+These each are loggers based on the log standard library and follow the
+standard usage. Eg..
+
+```go
+    import (
+        jww "github.com/spf13/jwalterweatherman"
+    )
+
+    ...
+
+    if err != nil {
+        jww.ERROR.Println(err)
+    }
+
+    // this isn’t that important, but they may want to know
+    jww.INFO.Printf("information %q", response)
+
+```
+
+
+## Step 2. Optionally configure it
+
+By default:
+ * Debug, Trace & Info goto /dev/null
+ * Warn and above is logged (when a log file/io.Writer is provided)
+ * Error and above is printed to the terminal (stdout)
+
+
+### Changing the thresholds
+
+The threshold can be changed at any time, but will only affect calls that
+execute after the change was made.
+
+This is very useful if your application has a verbose mode. Of course you
+can decide what verbose means to you or even have multiple levels of
+verbosity.
+
+
+```go
+    import (
+        jww "github.com/spf13/jwalterweatherman"
+    )
+
+    if Verbose {
+        jww.SetLogThreshold(jww.LevelTrace)
+        jww.SetOutputThreshold(jww.LevelInfo)
+    }
+```
+
+### Using a temp log file
+
+JWW conveniently creates a temporary file and sets the log Handle to
+a io.Writer created for it. You should call this early in your application
+initialization routine as it will only log calls made after it is executed. 
+
+```go
+    import (
+        jww "github.com/spf13/jwalterweatherman"
+    )
+
+    jww.UseTempLogFile("YourAppName") 
+
+```
+
+### Setting a log file
+
+JWW can log to any file you provide a path to (provided it’s writable).
+Will only append to this file.
+
+
+```go
+    import (
+        jww "github.com/spf13/jwalterweatherman"
+    )
+
+    jww.SetLogFile("/path/to/logfile") 
+
+```
+
+
+# More information
+
+This is an early release. I’ve been using it for a while and this is the
+third interface I’ve tried. I like this one pretty well, but no guarantees
+that it won’t change a bit.
+
+I wrote this for use in [hugo](http://hugo.spf13.com). If you are looking
+for a static website engine that’s super fast please checkout Hugo.
diff --git a/jww_test.go b/jww_test.go
index 4b122d5..91c6b9b 100644
--- a/jww_test.go
+++ b/jww_test.go
@@ -12,13 +12,13 @@
 )
 
 func TestLevels(t *testing.T) {
-    SetOutLevel(LevelError)
-    assert.Equal(t, OutLevel(), LevelError)
-    SetLogLevel(LevelCritical)
-    assert.Equal(t, LogLevel(), LevelCritical)
-    assert.NotEqual(t, OutLevel(), LevelCritical)
-    SetOutLevel(LevelWarn)
-    assert.Equal(t, OutLevel(), LevelWarn)
+    SetOutputThreshold(LevelError)
+    assert.Equal(t, OutputThreshold(), LevelError)
+    SetLogThreshold(LevelCritical)
+    assert.Equal(t, LogThreshold(), LevelCritical)
+    assert.NotEqual(t, OutputThreshold(), LevelCritical)
+    SetOutputThreshold(LevelWarn)
+    assert.Equal(t, OutputThreshold(), LevelWarn)
 }
 
 func TestDefaultLogging(t *testing.T) {
@@ -27,23 +27,30 @@
     LogHandle = logBuf
     OutHandle = outputBuf
 
-    SetOutLevel(LevelInfo)
-    SetLogLevel(LevelWarn)
+    SetLogThreshold(LevelWarn)
+    SetOutputThreshold(LevelError)
 
+    FATAL.Println("fatal err")
     CRITICAL.Println("critical err")
     ERROR.Println("an error")
     WARN.Println("a warning")
     INFO.Println("information")
     DEBUG.Println("debugging info")
+    TRACE.Println("trace")
 
+    assert.Contains(t, logBuf.String(), "fatal err")
     assert.Contains(t, logBuf.String(), "critical err")
     assert.Contains(t, logBuf.String(), "an error")
-    assert.Contains(t, logBuf.String(), "information")
     assert.Contains(t, logBuf.String(), "a warning")
+    assert.NotContains(t, logBuf.String(), "information")
     assert.NotContains(t, logBuf.String(), "debugging info")
+    assert.NotContains(t, logBuf.String(), "trace")
+
+    assert.Contains(t, outputBuf.String(), "fatal err")
     assert.Contains(t, outputBuf.String(), "critical err")
     assert.Contains(t, outputBuf.String(), "an error")
-    assert.Contains(t, outputBuf.String(), "information")
     assert.NotContains(t, outputBuf.String(), "a warning")
+    assert.NotContains(t, outputBuf.String(), "information")
     assert.NotContains(t, outputBuf.String(), "debugging info")
+    assert.NotContains(t, outputBuf.String(), "trace")
 }
diff --git a/thatswhyyoualwaysleaveanote.go b/thatswhyyoualwaysleaveanote.go
index 2470578..9a2e2f1 100644
--- a/thatswhyyoualwaysleaveanote.go
+++ b/thatswhyyoualwaysleaveanote.go
@@ -17,109 +17,124 @@
 // debug and critical.
 type Level int
 
-//TRACE
-//DEBUG
-//INFO
-//WARN
-//ERROR
-//CRITICAL
-//FATAL
-
-type JWWLevel struct {
+type NotePad struct {
     Handle io.Writer
-    Level  int
-    *log.Logger
+    Level  Level
+    Prefix string
+    Logger **log.Logger
 }
 
+// Feedback is special. It writes plainly to the output while
+// logging with the standard extra information (date, file, etc)
+// Only Println and Printf are currently provided for this
 type Feedback struct{}
 
-// Log levels to control the logging output.
 const (
-    LevelDebug Level = iota
-    LevelWarn
+    LevelTrace Level = iota
+    LevelDebug
     LevelInfo
+    LevelWarn
     LevelError
     LevelCritical
+    LevelFatal
+    DefaultLogThreshold    = LevelWarn
+    DefaultOutputThreshold = LevelError
 )
 
 var (
-    DEBUG          *log.Logger
-    WARN           *log.Logger
-    INFO           *log.Logger
-    LOG            *log.Logger
-    ERROR          *log.Logger
-    CRITICAL       *log.Logger
-    FEEDBACK       Feedback
-    DebugHandle    io.Writer = os.Stdout
-    WarnHandle     io.Writer = os.Stdout
-    InfoHandle     io.Writer = os.Stdout
-    ErrorHandle    io.Writer = os.Stdout
-    CriticalHandle io.Writer = os.Stdout
-    logLevel       Level     = LevelWarn // 1
-    outLevel       Level     = LevelInfo // 2
-    LogHandle      io.Writer = ioutil.Discard
-    OutHandle      io.Writer = os.Stdout
-    BothHandle     io.Writer = io.MultiWriter(LogHandle, OutHandle)
+    TRACE      *log.Logger
+    DEBUG      *log.Logger
+    INFO       *log.Logger
+    WARN       *log.Logger
+    ERROR      *log.Logger
+    CRITICAL   *log.Logger
+    FATAL      *log.Logger
+    LOG        *log.Logger
+    FEEDBACK   Feedback
+    LogHandle  io.Writer  = ioutil.Discard
+    OutHandle  io.Writer  = os.Stdout
+    BothHandle io.Writer  = io.MultiWriter(LogHandle, OutHandle)
+    NotePads   []*NotePad = []*NotePad{trace, debug, info, warn, err, critical, fatal}
+
+    trace           *NotePad = &NotePad{Level: LevelTrace, Handle: os.Stdout, Logger: &TRACE, Prefix: "TRACE: "}
+    debug           *NotePad = &NotePad{Level: LevelDebug, Handle: os.Stdout, Logger: &DEBUG, Prefix: "DEBUG: "}
+    info            *NotePad = &NotePad{Level: LevelInfo, Handle: os.Stdout, Logger: &INFO, Prefix: "INFO: "}
+    warn            *NotePad = &NotePad{Level: LevelWarn, Handle: os.Stdout, Logger: &WARN, Prefix: "WARN: "}
+    err             *NotePad = &NotePad{Level: LevelError, Handle: os.Stdout, Logger: &ERROR, Prefix: "ERROR: "}
+    critical        *NotePad = &NotePad{Level: LevelCritical, Handle: os.Stdout, Logger: &CRITICAL, Prefix: "CRITICAL: "}
+    fatal           *NotePad = &NotePad{Level: LevelFatal, Handle: os.Stdout, Logger: &FATAL, Prefix: "FATAL: "}
+    logThreshold    Level    = DefaultLogThreshold
+    outputThreshold Level    = DefaultOutputThreshold
 )
 
 func init() {
-    SetOutLevel(LevelInfo)
+    SetOutputThreshold(DefaultOutputThreshold)
 }
 
+// Initialize will setup the jWalterWeatherman standard approach of providing the user
+// some feedback and logging a potentially different amount based on independent log and output thresholds.
+// By default the output has a lower threshold than logged
+// Don't use if you have manually set the Handles of the different levels as it will overwrite them.
 func Initialize() {
-    initWriters()
+    BothHandle = io.MultiWriter(LogHandle, OutHandle)
 
-    DEBUG = log.New(DebugHandle,
-        "DEBUG: ",
-        log.Ldate|log.Ltime|log.Lshortfile)
+    for _, n := range NotePads {
+        if n.Level < outputThreshold && n.Level < logThreshold {
+            n.Handle = ioutil.Discard
+        } else if n.Level >= outputThreshold && n.Level >= logThreshold {
+            n.Handle = BothHandle
+        } else if n.Level >= outputThreshold && n.Level < logThreshold {
+            n.Handle = OutHandle
+        } else {
+            n.Handle = LogHandle
+        }
+    }
 
-    INFO = log.New(InfoHandle,
-        "INFO:  ",
-        log.Ldate|log.Ltime|log.Lshortfile)
+    for _, n := range NotePads {
+        *n.Logger = log.New(n.Handle, n.Prefix, log.Ldate)
+    }
 
     LOG = log.New(LogHandle,
         "LOG:   ",
         log.Ldate|log.Ltime|log.Lshortfile)
-
-    WARN = log.New(WarnHandle,
-        "WARN:  ",
-        log.Ldate|log.Ltime|log.Lshortfile)
-
-    ERROR = log.New(ErrorHandle,
-        "ERROR: ",
-        log.Ldate|log.Ltime|log.Lshortfile)
-
-    CRITICAL = log.New(CriticalHandle,
-        "CRITICAL: ",
-        log.Ldate|log.Ltime|log.Lshortfile)
 }
 
-// Level returns the current log level.
-func LogLevel() Level {
-    return logLevel
+// Level returns the current global log threshold.
+func LogThreshold() Level {
+    return logThreshold
 }
 
-func OutLevel() Level {
-    return outLevel
+// Level returns the current global output threshold.
+func OutputThreshold() Level {
+    return outputThreshold
 }
 
+// Ensures that the level provided is within the bounds of available levels
 func levelCheck(level Level) Level {
     switch {
-    case level <= LevelDebug:
-        return LevelDebug
-    case level >= LevelCritical:
-        return LevelCritical
+    case level <= LevelTrace:
+        return LevelTrace
+    case level >= LevelFatal:
+        return LevelFatal
     default:
         return level
     }
 }
 
-// SetLevel switches to a new log level.
-func SetLogLevel(level Level) {
-    logLevel = levelCheck(level)
+// Establishes a threshold where anything matching or above will be logged
+func SetLogThreshold(level Level) {
+    logThreshold = levelCheck(level)
     Initialize()
 }
 
+// Establishes a threshold where anything matching or above will be output
+func SetOutputThreshold(level Level) {
+    outputThreshold = levelCheck(level)
+    Initialize()
+}
+
+// Conveniently Sets the Log Handle to a io.writer created for the file behind the given filepath
+// Will only append to this file
 func SetLogFile(path string) {
     file, err := os.OpenFile(path, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666)
     fmt.Println("Logging to", file.Name())
@@ -132,6 +147,7 @@
     Initialize()
 }
 
+// Conveniently Creates a temporary file and sets the Log Handle to a io.writer created for it
 func UseTempLogFile(prefix string) {
     file, err := ioutil.TempFile(os.TempDir(), prefix)
     if err != nil {
@@ -144,80 +160,23 @@
     Initialize()
 }
 
+// Disables logging for the entire JWW system
 func DiscardLogging() {
     LogHandle = ioutil.Discard
     Initialize()
 }
 
-func SetOutLevel(level Level) {
-    outLevel = levelCheck(level) // 1
-    Initialize()
-}
-
-// Don't use if you have manually set the Handles of the different levels as it will overwrite them.
-func initWriters() {
-    BothHandle = io.MultiWriter(LogHandle, OutHandle)
-    //DEBUG
-    if LevelDebug < outLevel && LevelDebug < logLevel {
-        DebugHandle = ioutil.Discard
-    } else if LevelDebug >= outLevel && LevelDebug >= logLevel {
-        DebugHandle = BothHandle
-    } else if LevelDebug >= outLevel && LevelDebug < logLevel {
-        DebugHandle = OutHandle
-    } else {
-        DebugHandle = LogHandle
-    }
-
-    //WARN
-    if LevelWarn < outLevel && LevelWarn < logLevel {
-        WarnHandle = ioutil.Discard
-    } else if LevelWarn >= outLevel && LevelWarn >= logLevel {
-        WarnHandle = BothHandle
-    } else if LevelWarn >= outLevel && LevelWarn < logLevel {
-        WarnHandle = OutHandle
-    } else {
-        WarnHandle = LogHandle
-    }
-
-    //INFO
-    if LevelInfo < outLevel && LevelInfo < logLevel {
-        InfoHandle = ioutil.Discard
-    } else if LevelInfo >= outLevel && LevelInfo >= logLevel {
-        InfoHandle = BothHandle
-    } else if LevelInfo >= outLevel && LevelInfo < logLevel {
-        InfoHandle = OutHandle
-    } else {
-        InfoHandle = LogHandle
-    }
-
-    //ERROR
-    if LevelError < outLevel && LevelError < logLevel {
-        ErrorHandle = ioutil.Discard
-    } else if LevelError >= outLevel && LevelError >= logLevel {
-        ErrorHandle = BothHandle
-    } else if LevelError >= outLevel && LevelError < logLevel {
-        ErrorHandle = OutHandle
-    } else {
-        ErrorHandle = LogHandle
-    }
-
-    //CRITICAL
-    if LevelCritical < outLevel && LevelCritical < logLevel {
-        CriticalHandle = ioutil.Discard
-    } else if LevelCritical >= outLevel && LevelCritical >= logLevel {
-        CriticalHandle = BothHandle
-    } else if LevelCritical >= outLevel && LevelCritical < logLevel {
-        CriticalHandle = OutHandle
-    } else {
-        CriticalHandle = LogHandle
-    }
-}
-
+// Feedback is special. It writes plainly to the output while
+// logging with the standard extra information (date, file, etc)
+// Only Println and Printf are currently provided for this
 func (fb *Feedback) Println(v ...interface{}) {
     fmt.Println(v...)
     LOG.Println(v...)
 }
 
+// Feedback is special. It writes plainly to the output while
+// logging with the standard extra information (date, file, etc)
+// Only Println and Printf are currently provided for this
 func (fb *Feedback) Printf(format string, v ...interface{}) {
     fmt.Printf(format, v...)
     LOG.Printf(format, v...)