diff --git a/cmd/torusblk/flex.go b/cmd/torusblk/flex.go
index 7f45627..a59e606 100644
--- a/cmd/torusblk/flex.go
+++ b/cmd/torusblk/flex.go
@@ -196,7 +196,7 @@ func attachAction(cmd *cobra.Command, args []string) {
 	<-ch
 	status := sysd.wait(svc)
 	if status == "failed" {
-		onErr(errors.New("Couldn't attach"))
+		onErr(errors.New("couldn't attach"))
 	} else if status == "active" {
 		writeResponse(Response{
 			Status: "Success",
@@ -278,7 +278,7 @@ func mountAction(cmd *cobra.Command, args []string) {
 	// }
 	// status := sysd.wait(mountsvc)
 	// if status == "failed" {
-	// 	onErr(errors.New("Couldn't attach"))
+	// 	onErr(errors.New("couldn't attach"))
 	// } else if status == "active" {
 	// 	writeResponse(Response{
 	// 		Status: "Success",
diff --git a/cmd/torusblk/main.go b/cmd/torusblk/main.go
index 9029e9c..f6c1109 100644
--- a/cmd/torusblk/main.go
+++ b/cmd/torusblk/main.go
@@ -88,12 +88,12 @@ func configureServer(cmd *cobra.Command, args []string) {
 func createServer() *torus.Server {
 	srv, err := torus.NewServer(cfg, "etcd", "temp")
 	if err != nil {
-		fmt.Printf("Couldn't start: %s\n", err)
+		fmt.Printf("couldn't start: %s\n", err)
 		os.Exit(1)
 	}
 	err = distributor.OpenReplication(srv)
 	if err != nil {
-		fmt.Printf("Couldn't start: %s", err)
+		fmt.Printf("couldn't start: %s", err)
 		os.Exit(1)
 	}
 	if httpAddr != "" {
diff --git a/cmd/torusctl/common.go b/cmd/torusctl/common.go
index 84e5f11..904823a 100644
--- a/cmd/torusctl/common.go
+++ b/cmd/torusctl/common.go
@@ -33,11 +33,11 @@ func createServer() *torus.Server {
 	cfg := flagconfig.BuildConfigFromFlags()
 	srv, err := torus.NewServer(cfg, "etcd", "temp")
 	if err != nil {
-		die("Couldn't start: %s\n", err)
+		die("couldn't start: %s", err)
 	}
 	err = distributor.OpenReplication(srv)
 	if err != nil {
-		die("Couldn't start: %s", err)
+		die("couldn't start: %s", err)
 	}
 	return srv
 }
diff --git a/cmd/torusctl/volume.go b/cmd/torusctl/volume.go
index 4b3e874..c1d112f 100644
--- a/cmd/torusctl/volume.go
+++ b/cmd/torusctl/volume.go
@@ -54,7 +54,7 @@ func volumeListAction(cmd *cobra.Command, args []string) {
 	mds := mustConnectToMDS()
 	vols, _, err := mds.GetVolumes()
 	if err != nil {
-		die("error listing volumes: %v\n", err)
+		die("error listing volumes: %v", err)
 	}
 	table := NewTableWriter(os.Stdout)
 	table.SetHeader([]string{"Volume Name", "Size", "Type", "Status"})
diff --git a/cmd/torusd/main.go b/cmd/torusd/main.go
index 75b2681..b872c7e 100644
--- a/cmd/torusd/main.go
+++ b/cmd/torusd/main.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"net/url"
 	"os"
@@ -52,7 +51,12 @@ var rootCommand = &cobra.Command{
 	Short:  "Torus distributed storage",
 	Long:   `The torus distributed storage server.`,
 	PreRun: configureServer,
-	Run:    runServer,
+	Run: func(cmd *cobra.Command, args []string) {
+		err := runServer(cmd, args)
+		if err != nil {
+			die("%v", err)
+		}
+	},
 }
 
 func init() {
@@ -93,8 +97,7 @@ func configureServer(cmd *cobra.Command, args []string) {
 		rl := capnslog.MustRepoLogger("github.com/coreos/torus")
 		llc, err := rl.ParseLogLevelConfig(logpkg)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "error parsing logpkg: %s\n", err)
-			os.Exit(1)
+			die("error parsing logpkg: %s", err)
 		}
 		rl.SetLogLevel(llc)
 	}
@@ -110,16 +113,14 @@ func configureServer(cmd *cobra.Command, args []string) {
 	if strings.Contains(sizeStr, "%") {
 		percent, err := parsePercentage(sizeStr)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "error parsing size %s: %s\n", sizeStr, err)
-			os.Exit(1)
+			die("error parsing size %s: %s", sizeStr, err)
 		}
 		directory, _ := filepath.Abs(dataDir)
 		size = du.NewDiskUsage(directory).Size() * percent / 100
 	} else {
 		size, err = humanize.ParseBytes(sizeStr)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "error parsing size %s: %s\n", sizeStr, err)
-			os.Exit(1)
+			die("error parsing size %s: %s", sizeStr, err)
 		}
 	}
 
@@ -135,12 +136,12 @@ func parsePercentage(percentString string) (uint64, error) {
 		return 0, err
 	}
 	if sizeNumber < 1 || sizeNumber > 100 {
-		return 0, errors.New(fmt.Sprintf("invalid size %d; must be between 1%% and 100%%", sizeNumber))
+		return 0, fmt.Errorf("invalid size %d; must be between 1%% and 100%%", sizeNumber)
 	}
 	return uint64(sizeNumber), nil
 }
 
-func runServer(cmd *cobra.Command, args []string) {
+func runServer(cmd *cobra.Command, args []string) error {
 	if completion {
 		cmd.Root().GenBashCompletion(os.Stdout)
 		os.Exit(0)
@@ -162,8 +163,7 @@ func runServer(cmd *cobra.Command, args []string) {
 			if err == torus.ErrExists {
 				fmt.Println("debug-init: Already exists")
 			} else {
-				fmt.Printf("Couldn't debug-init: %s\n", err)
-				os.Exit(1)
+				return fmt.Errorf("couldn't debug-init: %s", err)
 			}
 		}
 		fallthrough
@@ -171,15 +171,13 @@ func runServer(cmd *cobra.Command, args []string) {
 		srv, err = torus.NewServer(cfg, "etcd", "mfile")
 	}
 	if err != nil {
-		fmt.Printf("Couldn't start: %s\n", err)
-		os.Exit(1)
+		return fmt.Errorf("couldn't start: %s", err)
 	}
 
 	if autojoin {
 		err = doAutojoin(srv)
 		if err != nil {
-			fmt.Printf("Couldn't auto-join: %s\n", err)
-			os.Exit(1)
+			return fmt.Errorf("couldn't auto-join: %s", err)
 		}
 	}
 
@@ -192,13 +190,11 @@ func runServer(cmd *cobra.Command, args []string) {
 
 		u, err = url.Parse(peerAddress)
 		if err != nil {
-			fmt.Printf("Couldn't parse peer address %s: %s\n", peerAddress, err)
-			os.Exit(1)
+			return fmt.Errorf("couldn't parse peer address %s: %s", peerAddress, err)
 		}
 
 		if u.Scheme == "" {
-			fmt.Printf("Peer address %s does not have URL scheme (http:// or tdp://)\n", peerAddress)
-			os.Exit(1)
+			return fmt.Errorf("Peer address %s does not have URL scheme (http:// or tdp://)", peerAddress)
 		}
 
 		err = distributor.ListenReplication(srv, u)
@@ -216,22 +212,21 @@ func runServer(cmd *cobra.Command, args []string) {
 	}()
 
 	if err != nil {
-		fmt.Println("couldn't use server:", err)
-		os.Exit(1)
+		return fmt.Errorf("couldn't use server: %s", err)
 	}
 	if httpAddress != "" {
 		http.ServeHTTP(httpAddress, srv)
 	}
 	// Wait
 	<-mainClose
+	return nil
 }
 
 func doAutojoin(s *torus.Server) error {
 	for {
 		ring, err := s.MDS.GetRing()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "couldn't get ring: %v\n", err)
-			return err
+			return fmt.Errorf("couldn't get ring: %v", err)
 		}
 		var newRing torus.Ring
 		if r, ok := ring.(torus.RingAdder); ok {
@@ -242,16 +237,14 @@ func doAutojoin(s *torus.Server) error {
 				},
 			})
 		} else {
-			fmt.Fprintf(os.Stderr, "current ring type cannot support auto-adding\n")
-			return err
+			return fmt.Errorf("current ring type cannot support auto-adding")
 		}
 		if err == torus.ErrExists {
 			// We're already a member; we're coming back up.
 			return nil
 		}
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "couldn't add peer to ring: %v", err)
-			return err
+			return fmt.Errorf("couldn't add peer to ring: %v", err)
 		}
 		err = s.MDS.SetRing(newRing)
 		if err == torus.ErrNonSequentialRing || err == torus.ErrAgain {
@@ -261,3 +254,8 @@ func doAutojoin(s *torus.Server) error {
 		return err
 	}
 }
+
+func die(why string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, why+"\n", args...)
+	os.Exit(1)
+}
diff --git a/distributor/storage.go b/distributor/storage.go
index 5a60e90..d4366ca 100644
--- a/distributor/storage.go
+++ b/distributor/storage.go
@@ -188,7 +188,7 @@ func (d *Distributor) WriteBlock(ctx context.Context, i torus.BlockRef, data []b
 		if err == nil {
 			return nil
 		}
-		clog.Debugf("Couldn't write locally; writing to cluster: %s", err)
+		clog.Debugf("couldn't write locally; writing to cluster: %s", err)
 		fallthrough
 	case torus.WriteOne:
 		for _, p := range peers.Peers[:peers.Replication] {
diff --git a/file.go b/file.go
index a5b688c..aae3bdd 100644
--- a/file.go
+++ b/file.go
@@ -183,7 +183,7 @@ func (f *File) WriteAt(b []byte, off int64) (n int, err error) {
 			return n, err
 		} else if wrote != frontlen {
 			promFileWrittenBytes.WithLabelValues(f.volume.Name).Add(float64(n))
-			return n, errors.New("Couldn't write all of the first block at the offset")
+			return n, errors.New("couldn't write all of the first block at the offset")
 		}
 		b = b[frontlen:]
 		n += wrote
@@ -241,7 +241,7 @@ func (f *File) WriteAt(b []byte, off int64) (n int, err error) {
 		return n, err
 	} else if wrote != toWrite {
 		promFileWrittenBytes.WithLabelValues(f.volume.Name).Add(float64(n))
-		return n, errors.New("Couldn't write all of the last block")
+		return n, errors.New("couldn't write all of the last block")
 	}
 	n += wrote
 	off += int64(wrote)
diff --git a/internal/nbd/nbd.go b/internal/nbd/nbd.go
index 5efe342..dfbe6df 100644
--- a/internal/nbd/nbd.go
+++ b/internal/nbd/nbd.go
@@ -232,7 +232,7 @@ func (nbd *NBD) Serve() error {
 			time.Sleep(time.Microsecond * 500)
 			err := nbd.SetBlockSize(nbd.blocksize)
 			if err != nil {
-				clog.Printf("Couldn't upgrade blocksize: %s", err)
+				clog.Printf("couldn't upgrade blocksize: %s", err)
 			}
 		}(nbd)
 	}