diff --git a/metropolis/node/build/mkimage/main.go b/metropolis/node/build/mkimage/main.go
index e5c25df..b885618 100644
--- a/metropolis/node/build/mkimage/main.go
+++ b/metropolis/node/build/mkimage/main.go
@@ -57,7 +57,7 @@
 	// Start with the EFI Payload the OS will boot from.
 	p, err := os.Open(efiPayload)
 	if err != nil {
-		log.Fatalf("while opening the EFI payload at %q: %s", efiPayload, err.Error())
+		log.Fatalf("while opening the EFI payload at %q: %v", efiPayload, err)
 	}
 	defer p.Close()
 	cfg.EFIPayload = p
@@ -68,7 +68,7 @@
 	if systemImage != "" {
 		img, err := os.Open(systemImage)
 		if err != nil {
-			log.Fatalf("while opening the system image at %q: %s", systemImage, err.Error())
+			log.Fatalf("while opening the system image at %q: %v", systemImage, err)
 		}
 		defer img.Close()
 		cfg.SystemImage = img
@@ -78,7 +78,7 @@
 	if nodeParams != "" {
 		np, err := os.Open(nodeParams)
 		if err != nil {
-			log.Fatalf("while opening node parameters at %q: %s", nodeParams, err.Error())
+			log.Fatalf("while opening node parameters at %q: %v", nodeParams, err)
 		}
 		defer np.Close()
 		cfg.NodeParameters = np
@@ -86,6 +86,6 @@
 
 	// Write the parametrized OS image.
 	if _, err := osimage.Create(&cfg); err != nil {
-		log.Fatalf("while creating a Metropolis OS image: %s", err.Error())
+		log.Fatalf("while creating a Metropolis OS image: %v", err)
 	}
 }
diff --git a/metropolis/node/installer/main.go b/metropolis/node/installer/main.go
index 6eb6706..dc72e07 100644
--- a/metropolis/node/installer/main.go
+++ b/metropolis/node/installer/main.go
@@ -179,22 +179,22 @@
 func main() {
 	// Mount sysfs, devtmpfs and efivarfs.
 	if err := mountPseudoFS(); err != nil {
-		log.Fatalf("while mounting pseudo-filesystems: %s", err.Error())
+		log.Fatalf("while mounting pseudo-filesystems: %v", err)
 	}
 	// Read the installer ESP UUID from efivarfs.
 	espUuid, err := efivarfs.ReadLoaderDevicePartUUID()
 	if err != nil {
-		log.Fatalf("while reading the installer ESP UUID: %s", err.Error())
+		log.Fatalf("while reading the installer ESP UUID: %v", err)
 	}
 	// Look up the installer partition based on espUuid.
 	espDev, err := sysfs.DeviceByPartUUID(espUuid)
 	espPath := filepath.Join("/dev", espDev)
 	if err != nil {
-		log.Fatalf("while resolving the installer device handle: %s", err.Error())
+		log.Fatalf("while resolving the installer device handle: %v", err)
 	}
 	// Mount the installer partition. The installer bundle will be read from it.
 	if err := mountInstallerESP(espPath); err != nil {
-		log.Fatalf("while mounting the installer ESP: %s", err.Error())
+		log.Fatalf("while mounting the installer ESP: %v", err)
 	}
 
 	nodeParameters, err := os.Open("/installer/EFI/metropolis-installer/nodeparams.pb")
@@ -250,7 +250,7 @@
 	// Look for suitable block devices, given the minimum size.
 	blkDevs, err := findInstallableBlockDevices(espDev, minSize)
 	if err != nil {
-		log.Fatal(err.Error())
+		log.Fatal(err)
 	}
 	if len(blkDevs) == 0 {
 		log.Fatal("couldn't find a suitable block device.")
@@ -266,34 +266,34 @@
 	log.Printf("Installing to %s\n", tgtBlkdevPath)
 	be, err := osimage.Create(&installParams)
 	if err != nil {
-		log.Fatalf("while installing: %s", err.Error())
+		log.Fatalf("while installing: %v", err)
 	}
 	// The target device's partition table has just been updated. Re-read it to
 	// make the node system partition reachable through /dev.
 	if err := rereadPartitionTable(tgtBlkdevPath); err != nil {
-		log.Fatalf("while re-reading the partition table of %q: %s", tgtBlkdevPath, err.Error())
+		log.Fatalf("while re-reading the partition table of %q: %v", tgtBlkdevPath, err)
 	}
 	// Look up the node's system partition path to be later used in the
 	// initialization step. It's always the second partition, right after
 	// the ESP.
 	sysBlkdevName, err := sysfs.PartitionBlockDevice(tgtBlkdevName, 2)
 	if err != nil {
-		log.Fatalf("while looking up the system partition: %s", err.Error())
+		log.Fatalf("while looking up the system partition: %v", err)
 	}
 	sysBlkdevPath := filepath.Join("/dev", sysBlkdevName)
 	// Copy the system partition contents.
 	if err := initializeSystemPartition(systemImage, sysBlkdevPath); err != nil {
-		log.Fatalf("while initializing the system partition at %q: %s", sysBlkdevPath, err.Error())
+		log.Fatalf("while initializing the system partition at %q: %v", sysBlkdevPath, err)
 	}
 
 	// Create an EFI boot entry for Metropolis.
 	en, err := efivarfs.CreateBootEntry(be)
 	if err != nil {
-		log.Fatalf("while creating a boot entry: %s", err.Error())
+		log.Fatalf("while creating a boot entry: %v", err)
 	}
 	// Erase the preexisting boot order, leaving Metropolis as the only option.
 	if err := efivarfs.SetBootOrder(&efivarfs.BootOrder{uint16(en)}); err != nil {
-		log.Fatalf("while adjusting the boot order: %s", err.Error())
+		log.Fatalf("while adjusting the boot order: %v", err)
 	}
 
 	// Reboot.
diff --git a/metropolis/test/installer/main.go b/metropolis/test/installer/main.go
index 0f2f40e..a5bac64 100644
--- a/metropolis/test/installer/main.go
+++ b/metropolis/test/installer/main.go
@@ -180,19 +180,19 @@
 	// generated by Metropolis buildsystem.
 	installer, err := os.Open(installerEFIPayload)
 	if err != nil {
-		log.Fatalf("Couldn't open the installer EFI executable at %q: %s", installerEFIPayload, err.Error())
+		log.Fatalf("Couldn't open the installer EFI executable at %q: %v", installerEFIPayload, err)
 	}
 	info, err := installer.Stat()
 	if err != nil {
-		log.Fatalf("Couldn't stat the installer EFI executable: %s", err.Error())
+		log.Fatalf("Couldn't stat the installer EFI executable: %v", err)
 	}
 	bundle, err := os.Open(testOSBundle)
 	if err != nil {
-		log.Fatalf("failed to open TestOS bundle: %v", err)
+		log.Fatalf("Failed to open TestOS bundle: %v", err)
 	}
 	bundleStat, err := bundle.Stat()
 	if err != nil {
-		log.Fatalf("failed to stat() TestOS bundle: %v", err)
+		log.Fatalf("Failed to stat() TestOS bundle: %v", err)
 	}
 	iargs := mctl.MakeInstallerImageArgs{
 		Installer:     installer,
@@ -203,7 +203,7 @@
 		BundleSize:    uint64(bundleStat.Size()),
 	}
 	if err := mctl.MakeInstallerImage(iargs); err != nil {
-		log.Fatalf("Couldn't create the installer image at %q: %s", installerImage, err.Error())
+		log.Fatalf("Couldn't create the installer image at %q: %v", installerImage, err)
 	}
 	// With common dependencies set up, run the tests.
 	code := m.Run()