diff --git a/cmd/ghcs/code.go b/cmd/ghcs/code.go
index 0ec363a6d..d905c75ac 100644
--- a/cmd/ghcs/code.go
+++ b/cmd/ghcs/code.go
@@ -42,7 +42,7 @@ func code(codespaceName string, useInsiders bool) error {
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	if codespaceName == "" {
@@ -51,7 +51,7 @@ func code(codespaceName string, useInsiders bool) error {
 			if err == errNoCodespaces {
 				return err
 			}
-			return fmt.Errorf("error choosing codespace: %v", err)
+			return fmt.Errorf("error choosing codespace: %w", err)
 		}
 		codespaceName = codespace.Name
 	}
diff --git a/cmd/ghcs/common.go b/cmd/ghcs/common.go
index 133e6d1de..2f4862e13 100644
--- a/cmd/ghcs/common.go
+++ b/cmd/ghcs/common.go
@@ -20,7 +20,7 @@ var errNoCodespaces = errors.New("You have no codespaces.")
 func chooseCodespace(ctx context.Context, apiClient *api.API, user *api.User) (*api.Codespace, error) {
 	codespaces, err := apiClient.ListCodespaces(ctx, user)
 	if err != nil {
-		return nil, fmt.Errorf("error getting codespaces: %v", err)
+		return nil, fmt.Errorf("error getting codespaces: %w", err)
 	}
 
 	if len(codespaces) == 0 {
@@ -54,7 +54,7 @@ func chooseCodespace(ctx context.Context, apiClient *api.API, user *api.User) (*
 		Codespace string
 	}
 	if err := ask(sshSurvey, &answers); err != nil {
-		return nil, fmt.Errorf("error getting answers: %v", err)
+		return nil, fmt.Errorf("error getting answers: %w", err)
 	}
 
 	codespace := codespacesByName[answers.Codespace]
@@ -70,23 +70,23 @@ func getOrChooseCodespace(ctx context.Context, apiClient *api.API, user *api.Use
 			if err == errNoCodespaces {
 				return nil, "", err
 			}
-			return nil, "", fmt.Errorf("choosing codespace: %v", err)
+			return nil, "", fmt.Errorf("choosing codespace: %w", err)
 		}
 		codespaceName = codespace.Name
 
 		token, err = apiClient.GetCodespaceToken(ctx, user.Login, codespaceName)
 		if err != nil {
-			return nil, "", fmt.Errorf("getting codespace token: %v", err)
+			return nil, "", fmt.Errorf("getting codespace token: %w", err)
 		}
 	} else {
 		token, err = apiClient.GetCodespaceToken(ctx, user.Login, codespaceName)
 		if err != nil {
-			return nil, "", fmt.Errorf("getting codespace token for given codespace: %v", err)
+			return nil, "", fmt.Errorf("getting codespace token for given codespace: %w", err)
 		}
 
 		codespace, err = apiClient.GetCodespace(ctx, token, user.Login, codespaceName)
 		if err != nil {
-			return nil, "", fmt.Errorf("getting full codespace details: %v", err)
+			return nil, "", fmt.Errorf("getting full codespace details: %w", err)
 		}
 	}
 
diff --git a/cmd/ghcs/create.go b/cmd/ghcs/create.go
index b5238a6f7..8b7a2e7d9 100644
--- a/cmd/ghcs/create.go
+++ b/cmd/ghcs/create.go
@@ -55,31 +55,31 @@ func create(opts *createOptions) error {
 
 	repo, err := getRepoName(opts.repo)
 	if err != nil {
-		return fmt.Errorf("error getting repository name: %v", err)
+		return fmt.Errorf("error getting repository name: %w", err)
 	}
 	branch, err := getBranchName(opts.branch)
 	if err != nil {
-		return fmt.Errorf("error getting branch name: %v", err)
+		return fmt.Errorf("error getting branch name: %w", err)
 	}
 
 	repository, err := apiClient.GetRepository(ctx, repo)
 	if err != nil {
-		return fmt.Errorf("error getting repository: %v", err)
+		return fmt.Errorf("error getting repository: %w", err)
 	}
 
 	locationResult := <-locationCh
 	if locationResult.Err != nil {
-		return fmt.Errorf("error getting codespace region location: %v", locationResult.Err)
+		return fmt.Errorf("error getting codespace region location: %w", locationResult.Err)
 	}
 
 	userResult := <-userCh
 	if userResult.Err != nil {
-		return fmt.Errorf("error getting codespace user: %v", userResult.Err)
+		return fmt.Errorf("error getting codespace user: %w", userResult.Err)
 	}
 
 	machine, err := getMachineName(ctx, opts.machine, userResult.User, repository, branch, locationResult.Location, apiClient)
 	if err != nil {
-		return fmt.Errorf("error getting machine type: %v", err)
+		return fmt.Errorf("error getting machine type: %w", err)
 	}
 	if machine == "" {
 		return errors.New("There are no available machine types for this repository")
@@ -89,7 +89,7 @@ func create(opts *createOptions) error {
 
 	codespace, err := apiClient.CreateCodespace(ctx, userResult.User, repository, machine, branch, locationResult.Location)
 	if err != nil {
-		return fmt.Errorf("error creating codespace: %v", err)
+		return fmt.Errorf("error creating codespace: %w", err)
 	}
 
 	if opts.showStatus {
@@ -163,7 +163,7 @@ func showStatus(ctx context.Context, log *output.Logger, apiClient *api.API, use
 			return nil // we cancelled the context to stop polling, we can ignore the error
 		}
 
-		return fmt.Errorf("failed to poll state changes from codespace: %v", err)
+		return fmt.Errorf("failed to poll state changes from codespace: %w", err)
 	}
 
 	return nil
@@ -237,7 +237,7 @@ func getBranchName(branch string) (string, error) {
 func getMachineName(ctx context.Context, machine string, user *api.User, repo *api.Repository, branch, location string, apiClient *api.API) (string, error) {
 	skus, err := apiClient.GetCodespacesSKUs(ctx, user, repo, branch, location)
 	if err != nil {
-		return "", fmt.Errorf("error requesting machine instance types: %v", err)
+		return "", fmt.Errorf("error requesting machine instance types: %w", err)
 	}
 
 	// if user supplied a machine type, it must be valid
@@ -287,7 +287,7 @@ func getMachineName(ctx context.Context, machine string, user *api.User, repo *a
 
 	var skuAnswers struct{ SKU string }
 	if err := ask(skuSurvey, &skuAnswers); err != nil {
-		return "", fmt.Errorf("error getting SKU: %v", err)
+		return "", fmt.Errorf("error getting SKU: %w", err)
 	}
 
 	sku := skuByName[skuAnswers.SKU]
diff --git a/cmd/ghcs/delete.go b/cmd/ghcs/delete.go
index 3f5d68684..b2547e350 100644
--- a/cmd/ghcs/delete.go
+++ b/cmd/ghcs/delete.go
@@ -55,16 +55,16 @@ func delete_(log *output.Logger, codespaceName string) error {
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespace, token, err := getOrChooseCodespace(ctx, apiClient, user, codespaceName)
 	if err != nil {
-		return fmt.Errorf("get or choose codespace: %v", err)
+		return fmt.Errorf("get or choose codespace: %w", err)
 	}
 
 	if err := apiClient.DeleteCodespace(ctx, user, token, codespace.Name); err != nil {
-		return fmt.Errorf("error deleting codespace: %v", err)
+		return fmt.Errorf("error deleting codespace: %w", err)
 	}
 
 	log.Println("Codespace deleted.")
@@ -78,22 +78,22 @@ func deleteAll(log *output.Logger) error {
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespaces, err := apiClient.ListCodespaces(ctx, user)
 	if err != nil {
-		return fmt.Errorf("error getting codespaces: %v", err)
+		return fmt.Errorf("error getting codespaces: %w", err)
 	}
 
 	for _, c := range codespaces {
 		token, err := apiClient.GetCodespaceToken(ctx, user.Login, c.Name)
 		if err != nil {
-			return fmt.Errorf("error getting codespace token: %v", err)
+			return fmt.Errorf("error getting codespace token: %w", err)
 		}
 
 		if err := apiClient.DeleteCodespace(ctx, user, token, c.Name); err != nil {
-			return fmt.Errorf("error deleting codespace: %v", err)
+			return fmt.Errorf("error deleting codespace: %w", err)
 		}
 
 		log.Printf("Codespace deleted: %s\n", c.Name)
@@ -108,12 +108,12 @@ func deleteByRepo(log *output.Logger, repo string) error {
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespaces, err := apiClient.ListCodespaces(ctx, user)
 	if err != nil {
-		return fmt.Errorf("error getting codespaces: %v", err)
+		return fmt.Errorf("error getting codespaces: %w", err)
 	}
 
 	var deleted bool
@@ -125,11 +125,11 @@ func deleteByRepo(log *output.Logger, repo string) error {
 
 		token, err := apiClient.GetCodespaceToken(ctx, user.Login, c.Name)
 		if err != nil {
-			return fmt.Errorf("error getting codespace token: %v", err)
+			return fmt.Errorf("error getting codespace token: %w", err)
 		}
 
 		if err := apiClient.DeleteCodespace(ctx, user, token, c.Name); err != nil {
-			return fmt.Errorf("error deleting codespace: %v", err)
+			return fmt.Errorf("error deleting codespace: %w", err)
 		}
 
 		log.Printf("Codespace deleted: %s\n", c.Name)
diff --git a/cmd/ghcs/list.go b/cmd/ghcs/list.go
index dee1b0875..2db609d50 100644
--- a/cmd/ghcs/list.go
+++ b/cmd/ghcs/list.go
@@ -41,12 +41,12 @@ func list(opts *listOptions) error {
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespaces, err := apiClient.ListCodespaces(ctx, user)
 	if err != nil {
-		return fmt.Errorf("error getting codespaces: %v", err)
+		return fmt.Errorf("error getting codespaces: %w", err)
 	}
 
 	table := output.NewTable(os.Stdout, opts.asJSON)
diff --git a/cmd/ghcs/logs.go b/cmd/ghcs/logs.go
index ccfb46236..f65fa1109 100644
--- a/cmd/ghcs/logs.go
+++ b/cmd/ghcs/logs.go
@@ -49,17 +49,17 @@ func logs(ctx context.Context, log *output.Logger, codespaceName string, follow
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("getting user: %v", err)
+		return fmt.Errorf("getting user: %w", err)
 	}
 
 	codespace, token, err := getOrChooseCodespace(ctx, apiClient, user, codespaceName)
 	if err != nil {
-		return fmt.Errorf("get or choose codespace: %v", err)
+		return fmt.Errorf("get or choose codespace: %w", err)
 	}
 
 	session, err := codespaces.ConnectToLiveshare(ctx, log, apiClient, user.Login, token, codespace)
 	if err != nil {
-		return fmt.Errorf("connecting to Live Share: %v", err)
+		return fmt.Errorf("connecting to Live Share: %w", err)
 	}
 
 	// Ensure local port is listening before client (getPostCreateOutput) connects.
@@ -73,7 +73,7 @@ func logs(ctx context.Context, log *output.Logger, codespaceName string, follow
 	log.Println("Fetching SSH Details...")
 	remoteSSHServerPort, sshUser, err := session.StartSSHServer(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting ssh server details: %v", err)
+		return fmt.Errorf("error getting ssh server details: %w", err)
 	}
 
 	cmdType := "cat"
@@ -99,10 +99,10 @@ func logs(ctx context.Context, log *output.Logger, codespaceName string, follow
 
 	select {
 	case err := <-tunnelClosed:
-		return fmt.Errorf("connection closed: %v", err)
+		return fmt.Errorf("connection closed: %w", err)
 	case err := <-cmdDone:
 		if err != nil {
-			return fmt.Errorf("error retrieving logs: %v", err)
+			return fmt.Errorf("error retrieving logs: %w", err)
 		}
 
 		return nil // success
diff --git a/cmd/ghcs/ports.go b/cmd/ghcs/ports.go
index 8256c13e2..7bc53c441 100644
--- a/cmd/ghcs/ports.go
+++ b/cmd/ghcs/ports.go
@@ -58,7 +58,7 @@ func ports(codespaceName string, asJSON bool) error {
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespace, token, err := getOrChooseCodespace(ctx, apiClient, user, codespaceName)
@@ -67,20 +67,20 @@ func ports(codespaceName string, asJSON bool) error {
 		if err == errNoCodespaces {
 			return err
 		}
-		return fmt.Errorf("error choosing codespace: %v", err)
+		return fmt.Errorf("error choosing codespace: %w", err)
 	}
 
 	devContainerCh := getDevContainer(ctx, apiClient, codespace)
 
 	session, err := codespaces.ConnectToLiveshare(ctx, log, apiClient, user.Login, token, codespace)
 	if err != nil {
-		return fmt.Errorf("error connecting to Live Share: %v", err)
+		return fmt.Errorf("error connecting to Live Share: %w", err)
 	}
 
 	log.Println("Loading ports...")
 	ports, err := session.GetSharedServers(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting ports of shared servers: %v", err)
+		return fmt.Errorf("error getting ports of shared servers: %w", err)
 	}
 
 	devContainerResult := <-devContainerCh
@@ -130,7 +130,7 @@ func getDevContainer(ctx context.Context, apiClient *api.API, codespace *api.Cod
 	go func() {
 		contents, err := apiClient.GetCodespaceRepositoryContents(ctx, codespace, ".devcontainer/devcontainer.json")
 		if err != nil {
-			ch <- devContainerResult{nil, fmt.Errorf("error getting content: %v", err)}
+			ch <- devContainerResult{nil, fmt.Errorf("error getting content: %w", err)}
 			return
 		}
 
@@ -147,7 +147,7 @@ func getDevContainer(ctx context.Context, apiClient *api.API, codespace *api.Cod
 
 		var container devContainer
 		if err := json.Unmarshal(convertedJSON, &container); err != nil {
-			ch <- devContainerResult{nil, fmt.Errorf("error unmarshaling: %v", err)}
+			ch <- devContainerResult{nil, fmt.Errorf("error unmarshaling: %w", err)}
 			return
 		}
 
@@ -168,7 +168,7 @@ func newPortsPublicCmd() *cobra.Command {
 				// should only happen if flag is not defined
 				// or if the flag is not of string type
 				// since it's a persistent flag that we control it should never happen
-				return fmt.Errorf("get codespace flag: %v", err)
+				return fmt.Errorf("get codespace flag: %w", err)
 			}
 
 			log := output.NewLogger(os.Stdout, os.Stderr, false)
@@ -189,7 +189,7 @@ func newPortsPrivateCmd() *cobra.Command {
 				// should only happen if flag is not defined
 				// or if the flag is not of string type
 				// since it's a persistent flag that we control it should never happen
-				return fmt.Errorf("get codespace flag: %v", err)
+				return fmt.Errorf("get codespace flag: %w", err)
 			}
 
 			log := output.NewLogger(os.Stdout, os.Stderr, false)
@@ -204,7 +204,7 @@ func updatePortVisibility(log *output.Logger, codespaceName, sourcePort string,
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespace, token, err := getOrChooseCodespace(ctx, apiClient, user, codespaceName)
@@ -212,21 +212,21 @@ func updatePortVisibility(log *output.Logger, codespaceName, sourcePort string,
 		if err == errNoCodespaces {
 			return err
 		}
-		return fmt.Errorf("error getting codespace: %v", err)
+		return fmt.Errorf("error getting codespace: %w", err)
 	}
 
 	session, err := codespaces.ConnectToLiveshare(ctx, log, apiClient, user.Login, token, codespace)
 	if err != nil {
-		return fmt.Errorf("error connecting to Live Share: %v", err)
+		return fmt.Errorf("error connecting to Live Share: %w", err)
 	}
 
 	port, err := strconv.Atoi(sourcePort)
 	if err != nil {
-		return fmt.Errorf("error reading port number: %v", err)
+		return fmt.Errorf("error reading port number: %w", err)
 	}
 
 	if err := session.UpdateSharedVisibility(ctx, port, public); err != nil {
-		return fmt.Errorf("error update port to public: %v", err)
+		return fmt.Errorf("error update port to public: %w", err)
 	}
 
 	state := "PUBLIC"
@@ -251,7 +251,7 @@ func newPortsForwardCmd() *cobra.Command {
 				// should only happen if flag is not defined
 				// or if the flag is not of string type
 				// since it's a persistent flag that we control it should never happen
-				return fmt.Errorf("get codespace flag: %v", err)
+				return fmt.Errorf("get codespace flag: %w", err)
 			}
 
 			log := output.NewLogger(os.Stdout, os.Stderr, false)
@@ -266,12 +266,12 @@ func forwardPorts(log *output.Logger, codespaceName string, ports []string) erro
 
 	portPairs, err := getPortPairs(ports)
 	if err != nil {
-		return fmt.Errorf("get port pairs: %v", err)
+		return fmt.Errorf("get port pairs: %w", err)
 	}
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespace, token, err := getOrChooseCodespace(ctx, apiClient, user, codespaceName)
@@ -279,12 +279,12 @@ func forwardPorts(log *output.Logger, codespaceName string, ports []string) erro
 		if err == errNoCodespaces {
 			return err
 		}
-		return fmt.Errorf("error getting codespace: %v", err)
+		return fmt.Errorf("error getting codespace: %w", err)
 	}
 
 	session, err := codespaces.ConnectToLiveshare(ctx, log, apiClient, user.Login, token, codespace)
 	if err != nil {
-		return fmt.Errorf("error connecting to Live Share: %v", err)
+		return fmt.Errorf("error connecting to Live Share: %w", err)
 	}
 
 	// Run forwarding of all ports concurrently, aborting all of
@@ -323,12 +323,12 @@ func getPortPairs(ports []string) ([]portPair, error) {
 
 		remote, err := strconv.Atoi(parts[0])
 		if err != nil {
-			return pp, fmt.Errorf("convert remote port to int: %v", err)
+			return pp, fmt.Errorf("convert remote port to int: %w", err)
 		}
 
 		local, err := strconv.Atoi(parts[1])
 		if err != nil {
-			return pp, fmt.Errorf("convert local port to int: %v", err)
+			return pp, fmt.Errorf("convert local port to int: %w", err)
 		}
 
 		pp = append(pp, portPair{remote, local})
diff --git a/cmd/ghcs/ssh.go b/cmd/ghcs/ssh.go
index fc1e6a73c..6d5f2376b 100644
--- a/cmd/ghcs/ssh.go
+++ b/cmd/ghcs/ssh.go
@@ -46,23 +46,23 @@ func ssh(ctx context.Context, sshProfile, codespaceName string, localSSHServerPo
 
 	user, err := apiClient.GetUser(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting user: %v", err)
+		return fmt.Errorf("error getting user: %w", err)
 	}
 
 	codespace, token, err := getOrChooseCodespace(ctx, apiClient, user, codespaceName)
 	if err != nil {
-		return fmt.Errorf("get or choose codespace: %v", err)
+		return fmt.Errorf("get or choose codespace: %w", err)
 	}
 
 	session, err := codespaces.ConnectToLiveshare(ctx, log, apiClient, user.Login, token, codespace)
 	if err != nil {
-		return fmt.Errorf("error connecting to Live Share: %v", err)
+		return fmt.Errorf("error connecting to Live Share: %w", err)
 	}
 
 	log.Println("Fetching SSH Details...")
 	remoteSSHServerPort, sshUser, err := session.StartSSHServer(ctx)
 	if err != nil {
-		return fmt.Errorf("error getting ssh server details: %v", err)
+		return fmt.Errorf("error getting ssh server details: %w", err)
 	}
 
 	usingCustomPort := localSSHServerPort != 0 // suppress log of command line in Shell
@@ -94,10 +94,10 @@ func ssh(ctx context.Context, sshProfile, codespaceName string, localSSHServerPo
 
 	select {
 	case err := <-tunnelClosed:
-		return fmt.Errorf("tunnel closed: %v", err)
+		return fmt.Errorf("tunnel closed: %w", err)
 	case err := <-shellClosed:
 		if err != nil {
-			return fmt.Errorf("shell closed: %v", err)
+			return fmt.Errorf("shell closed: %w", err)
 		}
 		return nil // success
 	}
diff --git a/internal/api/api.go b/internal/api/api.go
index 8277e903a..1246389e8 100644
--- a/internal/api/api.go
+++ b/internal/api/api.go
@@ -57,19 +57,19 @@ type User struct {
 func (a *API) GetUser(ctx context.Context) (*User, error) {
 	req, err := http.NewRequest(http.MethodGet, githubAPI+"/user", nil)
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/user")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -78,7 +78,7 @@ func (a *API) GetUser(ctx context.Context) (*User, error) {
 
 	var response User
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return &response, nil
@@ -89,7 +89,7 @@ func jsonErrorResponse(b []byte) error {
 		Message string `json:"message"`
 	}
 	if err := json.Unmarshal(b, &response); err != nil {
-		return fmt.Errorf("error unmarshaling error response: %v", err)
+		return fmt.Errorf("error unmarshaling error response: %w", err)
 	}
 
 	return errors.New(response.Message)
@@ -102,19 +102,19 @@ type Repository struct {
 func (a *API) GetRepository(ctx context.Context, nwo string) (*Repository, error) {
 	req, err := http.NewRequest(http.MethodGet, githubAPI+"/repos/"+strings.ToLower(nwo), nil)
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/repos/*")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -123,7 +123,7 @@ func (a *API) GetRepository(ctx context.Context, nwo string) (*Repository, error
 
 	var response Repository
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return &response, nil
@@ -171,19 +171,19 @@ func (a *API) ListCodespaces(ctx context.Context, user *User) ([]*Codespace, err
 		http.MethodGet, githubAPI+"/vscs_internal/user/"+user.Login+"/codespaces", nil,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/vscs_internal/user/*/codespaces")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -194,7 +194,7 @@ func (a *API) ListCodespaces(ctx context.Context, user *User) ([]*Codespace, err
 		Codespaces []*Codespace `json:"codespaces"`
 	}
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 	return response.Codespaces, nil
 }
@@ -210,7 +210,7 @@ type getCodespaceTokenResponse struct {
 func (a *API) GetCodespaceToken(ctx context.Context, ownerLogin, codespaceName string) (string, error) {
 	reqBody, err := json.Marshal(getCodespaceTokenRequest{true})
 	if err != nil {
-		return "", fmt.Errorf("error preparing request body: %v", err)
+		return "", fmt.Errorf("error preparing request body: %w", err)
 	}
 
 	req, err := http.NewRequest(
@@ -219,19 +219,19 @@ func (a *API) GetCodespaceToken(ctx context.Context, ownerLogin, codespaceName s
 		bytes.NewBuffer(reqBody),
 	)
 	if err != nil {
-		return "", fmt.Errorf("error creating request: %v", err)
+		return "", fmt.Errorf("error creating request: %w", err)
 	}
 
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/vscs_internal/user/*/codespaces/*/token")
 	if err != nil {
-		return "", fmt.Errorf("error making request: %v", err)
+		return "", fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return "", fmt.Errorf("error reading response body: %v", err)
+		return "", fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -240,7 +240,7 @@ func (a *API) GetCodespaceToken(ctx context.Context, ownerLogin, codespaceName s
 
 	var response getCodespaceTokenResponse
 	if err := json.Unmarshal(b, &response); err != nil {
-		return "", fmt.Errorf("error unmarshaling response: %v", err)
+		return "", fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return response.RepositoryToken, nil
@@ -253,19 +253,19 @@ func (a *API) GetCodespace(ctx context.Context, token, owner, codespace string)
 		nil,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	req.Header.Set("Authorization", "Bearer "+token)
 	resp, err := a.do(ctx, req, "/vscs_internal/user/*/codespaces/*")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -274,7 +274,7 @@ func (a *API) GetCodespace(ctx context.Context, token, owner, codespace string)
 
 	var response Codespace
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return &response, nil
@@ -287,19 +287,19 @@ func (a *API) StartCodespace(ctx context.Context, token string, codespace *Codes
 		nil,
 	)
 	if err != nil {
-		return fmt.Errorf("error creating request: %v", err)
+		return fmt.Errorf("error creating request: %w", err)
 	}
 
 	req.Header.Set("Authorization", "Bearer "+token)
 	resp, err := a.do(ctx, req, "/vscs_internal/proxy/environments/*/start")
 	if err != nil {
-		return fmt.Errorf("error making request: %v", err)
+		return fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return fmt.Errorf("error reading response body: %v", err)
+		return fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -325,18 +325,18 @@ type getCodespaceRegionLocationResponse struct {
 func (a *API) GetCodespaceRegionLocation(ctx context.Context) (string, error) {
 	req, err := http.NewRequest(http.MethodGet, "https://online.visualstudio.com/api/v1/locations", nil)
 	if err != nil {
-		return "", fmt.Errorf("error creating request: %v", err)
+		return "", fmt.Errorf("error creating request: %w", err)
 	}
 
 	resp, err := a.do(ctx, req, req.URL.String())
 	if err != nil {
-		return "", fmt.Errorf("error making request: %v", err)
+		return "", fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return "", fmt.Errorf("error reading response body: %v", err)
+		return "", fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -345,7 +345,7 @@ func (a *API) GetCodespaceRegionLocation(ctx context.Context) (string, error) {
 
 	var response getCodespaceRegionLocationResponse
 	if err := json.Unmarshal(b, &response); err != nil {
-		return "", fmt.Errorf("error unmarshaling response: %v", err)
+		return "", fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return response.Current, nil
@@ -359,7 +359,7 @@ type SKU struct {
 func (a *API) GetCodespacesSKUs(ctx context.Context, user *User, repository *Repository, branch, location string) ([]*SKU, error) {
 	req, err := http.NewRequest(http.MethodGet, githubAPI+"/vscs_internal/user/"+user.Login+"/skus", nil)
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	q := req.URL.Query()
@@ -371,13 +371,13 @@ func (a *API) GetCodespacesSKUs(ctx context.Context, user *User, repository *Rep
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/vscs_internal/user/*/skus")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -388,7 +388,7 @@ func (a *API) GetCodespacesSKUs(ctx context.Context, user *User, repository *Rep
 		SKUs []*SKU `json:"skus"`
 	}
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return response.SKUs, nil
@@ -404,24 +404,24 @@ type createCodespaceRequest struct {
 func (a *API) CreateCodespace(ctx context.Context, user *User, repository *Repository, sku, branch, location string) (*Codespace, error) {
 	requestBody, err := json.Marshal(createCodespaceRequest{repository.ID, branch, location, sku})
 	if err != nil {
-		return nil, fmt.Errorf("error marshaling request: %v", err)
+		return nil, fmt.Errorf("error marshaling request: %w", err)
 	}
 
 	req, err := http.NewRequest(http.MethodPost, githubAPI+"/vscs_internal/user/"+user.Login+"/codespaces", bytes.NewBuffer(requestBody))
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/vscs_internal/user/*/codespaces")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode > http.StatusAccepted {
@@ -430,7 +430,7 @@ func (a *API) CreateCodespace(ctx context.Context, user *User, repository *Repos
 
 	var response Codespace
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	return &response, nil
@@ -439,20 +439,20 @@ func (a *API) CreateCodespace(ctx context.Context, user *User, repository *Repos
 func (a *API) DeleteCodespace(ctx context.Context, user *User, token, codespaceName string) error {
 	req, err := http.NewRequest(http.MethodDelete, githubAPI+"/vscs_internal/user/"+user.Login+"/codespaces/"+codespaceName, nil)
 	if err != nil {
-		return fmt.Errorf("error creating request: %v", err)
+		return fmt.Errorf("error creating request: %w", err)
 	}
 
 	req.Header.Set("Authorization", "Bearer "+token)
 	resp, err := a.do(ctx, req, "/vscs_internal/user/*/codespaces/*")
 	if err != nil {
-		return fmt.Errorf("error making request: %v", err)
+		return fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode > http.StatusAccepted {
 		b, err := ioutil.ReadAll(resp.Body)
 		if err != nil {
-			return fmt.Errorf("error reading response body: %v", err)
+			return fmt.Errorf("error reading response body: %w", err)
 		}
 		return jsonErrorResponse(b)
 	}
@@ -467,7 +467,7 @@ type getCodespaceRepositoryContentsResponse struct {
 func (a *API) GetCodespaceRepositoryContents(ctx context.Context, codespace *Codespace, path string) ([]byte, error) {
 	req, err := http.NewRequest(http.MethodGet, githubAPI+"/repos/"+codespace.RepositoryNWO+"/contents/"+path, nil)
 	if err != nil {
-		return nil, fmt.Errorf("error creating request: %v", err)
+		return nil, fmt.Errorf("error creating request: %w", err)
 	}
 
 	q := req.URL.Query()
@@ -477,7 +477,7 @@ func (a *API) GetCodespaceRepositoryContents(ctx context.Context, codespace *Cod
 	a.setHeaders(req)
 	resp, err := a.do(ctx, req, "/repos/*/contents/*")
 	if err != nil {
-		return nil, fmt.Errorf("error making request: %v", err)
+		return nil, fmt.Errorf("error making request: %w", err)
 	}
 	defer resp.Body.Close()
 
@@ -487,7 +487,7 @@ func (a *API) GetCodespaceRepositoryContents(ctx context.Context, codespace *Cod
 
 	b, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("error reading response body: %v", err)
+		return nil, fmt.Errorf("error reading response body: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
@@ -496,12 +496,12 @@ func (a *API) GetCodespaceRepositoryContents(ctx context.Context, codespace *Cod
 
 	var response getCodespaceRepositoryContentsResponse
 	if err := json.Unmarshal(b, &response); err != nil {
-		return nil, fmt.Errorf("error unmarshaling response: %v", err)
+		return nil, fmt.Errorf("error unmarshaling response: %w", err)
 	}
 
 	decoded, err := base64.StdEncoding.DecodeString(response.Content)
 	if err != nil {
-		return nil, fmt.Errorf("error decoding content: %v", err)
+		return nil, fmt.Errorf("error decoding content: %w", err)
 	}
 
 	return decoded, nil
diff --git a/internal/codespaces/codespaces.go b/internal/codespaces/codespaces.go
index 804c2dab5..6235ca3a0 100644
--- a/internal/codespaces/codespaces.go
+++ b/internal/codespaces/codespaces.go
@@ -29,7 +29,7 @@ func ConnectToLiveshare(ctx context.Context, log logger, apiClient *api.API, use
 		startedCodespace = true
 		log.Print("Starting your codespace...")
 		if err := apiClient.StartCodespace(ctx, token, codespace); err != nil {
-			return nil, fmt.Errorf("error starting codespace: %v", err)
+			return nil, fmt.Errorf("error starting codespace: %w", err)
 		}
 	}
 
@@ -49,7 +49,7 @@ func ConnectToLiveshare(ctx context.Context, log logger, apiClient *api.API, use
 		var err error
 		codespace, err = apiClient.GetCodespace(ctx, token, userLogin, codespace.Name)
 		if err != nil {
-			return nil, fmt.Errorf("error getting codespace: %v", err)
+			return nil, fmt.Errorf("error getting codespace: %w", err)
 		}
 	}
 
@@ -68,7 +68,7 @@ func ConnectToLiveshare(ctx context.Context, log logger, apiClient *api.API, use
 		}),
 	)
 	if err != nil {
-		return nil, fmt.Errorf("error creating Live Share client: %v", err)
+		return nil, fmt.Errorf("error creating Live Share client: %w", err)
 	}
 
 	return lsclient.JoinWorkspace(ctx)