diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 2789ade34..e8098bcd8 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -18,10 +18,29 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Verify dependencies
-        run: go mod verify
-
-      - name: Build
         shell: bash
         run: |
-          go test -race ./...
-          go build -v ./cmd/gh
+          go mod verify
+          go mod download
+
+      - name: Run tests
+        shell: bash
+        run: |
+          assert-nothing-changed() {
+            local diff
+            git checkout -- .
+            "$@" >/dev/null || true
+            if ! diff="$(git diff -U1 --color --exit-code)"; then
+              printf '\n\e[31mError: running `\e[1m%s\e[22m` results in modifications that you must check into version control:\e[0m\n%s\n' "$*" "$diff" >&2
+              return 1
+            fi
+          }
+
+          STATUS=0
+          go test -race ./... || STATUS=$?
+          assert-nothing-changed go fmt ./... || STATUS=$?
+          assert-nothing-changed go mod tidy || STATUS=$?
+          exit $STATUS
+
+      - name: Build
+        run: go build -v ./cmd/gh
diff --git a/api/fake_http.go b/api/fake_http.go
index 92b904bd5..a88c9df17 100644
--- a/api/fake_http.go
+++ b/api/fake_http.go
@@ -48,18 +48,21 @@ func (f *FakeHTTP) StubWithFixture(status int, fixtureFileName string) func() {
 }
 
 func (f *FakeHTTP) StubRepoResponse(owner, repo string) {
+	f.StubRepoResponseWithPermission(owner, repo, "WRITE")
+}
+
+func (f *FakeHTTP) StubRepoResponseWithPermission(owner, repo, permission string) {
 	body := bytes.NewBufferString(fmt.Sprintf(`
 		{ "data": { "repo_000": {
 			"id": "REPOID",
 			"name": "%s",
 			"owner": {"login": "%s"},
 			"defaultBranchRef": {
-				"name": "master",
-				"target": {"oid": "deadbeef"}
+				"name": "master"
 			},
-			"viewerPermission": "WRITE"
+			"viewerPermission": "%s"
 		} } }
-	`, repo, owner))
+	`, repo, owner, permission))
 	resp := &http.Response{
 		StatusCode: 200,
 		Body:       ioutil.NopCloser(body),
@@ -76,8 +79,7 @@ func (f *FakeHTTP) StubForkedRepoResponse(forkFullName, parentFullName string) {
 			"name": "%s",
 			"owner": {"login": "%s"},
 			"defaultBranchRef": {
-				"name": "master",
-				"target": {"oid": "deadbeef"}
+				"name": "master"
 			},
 			"viewerPermission": "ADMIN",
 			"parent": {
@@ -85,8 +87,7 @@ func (f *FakeHTTP) StubForkedRepoResponse(forkFullName, parentFullName string) {
 				"name": "%s",
 				"owner": {"login": "%s"},
 				"defaultBranchRef": {
-					"name": "master",
-					"target": {"oid": "deadbeef"}
+					"name": "master"
 				},
 				"viewerPermission": "READ"
 			}
diff --git a/api/pull_request_test.go b/api/pull_request_test.go
index 82386108d..609a27e7c 100644
--- a/api/pull_request_test.go
+++ b/api/pull_request_test.go
@@ -22,7 +22,9 @@ func TestPullRequest_ChecksStatus(t *testing.T) {
 					{ "status": "COMPLETED",
 					  "conclusion": "FAILURE" },
 					{ "status": "COMPLETED",
-					  "conclusion": "ACTION_REQUIRED" }
+					  "conclusion": "ACTION_REQUIRED" },
+					{ "status": "COMPLETED",
+					  "conclusion": "STALE" }
 				]
 			}
 		}
@@ -32,8 +34,8 @@ func TestPullRequest_ChecksStatus(t *testing.T) {
 	eq(t, err, nil)
 
 	checks := pr.ChecksStatus()
-	eq(t, checks.Total, 7)
-	eq(t, checks.Pending, 2)
+	eq(t, checks.Total, 8)
+	eq(t, checks.Pending, 3)
 	eq(t, checks.Failing, 3)
 	eq(t, checks.Passing, 2)
 }
diff --git a/api/queries_pr.go b/api/queries_pr.go
index 0886d0568..905bd2066 100644
--- a/api/queries_pr.go
+++ b/api/queries_pr.go
@@ -120,7 +120,7 @@ func (pr *PullRequest) ChecksStatus() (summary PullRequestChecksStatus) {
 			summary.Passing++
 		case "ERROR", "FAILURE", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED":
 			summary.Failing++
-		case "EXPECTED", "REQUESTED", "QUEUED", "PENDING", "IN_PROGRESS":
+		case "EXPECTED", "REQUESTED", "QUEUED", "PENDING", "IN_PROGRESS", "STALE":
 			summary.Pending++
 		default:
 			panic(fmt.Errorf("unsupported status: %q", state))
diff --git a/api/queries_repo.go b/api/queries_repo.go
index ea2862500..b8ad760d0 100644
--- a/api/queries_repo.go
+++ b/api/queries_repo.go
@@ -2,32 +2,35 @@ package api
 
 import (
 	"bytes"
+	"context"
+	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"sort"
 	"strings"
 	"time"
 
 	"github.com/cli/cli/internal/ghrepo"
+	"github.com/cli/cli/utils"
+	"github.com/shurcooL/githubv4"
 )
 
 // Repository contains information about a GitHub repo
 type Repository struct {
-	ID        string
-	Name      string
-	URL       string
-	CloneURL  string
-	CreatedAt time.Time
-	Owner     RepositoryOwner
+	ID          string
+	Name        string
+	Description string
+	URL         string
+	CloneURL    string
+	CreatedAt   time.Time
+	Owner       RepositoryOwner
 
 	IsPrivate        bool
 	HasIssuesEnabled bool
 	ViewerPermission string
 	DefaultBranchRef struct {
-		Name   string
-		Target struct {
-			OID string
-		}
+		Name string
 	}
 
 	Parent *Repository
@@ -69,6 +72,7 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 		repository(owner: $owner, name: $name) {
 			id
 			hasIssuesEnabled
+			description
 		}
 	}`
 	variables := map[string]interface{}{
@@ -88,6 +92,37 @@ func GitHubRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 	return &result.Repository, nil
 }
 
+// RepoParent finds out the parent repository of a fork
+func RepoParent(client *Client, repo ghrepo.Interface) (ghrepo.Interface, error) {
+	var query struct {
+		Repository struct {
+			Parent *struct {
+				Name  string
+				Owner struct {
+					Login string
+				}
+			}
+		} `graphql:"repository(owner: $owner, name: $name)"`
+	}
+
+	variables := map[string]interface{}{
+		"owner": githubv4.String(repo.RepoOwner()),
+		"name":  githubv4.String(repo.RepoName()),
+	}
+
+	v4 := githubv4.NewClient(client.http)
+	err := v4.Query(context.Background(), &query, variables)
+	if err != nil {
+		return nil, err
+	}
+	if query.Repository.Parent == nil {
+		return nil, nil
+	}
+
+	parent := ghrepo.New(query.Repository.Parent.Owner.Login, query.Repository.Parent.Name)
+	return parent, nil
+}
+
 // RepoNetworkResult describes the relationship between related repositories
 type RepoNetworkResult struct {
 	ViewerLogin  string
@@ -122,7 +157,6 @@ func RepoNetwork(client *Client, repos []ghrepo.Interface) (RepoNetworkResult, e
 		viewerPermission
 		defaultBranchRef {
 			name
-			target { oid }
 		}
 		isPrivate
 	}
@@ -220,6 +254,49 @@ func ForkRepo(client *Client, repo ghrepo.Interface) (*Repository, error) {
 	}, nil
 }
 
+// RepoFindFork finds a fork of repo affiliated with the viewer
+func RepoFindFork(client *Client, repo ghrepo.Interface) (*Repository, error) {
+	result := struct {
+		Repository struct {
+			Forks struct {
+				Nodes []Repository
+			}
+		}
+	}{}
+
+	variables := map[string]interface{}{
+		"owner": repo.RepoOwner(),
+		"repo":  repo.RepoName(),
+	}
+
+	if err := client.GraphQL(`
+	query($owner: String!, $repo: String!) {
+		repository(owner: $owner, name: $repo) {
+			forks(first: 1, affiliations: [OWNER, COLLABORATOR]) {
+				nodes {
+					id
+					name
+					owner { login }
+					url
+					viewerPermission
+				}
+			}
+		}
+	}
+	`, variables, &result); err != nil {
+		return nil, err
+	}
+
+	forks := result.Repository.Forks.Nodes
+	// we check ViewerCanPush, even though we expect it to always be true per
+	// `affiliations` condition, to guard against versions of GitHub with a
+	// faulty `affiliations` implementation
+	if len(forks) > 0 && forks[0].ViewerCanPush() {
+		return &forks[0], nil
+	}
+	return nil, &NotFoundError{errors.New("no fork found")}
+}
+
 // RepoCreateInput represents input parameters for RepoCreate
 type RepoCreateInput struct {
 	Name        string `json:"name"`
@@ -279,3 +356,43 @@ func RepoCreate(client *Client, input RepoCreateInput) (*Repository, error) {
 
 	return &response.CreateRepository.Repository, nil
 }
+
+func RepositoryReadme(client *Client, fullName string) (string, error) {
+	type readmeResponse struct {
+		Name    string
+		Content string
+	}
+
+	var readme readmeResponse
+
+	err := client.REST("GET", fmt.Sprintf("repos/%s/readme", fullName), nil, &readme)
+	if err != nil && !strings.HasSuffix(err.Error(), "'Not Found'") {
+		return "", fmt.Errorf("could not get readme for repo: %w", err)
+	}
+
+	decoded, err := base64.StdEncoding.DecodeString(readme.Content)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode readme: %w", err)
+	}
+
+	readmeContent := string(decoded)
+
+	if isMarkdownFile(readme.Name) {
+		readmeContent, err = utils.RenderMarkdown(readmeContent)
+		if err != nil {
+			return "", fmt.Errorf("failed to render readme as markdown: %w", err)
+		}
+	}
+
+	return readmeContent, nil
+
+}
+
+func isMarkdownFile(filename string) bool {
+	// kind of gross, but i'm assuming that 90% of the time the suffix will just be .md. it didn't
+	// seem worth executing a regex for this given that assumption.
+	return strings.HasSuffix(filename, ".md") ||
+		strings.HasSuffix(filename, ".markdown") ||
+		strings.HasSuffix(filename, ".mdown") ||
+		strings.HasSuffix(filename, ".mkdown")
+}
diff --git a/command/issue.go b/command/issue.go
index f48195867..ecbb3930a 100644
--- a/command/issue.go
+++ b/command/issue.go
@@ -38,7 +38,7 @@ func init() {
 	issueListCmd.Flags().StringP("author", "A", "", "Filter by author")
 
 	issueCmd.AddCommand(issueViewCmd)
-	issueViewCmd.Flags().BoolP("preview", "p", false, "Display preview of issue content")
+	issueViewCmd.Flags().BoolP("web", "w", false, "Open issue in browser")
 }
 
 var issueCmd = &cobra.Command{
@@ -73,7 +73,7 @@ var issueViewCmd = &cobra.Command{
 		}
 		return nil
 	},
-	Short: "View an issue in the browser",
+	Short: "View an issue",
 	RunE:  issueView,
 }
 
@@ -213,17 +213,17 @@ func issueView(cmd *cobra.Command, args []string) error {
 	}
 	openURL := issue.URL
 
-	preview, err := cmd.Flags().GetBool("preview")
+	web, err := cmd.Flags().GetBool("web")
 	if err != nil {
 		return err
 	}
 
-	if preview {
-		out := colorableOut(cmd)
-		return printIssuePreview(out, issue)
-	} else {
+	if web {
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", openURL)
 		return utils.OpenInBrowser(openURL)
+	} else {
+		out := colorableOut(cmd)
+		return printIssuePreview(out, issue)
 	}
 
 }
diff --git a/command/issue_test.go b/command/issue_test.go
index a0aa6fd11..fc29a7a81 100644
--- a/command/issue_test.go
+++ b/command/issue_test.go
@@ -10,8 +10,8 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 	"github.com/google/go-cmp/cmp"
 )
 
@@ -217,7 +217,7 @@ func TestIssueList_disabledIssues(t *testing.T) {
 	}
 }
 
-func TestIssueView(t *testing.T) {
+func TestIssueView_web(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -230,13 +230,13 @@ func TestIssueView(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(issueViewCmd, "issue view 123")
+	output, err := RunCommand(issueViewCmd, "issue view -w 123")
 	if err != nil {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -251,7 +251,7 @@ func TestIssueView(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/issues/123")
 }
 
-func TestIssueView_numberArgWithHash(t *testing.T) {
+func TestIssueView_web_numberArgWithHash(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -264,13 +264,13 @@ func TestIssueView_numberArgWithHash(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(issueViewCmd, "issue view \"#123\"")
+	output, err := RunCommand(issueViewCmd, "issue view -w \"#123\"")
 	if err != nil {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -294,7 +294,7 @@ func TestIssueView_Preview(t *testing.T) {
 	}{
 		"Open issue": {
 			ownerRepo: "master",
-			command:   "issue view -p 123",
+			command:   "issue view 123",
 			fixture:   "../test/fixtures/issueView_preview.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`ix of coins`),
@@ -305,7 +305,7 @@ func TestIssueView_Preview(t *testing.T) {
 		},
 		"Open issue with no label": {
 			ownerRepo: "master",
-			command:   "issue view -p 123",
+			command:   "issue view 123",
 			fixture:   "../test/fixtures/issueView_previewNoLabel.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`ix of coins`),
@@ -316,7 +316,7 @@ func TestIssueView_Preview(t *testing.T) {
 		},
 		"Open issue with empty body": {
 			ownerRepo: "master",
-			command:   "issue view -p 123",
+			command:   "issue view 123",
 			fixture:   "../test/fixtures/issueView_previewWithEmptyBody.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`ix of coins`),
@@ -326,7 +326,7 @@ func TestIssueView_Preview(t *testing.T) {
 		},
 		"Closed issue": {
 			ownerRepo: "master",
-			command:   "issue view -p 123",
+			command:   "issue view 123",
 			fixture:   "../test/fixtures/issueView_previewClosedState.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`ix of coins`),
@@ -363,7 +363,7 @@ func TestIssueView_Preview(t *testing.T) {
 	}
 }
 
-func TestIssueView_notFound(t *testing.T) {
+func TestIssueView_web_notFound(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 
@@ -374,13 +374,13 @@ func TestIssueView_notFound(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	_, err := RunCommand(issueViewCmd, "issue view 9999")
+	_, err := RunCommand(issueViewCmd, "issue view -w 9999")
 	if err == nil || err.Error() != "graphql error: 'Could not resolve to an Issue with the number of 9999.'" {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -408,7 +408,7 @@ func TestIssueView_disabledIssues(t *testing.T) {
 	}
 }
 
-func TestIssueView_urlArg(t *testing.T) {
+func TestIssueView_web_urlArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -421,13 +421,13 @@ func TestIssueView_urlArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(issueViewCmd, "issue view https://github.com/OWNER/REPO/issues/123")
+	output, err := RunCommand(issueViewCmd, "issue view -w https://github.com/OWNER/REPO/issues/123")
 	if err != nil {
 		t.Errorf("error running command `issue view`: %v", err)
 	}
@@ -506,7 +506,7 @@ func TestIssueCreate_web(t *testing.T) {
 	http.StubRepoResponse("OWNER", "REPO")
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -532,7 +532,7 @@ func TestIssueCreate_webTitleBody(t *testing.T) {
 	http.StubRepoResponse("OWNER", "REPO")
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
diff --git a/command/pr.go b/command/pr.go
index ddbfd8740..cdfca9be3 100644
--- a/command/pr.go
+++ b/command/pr.go
@@ -31,7 +31,7 @@ func init() {
 	prListCmd.Flags().StringSliceP("label", "l", nil, "Filter by label")
 	prListCmd.Flags().StringP("assignee", "a", "", "Filter by assignee")
 
-	prViewCmd.Flags().BoolP("preview", "p", false, "Display preview of pull request content")
+	prViewCmd.Flags().BoolP("web", "w", false, "Open pull request in browser")
 }
 
 var prCmd = &cobra.Command{
@@ -57,10 +57,10 @@ var prStatusCmd = &cobra.Command{
 var prViewCmd = &cobra.Command{
 	Use:   "view [{<number> | <url> | <branch>}]",
 	Short: "View a pull request in the browser",
-	Long: `View a pull request specified by the argument in the browser.
+	Long: `View a pull request specified by the argument.
 
 Without an argument, the pull request that belongs to the current
-branch is opened.`,
+branch is displayed.`,
 	RunE: prView,
 }
 
@@ -84,7 +84,7 @@ func prStatus(cmd *cobra.Command, args []string) error {
 	repoOverride, _ := cmd.Flags().GetString("repo")
 	currentPRNumber, currentPRHeadRef, err := prSelectorForCurrentBranch(ctx, baseRepo)
 	if err != nil && repoOverride == "" && err.Error() != "git: not on any branch" {
-		return err
+		return fmt.Errorf("could not query for pull request for current branch: %w", err)
 	}
 
 	prPayload, err := api.PullRequests(apiClient, baseRepo, currentPRNumber, currentPRHeadRef, currentUser)
@@ -266,7 +266,7 @@ func prView(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	preview, err := cmd.Flags().GetBool("preview")
+	web, err := cmd.Flags().GetBool("web")
 	if err != nil {
 		return err
 	}
@@ -287,7 +287,7 @@ func prView(cmd *cobra.Command, args []string) error {
 
 		if prNumber > 0 {
 			openURL = fmt.Sprintf("https://github.com/%s/pull/%d", ghrepo.FullName(baseRepo), prNumber)
-			if preview {
+			if !web {
 				pr, err = api.PullRequestByNumber(apiClient, baseRepo, prNumber)
 				if err != nil {
 					return err
@@ -303,12 +303,12 @@ func prView(cmd *cobra.Command, args []string) error {
 		}
 	}
 
-	if preview {
-		out := colorableOut(cmd)
-		return printPrPreview(out, pr)
-	} else {
+	if web {
 		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", openURL)
 		return utils.OpenInBrowser(openURL)
+	} else {
+		out := colorableOut(cmd)
+		return printPrPreview(out, pr)
 	}
 }
 
@@ -413,7 +413,9 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 		reviews := pr.ReviewStatus()
 
 		if pr.State == "OPEN" {
-			if checks.Total > 0 || reviews.ChangesRequested || reviews.Approved {
+			reviewStatus := reviews.ChangesRequested || reviews.Approved || reviews.ReviewRequired
+			if checks.Total > 0 || reviewStatus {
+				// show checks & reviews on their own line
 				fmt.Fprintf(w, "\n  ")
 			}
 
@@ -421,24 +423,29 @@ func printPrs(w io.Writer, totalCount int, prs ...api.PullRequest) {
 				var summary string
 				if checks.Failing > 0 {
 					if checks.Failing == checks.Total {
-						summary = utils.Red("All checks failing")
+						summary = utils.Red("× All checks failing")
 					} else {
-						summary = utils.Red(fmt.Sprintf("%d/%d checks failing", checks.Failing, checks.Total))
+						summary = utils.Red(fmt.Sprintf("× %d/%d checks failing", checks.Failing, checks.Total))
 					}
 				} else if checks.Pending > 0 {
-					summary = utils.Yellow("Checks pending")
+					summary = utils.Yellow("- Checks pending")
 				} else if checks.Passing == checks.Total {
-					summary = utils.Green("Checks passing")
+					summary = utils.Green("✓ Checks passing")
 				}
-				fmt.Fprintf(w, " - %s", summary)
+				fmt.Fprint(w, summary)
+			}
+
+			if checks.Total > 0 && reviewStatus {
+				// add padding between checks & reviews
+				fmt.Fprint(w, " ")
 			}
 
 			if reviews.ChangesRequested {
-				fmt.Fprintf(w, " - %s", utils.Red("Changes requested"))
+				fmt.Fprint(w, utils.Red("+ Changes requested"))
 			} else if reviews.ReviewRequired {
-				fmt.Fprintf(w, " - %s", utils.Yellow("Review required"))
+				fmt.Fprint(w, utils.Yellow("- Review required"))
 			} else if reviews.Approved {
-				fmt.Fprintf(w, " - %s", utils.Green("Approved"))
+				fmt.Fprint(w, utils.Green("✓ Approved"))
 			}
 		} else {
 			fmt.Fprintf(w, " - %s", prStateTitleWithColor(pr))
diff --git a/command/pr_checkout.go b/command/pr_checkout.go
index 336a5a8d1..5db8fbd07 100644
--- a/command/pr_checkout.go
+++ b/command/pr_checkout.go
@@ -6,10 +6,11 @@ import (
 	"os"
 	"os/exec"
 
+	"github.com/spf13/cobra"
+
 	"github.com/cli/cli/git"
 	"github.com/cli/cli/internal/ghrepo"
-	"github.com/cli/cli/utils"
-	"github.com/spf13/cobra"
+	"github.com/cli/cli/internal/run"
 )
 
 func prCheckout(cmd *cobra.Command, args []string) error {
@@ -66,7 +67,7 @@ func prCheckout(cmd *cobra.Command, args []string) error {
 		cmdQueue = append(cmdQueue, []string{"git", "fetch", headRemote.Name, refSpec})
 
 		// local branch already exists
-		if git.VerifyRef("refs/heads/" + newBranchName) {
+		if _, err := git.ShowRefs("refs/heads/" + newBranchName); err == nil {
 			cmdQueue = append(cmdQueue, []string{"git", "checkout", newBranchName})
 			cmdQueue = append(cmdQueue, []string{"git", "merge", "--ff-only", fmt.Sprintf("refs/remotes/%s", remoteBranch)})
 		} else {
@@ -109,7 +110,7 @@ func prCheckout(cmd *cobra.Command, args []string) error {
 		cmd := exec.Command(args[0], args[1:]...)
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
-		if err := utils.PrepareCmd(cmd).Run(); err != nil {
+		if err := run.PrepareCmd(cmd).Run(); err != nil {
 			return err
 		}
 	}
diff --git a/command/pr_checkout_test.go b/command/pr_checkout_test.go
index 1a36756a7..a66163ed1 100644
--- a/command/pr_checkout_test.go
+++ b/command/pr_checkout_test.go
@@ -9,8 +9,8 @@ import (
 	"testing"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func TestPRCheckout_sameRepo(t *testing.T) {
@@ -44,9 +44,9 @@ func TestPRCheckout_sameRepo(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -96,9 +96,9 @@ func TestPRCheckout_urlArg(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -145,9 +145,9 @@ func TestPRCheckout_urlArg_differentBase(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -208,9 +208,9 @@ func TestPRCheckout_branchArg(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -258,9 +258,9 @@ func TestPRCheckout_existingBranch(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &test.OutputStub{}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -311,9 +311,9 @@ func TestPRCheckout_differentRepo_remoteExists(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
-		case "git show-ref --verify --quiet refs/heads/feature":
+		case "git show-ref --verify -- refs/heads/feature":
 			return &errorStub{"exit status: 1"}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
@@ -364,7 +364,7 @@ func TestPRCheckout_differentRepo(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
 			return &errorStub{"exit status 1"}
@@ -417,10 +417,10 @@ func TestPRCheckout_differentRepo_existingBranch(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
-			return &test.OutputStub{[]byte("refs/heads/feature\n")}
+			return &test.OutputStub{[]byte("refs/heads/feature\n"), nil}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
 			return &test.OutputStub{}
@@ -468,10 +468,10 @@ func TestPRCheckout_differentRepo_currentBranch(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
-			return &test.OutputStub{[]byte("refs/heads/feature\n")}
+			return &test.OutputStub{[]byte("refs/heads/feature\n"), nil}
 		default:
 			ranCommands = append(ranCommands, cmd.Args)
 			return &test.OutputStub{}
@@ -519,7 +519,7 @@ func TestPRCheckout_maintainerCanModify(t *testing.T) {
 	`))
 
 	ranCommands := [][]string{}
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case "git config branch.feature.merge":
 			return &errorStub{"exit status 1"}
diff --git a/command/pr_create.go b/command/pr_create.go
index 2be922987..96b3e27df 100644
--- a/command/pr_create.go
+++ b/command/pr_create.go
@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"strings"
 	"time"
 
 	"github.com/cli/cli/api"
@@ -75,7 +76,29 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return fmt.Errorf("could not determine the current branch: %w", err)
 	}
-	headRepo, headRepoErr := repoContext.HeadRepo()
+
+	var headRepo ghrepo.Interface
+	var headRemote *context.Remote
+
+	// determine whether the head branch is already pushed to a remote
+	headBranchPushedTo := determineTrackingBranch(remotes, headBranch)
+	if headBranchPushedTo != nil {
+		for _, r := range remotes {
+			if r.Name != headBranchPushedTo.RemoteName {
+				continue
+			}
+			headRepo = r
+			headRemote = r
+			break
+		}
+	}
+
+	// otherwise, determine the head repository with info obtained from the API
+	if headRepo == nil {
+		if r, err := repoContext.HeadRepo(); err == nil {
+			headRepo = r
+		}
+	}
 
 	baseBranch, err := cmd.Flags().GetString("base")
 	if err != nil {
@@ -101,7 +124,11 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		return fmt.Errorf("could not parse body: %w", err)
 	}
 
-	defs, defaultsErr := computeDefaults(baseBranch, headBranch)
+	baseTrackingBranch := baseBranch
+	if baseRemote, err := remotes.FindByRepo(baseRepo.RepoOwner(), baseRepo.RepoName()); err == nil {
+		baseTrackingBranch = fmt.Sprintf("%s/%s", baseRemote.Name, baseBranch)
+	}
+	defs, defaultsErr := computeDefaults(baseTrackingBranch, headBranch)
 
 	isWeb, err := cmd.Flags().GetBool("web")
 	if err != nil {
@@ -193,8 +220,9 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	}
 
 	didForkRepo := false
-	var headRemote *context.Remote
-	if headRepoErr != nil {
+	// if a head repository could not be determined so far, automatically create
+	// one by forking the base repository
+	if headRepo == nil {
 		if baseRepo.IsPrivate {
 			return fmt.Errorf("cannot fork private repository '%s'", ghrepo.FullName(baseRepo))
 		}
@@ -203,11 +231,29 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 			return fmt.Errorf("error forking repo: %w", err)
 		}
 		didForkRepo = true
+	}
+
+	headBranchLabel := headBranch
+	if !ghrepo.IsSame(baseRepo, headRepo) {
+		headBranchLabel = fmt.Sprintf("%s:%s", headRepo.RepoOwner(), headBranch)
+	}
+
+	if headRemote == nil {
+		headRemote, _ = repoContext.RemoteForRepo(headRepo)
+	}
+
+	// There are two cases when an existing remote for the head repo will be
+	// missing:
+	// 1. the head repo was just created by auto-forking;
+	// 2. an existing fork was discovered by quering the API.
+	//
+	// In either case, we want to add the head repo as a new git remote so we
+	// can push to it.
+	if headRemote == nil {
 		// TODO: support non-HTTPS git remote URLs
-		baseRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(baseRepo))
 		headRepoURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(headRepo))
-		// TODO: figure out what to name the new git remote
-		gitRemote, err := git.AddRemote("fork", baseRepoURL, headRepoURL)
+		// TODO: prevent clashes with another remote of a same name
+		gitRemote, err := git.AddRemote("fork", headRepoURL)
 		if err != nil {
 			return fmt.Errorf("error adding remote: %w", err)
 		}
@@ -218,34 +264,24 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 		}
 	}
 
-	headBranchLabel := headBranch
-	if !ghrepo.IsSame(baseRepo, headRepo) {
-		headBranchLabel = fmt.Sprintf("%s:%s", headRepo.RepoOwner(), headBranch)
-	}
-
-	if headRemote == nil {
-		headRemote, err = repoContext.RemoteForRepo(headRepo)
-		if err != nil {
-			return fmt.Errorf("git remote not found for head repository: %w", err)
-		}
-	}
-
-	pushTries := 0
-	maxPushTries := 3
-	for {
-		// TODO: respect existing upstream configuration of the current branch
-		if err := git.Push(headRemote.Name, fmt.Sprintf("HEAD:%s", headBranch)); err != nil {
-			if didForkRepo && pushTries < maxPushTries {
-				pushTries++
-				// first wait 2 seconds after forking, then 4s, then 6s
-				waitSeconds := 2 * pushTries
-				fmt.Fprintf(cmd.ErrOrStderr(), "waiting %s before retrying...\n", utils.Pluralize(waitSeconds, "second"))
-				time.Sleep(time.Duration(waitSeconds) * time.Second)
-				continue
+	// automatically push the branch if it hasn't been pushed anywhere yet
+	if headBranchPushedTo == nil {
+		pushTries := 0
+		maxPushTries := 3
+		for {
+			if err := git.Push(headRemote.Name, fmt.Sprintf("HEAD:%s", headBranch)); err != nil {
+				if didForkRepo && pushTries < maxPushTries {
+					pushTries++
+					// first wait 2 seconds after forking, then 4s, then 6s
+					waitSeconds := 2 * pushTries
+					fmt.Fprintf(cmd.ErrOrStderr(), "waiting %s before retrying...\n", utils.Pluralize(waitSeconds, "second"))
+					time.Sleep(time.Duration(waitSeconds) * time.Second)
+					continue
+				}
+				return err
 			}
-			return err
+			break
 		}
-		break
 	}
 
 	if action == SubmitAction {
@@ -275,6 +311,47 @@ func prCreate(cmd *cobra.Command, _ []string) error {
 	return nil
 }
 
+func determineTrackingBranch(remotes context.Remotes, headBranch string) *git.TrackingRef {
+	refsForLookup := []string{"HEAD"}
+	var trackingRefs []git.TrackingRef
+
+	headBranchConfig := git.ReadBranchConfig(headBranch)
+	if headBranchConfig.RemoteName != "" {
+		tr := git.TrackingRef{
+			RemoteName: headBranchConfig.RemoteName,
+			BranchName: strings.TrimPrefix(headBranchConfig.MergeRef, "refs/heads/"),
+		}
+		trackingRefs = append(trackingRefs, tr)
+		refsForLookup = append(refsForLookup, tr.String())
+	}
+
+	for _, remote := range remotes {
+		tr := git.TrackingRef{
+			RemoteName: remote.Name,
+			BranchName: headBranch,
+		}
+		trackingRefs = append(trackingRefs, tr)
+		refsForLookup = append(refsForLookup, tr.String())
+	}
+
+	resolvedRefs, _ := git.ShowRefs(refsForLookup...)
+	if len(resolvedRefs) > 1 {
+		for _, r := range resolvedRefs[1:] {
+			if r.Hash != resolvedRefs[0].Hash {
+				continue
+			}
+			for _, tr := range trackingRefs {
+				if tr.String() != r.Name {
+					continue
+				}
+				return &tr
+			}
+		}
+	}
+
+	return nil
+}
+
 func generateCompareURL(r ghrepo.Interface, base, head, title, body string) string {
 	u := fmt.Sprintf(
 		"https://github.com/%s/compare/%s...%s?expand=1",
diff --git a/command/pr_create_test.go b/command/pr_create_test.go
index 874b02a86..5a89ad911 100644
--- a/command/pr_create_test.go
+++ b/command/pr_create_test.go
@@ -8,12 +8,18 @@ import (
 	"testing"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/git"
+	"github.com/cli/cli/test"
 )
 
 func TestPRCreate(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -24,9 +30,11 @@ func TestPRCreate(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -34,7 +42,7 @@ func TestPRCreate(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create -t "my title" -b "my body"`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -57,10 +65,57 @@ func TestPRCreate(t *testing.T) {
 	eq(t, output.String(), "https://github.com/OWNER/REPO/pull/12\n")
 }
 
+func TestPRCreate_withForking(t *testing.T) {
+	initBlankContext("OWNER/REPO", "feature")
+	http := initFakeHTTP()
+	http.StubRepoResponseWithPermission("OWNER", "REPO", "READ")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": { "forks": { "nodes": [
+		] } } } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "repository": { "pullRequests": { "nodes" : [
+		] } } } }
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "node_id": "NODEID",
+		"name": "REPO",
+		"owner": {"login": "myself"},
+		"clone_url": "http://example.com",
+		"created_at": "2008-02-25T20:21:40Z"
+		}
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": { "createPullRequest": { "pullRequest": {
+			"URL": "https://github.com/OWNER/REPO/pull/12"
+		} } } }
+	`))
+
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
+	cs.Stub("")                                         // git status
+	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
+	cs.Stub("")                                         // git remote add
+	cs.Stub("")                                         // git push
+
+	output, err := RunCommand(prCreateCmd, `pr create -t title -b body`)
+	eq(t, err, nil)
+
+	eq(t, http.Requests[3].URL.Path, "/repos/OWNER/REPO/forks")
+	eq(t, output.String(), "https://github.com/OWNER/REPO/pull/12\n")
+}
+
 func TestPRCreate_alreadyExists(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes": [
 			{ "url": "https://github.com/OWNER/REPO/pull/123",
@@ -69,9 +124,11 @@ func TestPRCreate_alreadyExists(t *testing.T) {
 		] } } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 
@@ -88,6 +145,10 @@ func TestPRCreate_alreadyExistsDifferentBase(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes": [
 			{ "url": "https://github.com/OWNER/REPO/pull/123",
@@ -97,9 +158,11 @@ func TestPRCreate_alreadyExistsDifferentBase(t *testing.T) {
 	`))
 	http.StubResponse(200, bytes.NewBufferString("{}"))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git rev-parse
@@ -114,10 +177,16 @@ func TestPRCreate_web(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -129,9 +198,9 @@ func TestPRCreate_web(t *testing.T) {
 	eq(t, output.String(), "")
 	eq(t, output.Stderr(), "Opening github.com/OWNER/REPO/compare/master...feature in your browser.\n")
 
-	eq(t, len(cs.Calls), 4)
-	eq(t, strings.Join(cs.Calls[2].Args, " "), "git push --set-upstream origin HEAD:feature")
-	browserCall := cs.Calls[3].Args
+	eq(t, len(cs.Calls), 6)
+	eq(t, strings.Join(cs.Calls[4].Args, " "), "git push --set-upstream origin HEAD:feature")
+	browserCall := cs.Calls[5].Args
 	eq(t, browserCall[len(browserCall)-1], "https://github.com/OWNER/REPO/compare/master...feature?expand=1")
 }
 
@@ -140,6 +209,10 @@ func TestPRCreate_ReportsUncommittedChanges(t *testing.T) {
 	http := initFakeHTTP()
 
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -150,9 +223,11 @@ func TestPRCreate_ReportsUncommittedChanges(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub(" M git/git.go")                            // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -184,8 +259,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 									"name": "REPO",
 									"owner": {"login": "OWNER"},
 									"defaultBranchRef": {
-										"name": "default",
-										"target": {"oid": "deadbeef"}
+										"name": "default"
 									},
 									"viewerPermission": "READ"
 								},
@@ -195,8 +269,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 										"name": "REPO",
 										"owner": {"login": "OWNER"},
 										"defaultBranchRef": {
-											"name": "default",
-											"target": {"oid": "deadbeef"}
+											"name": "default"
 										},
 										"viewerPermission": "READ"
 									},
@@ -204,8 +277,7 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 									"name": "REPO",
 									"owner": {"login": "MYSELF"},
 									"defaultBranchRef": {
-										"name": "default",
-										"target": {"oid": "deadbeef"}
+										"name": "default"
 									},
 									"viewerPermission": "WRITE"
 		} } }
@@ -220,9 +292,11 @@ func TestPRCreate_cross_repo_same_branch(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git push
@@ -259,6 +333,10 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 	initBlankContext("OWNER/REPO", "cool_bug-fixes")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -269,9 +347,11 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                         // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                         // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                         // git status
 	cs.Stub("1234567890,commit 0\n2345678901,commit 1") // git log
 	cs.Stub("")                                         // git rev-parse
@@ -300,7 +380,7 @@ func TestPRCreate_survey_defaults_multicommit(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -329,6 +409,10 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -339,9 +423,11 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                                        // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                                        // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                                        // git status
 	cs.Stub("1234567890,the sky above the port")                       // git log
 	cs.Stub("was the color of a television, turned to a dead channel") // git show
@@ -371,7 +457,7 @@ func TestPRCreate_survey_defaults_monocommit(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -400,6 +486,10 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "repository": { "pullRequests": { "nodes" : [
 		] } } } }
@@ -410,9 +500,11 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("")                                                        // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("")                                                        // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("")                                                        // git status
 	cs.Stub("1234567890,the sky above the port")                       // git log
 	cs.Stub("was the color of a television, turned to a dead channel") // git show
@@ -423,7 +515,7 @@ func TestPRCreate_survey_autofill(t *testing.T) {
 	output, err := RunCommand(prCreateCmd, `pr create -f`)
 	eq(t, err, nil)
 
-	bodyBytes, _ := ioutil.ReadAll(http.Requests[2].Body)
+	bodyBytes, _ := ioutil.ReadAll(http.Requests[3].Body)
 	reqBody := struct {
 		Variables struct {
 			Input struct {
@@ -453,15 +545,17 @@ func TestPRCreate_defaults_error_autofill(t *testing.T) {
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("") // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("") // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("") // git status
 	cs.Stub("") // git log
 
 	_, err := RunCommand(prCreateCmd, "pr create -f")
 
-	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between master and feature")
+	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between origin/master and feature")
 }
 
 func TestPRCreate_defaults_error_web(t *testing.T) {
@@ -469,30 +563,38 @@ func TestPRCreate_defaults_error_web(t *testing.T) {
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("") // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("") // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("") // git status
 	cs.Stub("") // git log
 
 	_, err := RunCommand(prCreateCmd, "pr create -w")
 
-	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between master and feature")
+	eq(t, err.Error(), "could not compute title or body defaults: could not find any commits between origin/master and feature")
 }
 
 func TestPRCreate_defaults_error_interactive(t *testing.T) {
 	initBlankContext("OWNER/REPO", "feature")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
 	http.StubResponse(200, bytes.NewBufferString(`
 		{ "data": { "createPullRequest": { "pullRequest": {
 			"URL": "https://github.com/OWNER/REPO/pull/12"
 		} } } }
 	`))
 
-	cs, cmdTeardown := initCmdStubber()
+	cs, cmdTeardown := test.InitCmdStubber()
 	defer cmdTeardown()
 
+	cs.Stub("") // git config --get-regexp (determineTrackingBranch)
+	cs.Stub("") // git show-ref --verify   (determineTrackingBranch)
 	cs.Stub("") // git status
 	cs.Stub("") // git log
 	cs.Stub("") // git rev-parse
@@ -525,3 +627,103 @@ func TestPRCreate_defaults_error_interactive(t *testing.T) {
 	stderr := string(output.Stderr())
 	eq(t, strings.Contains(stderr, "warning: could not compute title or body defaults: could not find any commits"), true)
 }
+
+func Test_determineTrackingBranch_empty(t *testing.T) {
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{}
+
+	cs.Stub("")              // git config --get-regexp (ReadBranchConfig)
+	cs.Stub("deadbeef HEAD") // git show-ref --verify   (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref != nil {
+		t.Errorf("expected nil result, got %v", ref)
+	}
+}
+
+func Test_determineTrackingBranch_noMatch(t *testing.T) {
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{
+		&context.Remote{
+			Remote: &git.Remote{Name: "origin"},
+			Owner:  "hubot",
+			Repo:   "Spoon-Knife",
+		},
+		&context.Remote{
+			Remote: &git.Remote{Name: "upstream"},
+			Owner:  "octocat",
+			Repo:   "Spoon-Knife",
+		},
+	}
+
+	cs.Stub("") // git config --get-regexp (ReadBranchConfig)
+	cs.Stub(`deadbeef HEAD
+deadb00f refs/remotes/origin/feature`) // git show-ref --verify (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref != nil {
+		t.Errorf("expected nil result, got %v", ref)
+	}
+}
+
+func Test_determineTrackingBranch_hasMatch(t *testing.T) {
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{
+		&context.Remote{
+			Remote: &git.Remote{Name: "origin"},
+			Owner:  "hubot",
+			Repo:   "Spoon-Knife",
+		},
+		&context.Remote{
+			Remote: &git.Remote{Name: "upstream"},
+			Owner:  "octocat",
+			Repo:   "Spoon-Knife",
+		},
+	}
+
+	cs.Stub("") // git config --get-regexp (ReadBranchConfig)
+	cs.Stub(`deadbeef HEAD
+deadb00f refs/remotes/origin/feature
+deadbeef refs/remotes/upstream/feature`) // git show-ref --verify (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref == nil {
+		t.Fatal("expected result, got nil")
+	}
+
+	eq(t, cs.Calls[1].Args, []string{"git", "show-ref", "--verify", "--", "HEAD", "refs/remotes/origin/feature", "refs/remotes/upstream/feature"})
+
+	eq(t, ref.RemoteName, "upstream")
+	eq(t, ref.BranchName, "feature")
+}
+
+func Test_determineTrackingBranch_respectTrackingConfig(t *testing.T) {
+	cs, cmdTeardown := test.InitCmdStubber()
+	defer cmdTeardown()
+
+	remotes := context.Remotes{
+		&context.Remote{
+			Remote: &git.Remote{Name: "origin"},
+			Owner:  "hubot",
+			Repo:   "Spoon-Knife",
+		},
+	}
+
+	cs.Stub(`branch.feature.remote origin
+branch.feature.merge refs/heads/great-feat`) // git config --get-regexp (ReadBranchConfig)
+	cs.Stub(`deadbeef HEAD
+deadb00f refs/remotes/origin/feature`) // git show-ref --verify (ShowRefs)
+
+	ref := determineTrackingBranch(remotes, "feature")
+	if ref != nil {
+		t.Errorf("expected nil result, got %v", ref)
+	}
+
+	eq(t, cs.Calls[1].Args, []string{"git", "show-ref", "--verify", "--", "HEAD", "refs/remotes/origin/great-feat", "refs/remotes/origin/feature"})
+}
diff --git a/command/pr_test.go b/command/pr_test.go
index 7dc127402..a19279a9e 100644
--- a/command/pr_test.go
+++ b/command/pr_test.go
@@ -12,8 +12,8 @@ import (
 	"testing"
 
 	"github.com/cli/cli/api"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/shlex"
 	"github.com/spf13/cobra"
@@ -110,11 +110,11 @@ func TestPRStatus_fork(t *testing.T) {
 	defer jsonFile.Close()
 	http.StubResponse(200, jsonFile)
 
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{[]byte(`branch.blueberries.remote origin
-branch.blueberries.merge refs/heads/blueberries`)}
+branch.blueberries.merge refs/heads/blueberries`), nil}
 		default:
 			panic("not implemented")
 		}
@@ -146,9 +146,9 @@ func TestPRStatus_reviewsAndChecks(t *testing.T) {
 	}
 
 	expected := []string{
-		"- Checks passing - Changes requested",
-		"- Checks pending - Approved",
-		"- 1/3 checks failing - Review required",
+		"✓ Checks passing + Changes requested",
+		"- Checks pending ✓ Approved",
+		"× 1/3 checks failing - Review required",
 	}
 
 	for _, line := range expected {
@@ -411,7 +411,7 @@ func TestPRView_Preview(t *testing.T) {
 	}{
 		"Open PR": {
 			ownerRepo: "master",
-			args:      "pr view -p 12",
+			args:      "pr view 12",
 			fixture:   "../test/fixtures/prViewPreview.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are from a fork`),
@@ -422,7 +422,7 @@ func TestPRView_Preview(t *testing.T) {
 		},
 		"Open PR for the current branch": {
 			ownerRepo: "blueberries",
-			args:      "pr view -p",
+			args:      "pr view",
 			fixture:   "../test/fixtures/prView.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are a good fruit`),
@@ -433,7 +433,7 @@ func TestPRView_Preview(t *testing.T) {
 		},
 		"Open PR wth empty body for the current branch": {
 			ownerRepo: "blueberries",
-			args:      "pr view -p",
+			args:      "pr view",
 			fixture:   "../test/fixtures/prView_EmptyBody.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are a good fruit`),
@@ -443,7 +443,7 @@ func TestPRView_Preview(t *testing.T) {
 		},
 		"Closed PR": {
 			ownerRepo: "master",
-			args:      "pr view -p 12",
+			args:      "pr view 12",
 			fixture:   "../test/fixtures/prViewPreviewClosedState.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are from a fork`),
@@ -454,7 +454,7 @@ func TestPRView_Preview(t *testing.T) {
 		},
 		"Merged PR": {
 			ownerRepo: "master",
-			args:      "pr view -p 12",
+			args:      "pr view 12",
 			fixture:   "../test/fixtures/prViewPreviewMergedState.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are from a fork`),
@@ -465,7 +465,7 @@ func TestPRView_Preview(t *testing.T) {
 		},
 		"Draft PR": {
 			ownerRepo: "master",
-			args:      "pr view -p 12",
+			args:      "pr view 12",
 			fixture:   "../test/fixtures/prViewPreviewDraftState.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are from a fork`),
@@ -476,7 +476,7 @@ func TestPRView_Preview(t *testing.T) {
 		},
 		"Draft PR by branch": {
 			ownerRepo: "master",
-			args:      "pr view -p blueberries",
+			args:      "pr view blueberries",
 			fixture:   "../test/fixtures/prViewPreviewDraftStatebyBranch.json",
 			expectedOutputs: []*regexp.Regexp{
 				regexp.MustCompile(`Blueberries are a good fruit`),
@@ -514,7 +514,7 @@ func TestPRView_Preview(t *testing.T) {
 	}
 }
 
-func TestPRView_currentBranch(t *testing.T) {
+func TestPRView_web_currentBranch(t *testing.T) {
 	initBlankContext("OWNER/REPO", "blueberries")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -524,7 +524,7 @@ func TestPRView_currentBranch(t *testing.T) {
 	http.StubResponse(200, jsonFile)
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{}
@@ -535,7 +535,7 @@ func TestPRView_currentBranch(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view")
+	output, err := RunCommand(prViewCmd, "pr view -w")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -552,7 +552,7 @@ func TestPRView_currentBranch(t *testing.T) {
 	}
 }
 
-func TestPRView_noResultsForBranch(t *testing.T) {
+func TestPRView_web_noResultsForBranch(t *testing.T) {
 	initBlankContext("OWNER/REPO", "blueberries")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -562,7 +562,7 @@ func TestPRView_noResultsForBranch(t *testing.T) {
 	http.StubResponse(200, jsonFile)
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		switch strings.Join(cmd.Args, " ") {
 		case `git config --get-regexp ^branch\.blueberries\.(remote|merge)$`:
 			return &test.OutputStub{}
@@ -573,7 +573,7 @@ func TestPRView_noResultsForBranch(t *testing.T) {
 	})
 	defer restoreCmd()
 
-	_, err := RunCommand(prViewCmd, "pr view")
+	_, err := RunCommand(prViewCmd, "pr view -w")
 	if err == nil || err.Error() != `no open pull requests found for branch "blueberries"` {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -583,7 +583,7 @@ func TestPRView_noResultsForBranch(t *testing.T) {
 	}
 }
 
-func TestPRView_numberArg(t *testing.T) {
+func TestPRView_web_numberArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -595,13 +595,13 @@ func TestPRView_numberArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view 23")
+	output, err := RunCommand(prViewCmd, "pr view -w 23")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -615,7 +615,7 @@ func TestPRView_numberArg(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_numberArgWithHash(t *testing.T) {
+func TestPRView_web_numberArgWithHash(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -627,13 +627,13 @@ func TestPRView_numberArgWithHash(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view \"#23\"")
+	output, err := RunCommand(prViewCmd, "pr view -w \"#23\"")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -647,7 +647,7 @@ func TestPRView_numberArgWithHash(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_urlArg(t *testing.T) {
+func TestPRView_web_urlArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 
@@ -658,13 +658,13 @@ func TestPRView_urlArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view https://github.com/OWNER/REPO/pull/23/files")
+	output, err := RunCommand(prViewCmd, "pr view -w https://github.com/OWNER/REPO/pull/23/files")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -678,7 +678,7 @@ func TestPRView_urlArg(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_branchArg(t *testing.T) {
+func TestPRView_web_branchArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -692,13 +692,13 @@ func TestPRView_branchArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view blueberries")
+	output, err := RunCommand(prViewCmd, "pr view -w blueberries")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
@@ -712,7 +712,7 @@ func TestPRView_branchArg(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO/pull/23")
 }
 
-func TestPRView_branchWithOwnerArg(t *testing.T) {
+func TestPRView_web_branchWithOwnerArg(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -727,13 +727,13 @@ func TestPRView_branchWithOwnerArg(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(prViewCmd, "pr view hubot:blueberries")
+	output, err := RunCommand(prViewCmd, "pr view -w hubot:blueberries")
 	if err != nil {
 		t.Errorf("error running command `pr view`: %v", err)
 	}
diff --git a/command/repo.go b/command/repo.go
index be930c0c8..afc6ddec7 100644
--- a/command/repo.go
+++ b/command/repo.go
@@ -6,12 +6,14 @@ import (
 	"os"
 	"path"
 	"strings"
+	"text/template"
 	"time"
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/git"
 	"github.com/cli/cli/internal/ghrepo"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/utils"
 	"github.com/spf13/cobra"
 )
@@ -35,6 +37,7 @@ func init() {
 	repoForkCmd.Flags().Lookup("remote").NoOptDefVal = "true"
 
 	repoCmd.AddCommand(repoViewCmd)
+	repoViewCmd.Flags().BoolP("web", "w", false, "Open repository in browser")
 }
 
 var repoCmd = &cobra.Command{
@@ -78,9 +81,9 @@ With no argument, creates a fork of the current repository. Otherwise, forks the
 var repoViewCmd = &cobra.Command{
 	Use:   "view [<repository>]",
 	Short: "View a repository in the browser",
-	Long: `View a GitHub repository in the browser.
+	Long: `View a GitHub repository.
 
-With no argument, the repository for the current directory is opened.`,
+With no argument, the repository for the current directory is displayed.`,
 	RunE: repoView,
 }
 
@@ -90,6 +93,28 @@ func repoClone(cmd *cobra.Command, args []string) error {
 		cloneURL = fmt.Sprintf("https://github.com/%s.git", cloneURL)
 	}
 
+	var repo ghrepo.Interface
+	var parentRepo ghrepo.Interface
+
+	// TODO: consider caching and reusing `git.ParseSSHConfig().Translator()`
+	// here to handle hostname aliases in SSH remotes
+	if u, err := git.ParseURL(cloneURL); err == nil {
+		repo, _ = ghrepo.FromURL(u)
+	}
+
+	if repo != nil {
+		ctx := contextForCommand(cmd)
+		apiClient, err := apiClientForContext(ctx)
+		if err != nil {
+			return err
+		}
+
+		parentRepo, err = api.RepoParent(apiClient, repo)
+		if err != nil {
+			return err
+		}
+	}
+
 	cloneArgs := []string{"clone"}
 	cloneArgs = append(cloneArgs, args[1:]...)
 	cloneArgs = append(cloneArgs, cloneURL)
@@ -98,7 +123,30 @@ func repoClone(cmd *cobra.Command, args []string) error {
 	cloneCmd.Stdin = os.Stdin
 	cloneCmd.Stdout = os.Stdout
 	cloneCmd.Stderr = os.Stderr
-	return utils.PrepareCmd(cloneCmd).Run()
+	err := run.PrepareCmd(cloneCmd).Run()
+	if err != nil {
+		return err
+	}
+
+	if parentRepo != nil {
+		err := addUpstreamRemote(parentRepo, cloneURL)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func addUpstreamRemote(parentRepo ghrepo.Interface, cloneURL string) error {
+	// TODO: support SSH remote URLs
+	upstreamURL := fmt.Sprintf("https://github.com/%s.git", ghrepo.FullName(parentRepo))
+	cloneDir := path.Base(strings.TrimSuffix(cloneURL, ".git"))
+
+	cloneCmd := git.GitCommand("-C", cloneDir, "remote", "add", "upstream", upstreamURL)
+	cloneCmd.Stdout = os.Stdout
+	cloneCmd.Stderr = os.Stderr
+	return run.PrepareCmd(cloneCmd).Run()
 }
 
 func repoCreate(cmd *cobra.Command, args []string) error {
@@ -198,7 +246,7 @@ func repoCreate(cmd *cobra.Command, args []string) error {
 		remoteAdd := git.GitCommand("remote", "add", "origin", remoteURL)
 		remoteAdd.Stdout = os.Stdout
 		remoteAdd.Stderr = os.Stderr
-		err = utils.PrepareCmd(remoteAdd).Run()
+		err = run.PrepareCmd(remoteAdd).Run()
 		if err != nil {
 			return err
 		}
@@ -218,14 +266,14 @@ func repoCreate(cmd *cobra.Command, args []string) error {
 			gitInit := git.GitCommand("init", path)
 			gitInit.Stdout = os.Stdout
 			gitInit.Stderr = os.Stderr
-			err = utils.PrepareCmd(gitInit).Run()
+			err = run.PrepareCmd(gitInit).Run()
 			if err != nil {
 				return err
 			}
 			gitRemoteAdd := git.GitCommand("-C", path, "remote", "add", "origin", remoteURL)
 			gitRemoteAdd.Stdout = os.Stdout
 			gitRemoteAdd.Stderr = os.Stderr
-			err = utils.PrepareCmd(gitRemoteAdd).Run()
+			err = run.PrepareCmd(gitRemoteAdd).Run()
 			if err != nil {
 				return err
 			}
@@ -301,14 +349,6 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	s.FinalMSG = utils.Gray(fmt.Sprintf("- %s\n", loading))
 	s.Start()
 
-	authLogin, err := ctx.AuthLogin()
-	if err != nil {
-		s.Stop()
-		return fmt.Errorf("could not determine current username: %w", err)
-	}
-
-	possibleFork := ghrepo.New(authLogin, toFork.RepoName())
-
 	forkedRepo, err := api.ForkRepo(apiClient, toFork)
 	if err != nil {
 		s.Stop()
@@ -321,11 +361,11 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	// returns the fork repo data even if it already exists -- with no change in status code or
 	// anything. We thus check the created time to see if the repo is brand new or not; if it's not,
 	// we assume the fork already existed and report an error.
-	created_ago := Since(forkedRepo.CreatedAt)
-	if created_ago > time.Minute {
+	createdAgo := Since(forkedRepo.CreatedAt)
+	if createdAgo > time.Minute {
 		fmt.Fprintf(out, "%s %s %s\n",
 			utils.Yellow("!"),
-			utils.Bold(ghrepo.FullName(possibleFork)),
+			utils.Bold(ghrepo.FullName(forkedRepo)),
 			"already exists")
 	} else {
 		fmt.Fprintf(out, "%s Created fork %s\n", greenCheck, utils.Bold(ghrepo.FullName(forkedRepo)))
@@ -336,6 +376,15 @@ func repoFork(cmd *cobra.Command, args []string) error {
 	}
 
 	if inParent {
+		remotes, err := ctx.Remotes()
+		if err != nil {
+			return err
+		}
+		if remote, err := remotes.FindByRepo(forkedRepo.RepoOwner(), forkedRepo.RepoName()); err == nil {
+			fmt.Fprintf(out, "%s Using existing remote %s\n", greenCheck, utils.Bold(remote.Name))
+			return nil
+		}
+
 		remoteDesired := remotePref == "true"
 		if remotePref == "prompt" {
 			err = Confirm("Would you like to add a remote for the fork?", &remoteDesired)
@@ -344,12 +393,28 @@ func repoFork(cmd *cobra.Command, args []string) error {
 			}
 		}
 		if remoteDesired {
-			_, err := git.AddRemote("fork", forkedRepo.CloneURL, "")
+			remoteName := "origin"
+
+			remotes, err := ctx.Remotes()
+			if err != nil {
+				return err
+			}
+			if _, err := remotes.FindByName(remoteName); err == nil {
+				renameTarget := "upstream"
+				renameCmd := git.GitCommand("remote", "rename", remoteName, renameTarget)
+				err = run.PrepareCmd(renameCmd).Run()
+				if err != nil {
+					return err
+				}
+				fmt.Fprintf(out, "%s Renamed %s remote to %s\n", greenCheck, utils.Bold(remoteName), utils.Bold(renameTarget))
+			}
+
+			_, err = git.AddRemote(remoteName, forkedRepo.CloneURL)
 			if err != nil {
 				return fmt.Errorf("failed to add remote: %w", err)
 			}
 
-			fmt.Fprintf(out, "%s Remote added at %s\n", greenCheck, utils.Bold("fork"))
+			fmt.Fprintf(out, "%s Added remote %s\n", greenCheck, utils.Bold(remoteName))
 		}
 	} else {
 		cloneDesired := clonePref == "true"
@@ -364,11 +429,16 @@ func repoFork(cmd *cobra.Command, args []string) error {
 			cloneCmd.Stdin = os.Stdin
 			cloneCmd.Stdout = os.Stdout
 			cloneCmd.Stderr = os.Stderr
-			err = utils.PrepareCmd(cloneCmd).Run()
+			err = run.PrepareCmd(cloneCmd).Run()
 			if err != nil {
 				return fmt.Errorf("failed to clone fork: %w", err)
 			}
 
+			err = addUpstreamRemote(toFork, forkedRepo.CloneURL)
+			if err != nil {
+				return err
+			}
+
 			fmt.Fprintf(out, "%s Cloned fork\n", greenCheck)
 		}
 	}
@@ -386,6 +456,7 @@ var Confirm = func(prompt string, result *bool) error {
 
 func repoView(cmd *cobra.Command, args []string) error {
 	ctx := contextForCommand(cmd)
+
 	var toView ghrepo.Interface
 	if len(args) == 0 {
 		var err error
@@ -414,12 +485,67 @@ func repoView(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	_, err = api.GitHubRepo(apiClient, toView)
+	repo, err := api.GitHubRepo(apiClient, toView)
 	if err != nil {
 		return err
 	}
 
-	openURL := fmt.Sprintf("https://github.com/%s", ghrepo.FullName(toView))
-	fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", displayURL(openURL))
-	return utils.OpenInBrowser(openURL)
+	web, err := cmd.Flags().GetBool("web")
+	if err != nil {
+		return err
+	}
+
+	fullName := ghrepo.FullName(toView)
+
+	openURL := fmt.Sprintf("https://github.com/%s", fullName)
+	if web {
+		fmt.Fprintf(cmd.ErrOrStderr(), "Opening %s in your browser.\n", displayURL(openURL))
+		return utils.OpenInBrowser(openURL)
+	}
+
+	repoTmpl := `
+{{.FullName}}
+{{.Description}}
+
+{{.Readme}}
+
+{{.View}}
+`
+
+	tmpl, err := template.New("repo").Parse(repoTmpl)
+	if err != nil {
+		return err
+	}
+
+	readmeContent, _ := api.RepositoryReadme(apiClient, fullName)
+
+	if readmeContent == "" {
+		readmeContent = utils.Gray("No README provided")
+	}
+
+	description := repo.Description
+	if description == "" {
+		description = utils.Gray("No description provided")
+	}
+
+	repoData := struct {
+		FullName    string
+		Description string
+		Readme      string
+		View        string
+	}{
+		FullName:    utils.Bold(fullName),
+		Description: description,
+		Readme:      readmeContent,
+		View:        utils.Gray(fmt.Sprintf("View this repository on GitHub: %s", openURL)),
+	}
+
+	out := colorableOut(cmd)
+
+	err = tmpl.Execute(out, repoData)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
diff --git a/command/repo_test.go b/command/repo_test.go
index 6001be817..f0d271cf8 100644
--- a/command/repo_test.go
+++ b/command/repo_test.go
@@ -11,16 +11,15 @@ import (
 	"time"
 
 	"github.com/cli/cli/context"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func TestRepoFork_already_forked(t *testing.T) {
 	initContext = func() context.Context {
 		ctx := context.NewBlank()
-		ctx.SetBaseRepo("REPO")
+		ctx.SetBaseRepo("OWNER/REPO")
 		ctx.SetBranch("master")
-		ctx.SetAuthLogin("someone")
 		ctx.SetRemotes(map[string]string{
 			"origin": "OWNER/REPO",
 		})
@@ -41,6 +40,31 @@ func TestRepoFork_already_forked(t *testing.T) {
 	}
 }
 
+func TestRepoFork_reuseRemote(t *testing.T) {
+	initContext = func() context.Context {
+		ctx := context.NewBlank()
+		ctx.SetBaseRepo("OWNER/REPO")
+		ctx.SetBranch("master")
+		ctx.SetRemotes(map[string]string{
+			"upstream": "OWNER/REPO",
+			"origin":   "someone/REPO",
+		})
+		return ctx
+	}
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	defer http.StubWithFixture(200, "forkResult.json")()
+
+	output, err := RunCommand(repoForkCmd, "repo fork")
+	if err != nil {
+		t.Errorf("got unexpected error: %v", err)
+	}
+	if !strings.Contains(output.String(), "Using existing remote origin") {
+		t.Errorf("output did not match: %q", output)
+		return
+	}
+}
+
 func stubSince(d time.Duration) func() {
 	originalSince := Since
 	Since = func(t time.Time) time.Duration {
@@ -116,7 +140,7 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	var seenCmds []*exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmds = append(seenCmds, cmd)
 		return &test.OutputStub{}
 	})()
@@ -127,8 +151,8 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 	}
 
 	expectedCmds := []string{
-		"git remote add -f fork https://github.com/someone/repo.git",
-		"git fetch fork",
+		"git remote rename origin upstream",
+		"git remote add -f origin https://github.com/someone/repo.git",
 	}
 
 	for x, cmd := range seenCmds {
@@ -137,16 +161,9 @@ func TestRepoFork_in_parent_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Remote added at fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Added remote origin")
 }
 
 func TestRepoFork_outside_yes(t *testing.T) {
@@ -154,11 +171,11 @@ func TestRepoFork_outside_yes(t *testing.T) {
 	http := initFakeHTTP()
 	defer http.StubWithFixture(200, "forkResult.json")()
 
-	var seenCmd *exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
-		seenCmd = cmd
-		return &test.OutputStub{}
-	})()
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+	cs.Stub("") // git remote add
 
 	output, err := RunCommand(repoForkCmd, "repo fork --clone OWNER/REPO")
 	if err != nil {
@@ -167,18 +184,12 @@ func TestRepoFork_outside_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	eq(t, strings.Join(seenCmd.Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[0].Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C repo remote add upstream https://github.com/OWNER/REPO.git")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Cloned fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Cloned fork")
 }
 
 func TestRepoFork_outside_survey_yes(t *testing.T) {
@@ -186,11 +197,11 @@ func TestRepoFork_outside_survey_yes(t *testing.T) {
 	http := initFakeHTTP()
 	defer http.StubWithFixture(200, "forkResult.json")()
 
-	var seenCmd *exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
-		seenCmd = cmd
-		return &test.OutputStub{}
-	})()
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+	cs.Stub("") // git remote add
 
 	oldConfirm := Confirm
 	Confirm = func(_ string, result *bool) error {
@@ -206,18 +217,12 @@ func TestRepoFork_outside_survey_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	eq(t, strings.Join(seenCmd.Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[0].Args, " "), "git clone https://github.com/someone/repo.git")
+	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C repo remote add upstream https://github.com/OWNER/REPO.git")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Cloned fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Cloned fork")
 }
 
 func TestRepoFork_outside_survey_no(t *testing.T) {
@@ -226,7 +231,7 @@ func TestRepoFork_outside_survey_no(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	cmdRun := false
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		cmdRun = true
 		return &test.OutputStub{}
 	})()
@@ -262,7 +267,7 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	var seenCmds []*exec.Cmd
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmds = append(seenCmds, cmd)
 		return &test.OutputStub{}
 	})()
@@ -280,8 +285,8 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 	}
 
 	expectedCmds := []string{
-		"git remote add -f fork https://github.com/someone/repo.git",
-		"git fetch fork",
+		"git remote rename origin upstream",
+		"git remote add -f origin https://github.com/someone/repo.git",
 	}
 
 	for x, cmd := range seenCmds {
@@ -290,16 +295,10 @@ func TestRepoFork_in_parent_survey_yes(t *testing.T) {
 
 	eq(t, output.Stderr(), "")
 
-	expectedLines := []*regexp.Regexp{
-		regexp.MustCompile(`Created fork someone/REPO`),
-		regexp.MustCompile(`Remote added at fork`),
-	}
-	for _, r := range expectedLines {
-		if !r.MatchString(output.String()) {
-			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
-			return
-		}
-	}
+	test.ExpectLines(t, output.String(),
+		"Created fork someone/REPO",
+		"Renamed origin remote to upstream",
+		"Added remote origin")
 }
 
 func TestRepoFork_in_parent_survey_no(t *testing.T) {
@@ -310,7 +309,7 @@ func TestRepoFork_in_parent_survey_no(t *testing.T) {
 	defer http.StubWithFixture(200, "forkResult.json")()
 
 	cmdRun := false
-	defer utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	defer run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		cmdRun = true
 		return &test.OutputStub{}
 	})()
@@ -367,12 +366,17 @@ func TestRepoClone(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			var seenCmd *exec.Cmd
-			restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
-				seenCmd = cmd
-				return &test.OutputStub{}
-			})
-			defer restoreCmd()
+			http := initFakeHTTP()
+			http.StubResponse(200, bytes.NewBufferString(`
+			{ "data": { "repository": {
+				"parent": null
+			} } }
+			`))
+
+			cs, restore := test.InitCmdStubber()
+			defer restore()
+
+			cs.Stub("") // git clone
 
 			output, err := RunCommand(repoCloneCmd, tt.args)
 			if err != nil {
@@ -381,15 +385,38 @@ func TestRepoClone(t *testing.T) {
 
 			eq(t, output.String(), "")
 			eq(t, output.Stderr(), "")
-
-			if seenCmd == nil {
-				t.Fatal("expected a command to run")
-			}
-			eq(t, strings.Join(seenCmd.Args, " "), tt.want)
+			eq(t, cs.Count, 1)
+			eq(t, strings.Join(cs.Calls[0].Args, " "), tt.want)
 		})
 	}
 }
 
+func TestRepoClone_hasParent(t *testing.T) {
+	http := initFakeHTTP()
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": {
+		"parent": {
+			"owner": {"login": "hubot"},
+			"name": "ORIG"
+		}
+	} } }
+	`))
+
+	cs, restore := test.InitCmdStubber()
+	defer restore()
+
+	cs.Stub("") // git clone
+	cs.Stub("") // git remote add
+
+	_, err := RunCommand(repoCloneCmd, "repo clone OWNER/REPO")
+	if err != nil {
+		t.Fatalf("error running command `repo clone`: %v", err)
+	}
+
+	eq(t, cs.Count, 2)
+	eq(t, strings.Join(cs.Calls[1].Args, " "), "git -C REPO remote add upstream https://github.com/hubot/ORIG.git")
+}
+
 func TestRepoCreate(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")
@@ -408,7 +435,7 @@ func TestRepoCreate(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -473,7 +500,7 @@ func TestRepoCreate_org(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -538,7 +565,7 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
@@ -580,8 +607,7 @@ func TestRepoCreate_orgWithTeam(t *testing.T) {
 	}
 }
 
-
-func TestRepoView(t *testing.T) {
+func TestRepoView_web(t *testing.T) {
 	initBlankContext("OWNER/REPO", "master")
 	http := initFakeHTTP()
 	http.StubRepoResponse("OWNER", "REPO")
@@ -590,13 +616,13 @@ func TestRepoView(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(repoViewCmd, "repo view")
+	output, err := RunCommand(repoViewCmd, "repo view -w")
 	if err != nil {
 		t.Errorf("error running command `repo view`: %v", err)
 	}
@@ -611,7 +637,7 @@ func TestRepoView(t *testing.T) {
 	eq(t, url, "https://github.com/OWNER/REPO")
 }
 
-func TestRepoView_ownerRepo(t *testing.T) {
+func TestRepoView_web_ownerRepo(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")
 	initContext = func() context.Context {
@@ -623,13 +649,13 @@ func TestRepoView_ownerRepo(t *testing.T) {
 	`))
 
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(repoViewCmd, "repo view cli/cli")
+	output, err := RunCommand(repoViewCmd, "repo view -w cli/cli")
 	if err != nil {
 		t.Errorf("error running command `repo view`: %v", err)
 	}
@@ -644,7 +670,7 @@ func TestRepoView_ownerRepo(t *testing.T) {
 	eq(t, url, "https://github.com/cli/cli")
 }
 
-func TestRepoView_fullURL(t *testing.T) {
+func TestRepoView_web_fullURL(t *testing.T) {
 	ctx := context.NewBlank()
 	ctx.SetBranch("master")
 	initContext = func() context.Context {
@@ -655,13 +681,13 @@ func TestRepoView_fullURL(t *testing.T) {
 	{ }
 	`))
 	var seenCmd *exec.Cmd
-	restoreCmd := utils.SetPrepareCmd(func(cmd *exec.Cmd) utils.Runnable {
+	restoreCmd := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
 		seenCmd = cmd
 		return &test.OutputStub{}
 	})
 	defer restoreCmd()
 
-	output, err := RunCommand(repoViewCmd, "repo view https://github.com/cli/cli")
+	output, err := RunCommand(repoViewCmd, "repo view -w https://github.com/cli/cli")
 	if err != nil {
 		t.Errorf("error running command `repo view`: %v", err)
 	}
@@ -675,3 +701,77 @@ func TestRepoView_fullURL(t *testing.T) {
 	url := seenCmd.Args[len(seenCmd.Args)-1]
 	eq(t, url, "https://github.com/cli/cli")
 }
+
+func TestRepoView(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": {
+				"repository": {
+		      "description": "social distancing"
+		}}}
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "name": "readme.md",
+		  "content": "IyB0cnVseSBjb29sIHJlYWRtZSBjaGVjayBpdCBvdXQ="}
+	`))
+
+	output, err := RunCommand(repoViewCmd, "repo view")
+	if err != nil {
+		t.Errorf("error running command `repo view`: %v", err)
+	}
+
+	test.ExpectLines(t, output.String(),
+		"OWNER/REPO",
+		"social distancing",
+		"truly cool readme",
+		"View this repository on GitHub: https://github.com/OWNER/REPO")
+
+}
+
+func TestRepoView_nonmarkdown_readme(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "data": {
+				"repository": {
+		      "description": "social distancing"
+		}}}
+	`))
+	http.StubResponse(200, bytes.NewBufferString(`
+		{ "name": "readme.org",
+		  "content": "IyB0cnVseSBjb29sIHJlYWRtZSBjaGVjayBpdCBvdXQ="}
+	`))
+
+	output, err := RunCommand(repoViewCmd, "repo view")
+	if err != nil {
+		t.Errorf("error running command `repo view`: %v", err)
+	}
+
+	test.ExpectLines(t, output.String(),
+		"OWNER/REPO",
+		"social distancing",
+		"# truly cool readme",
+		"View this repository on GitHub: https://github.com/OWNER/REPO")
+}
+
+func TestRepoView_blanks(t *testing.T) {
+	initBlankContext("OWNER/REPO", "master")
+	http := initFakeHTTP()
+	http.StubRepoResponse("OWNER", "REPO")
+	http.StubResponse(200, bytes.NewBufferString("{}"))
+	http.StubResponse(200, bytes.NewBufferString("{}"))
+
+	output, err := RunCommand(repoViewCmd, "repo view")
+	if err != nil {
+		t.Errorf("error running command `repo view`: %v", err)
+	}
+
+	test.ExpectLines(t, output.String(),
+		"OWNER/REPO",
+		"No description provided",
+		"No README provided",
+		"View this repository on GitHub: https://github.com/OWNER/REPO")
+}
diff --git a/command/testing.go b/command/testing.go
index 0221ce8cf..8ab97fc81 100644
--- a/command/testing.go
+++ b/command/testing.go
@@ -3,7 +3,6 @@ package command
 import (
 	"errors"
 	"fmt"
-	"os/exec"
 	"reflect"
 
 	"github.com/AlecAivazis/survey/v2"
@@ -11,43 +10,8 @@ import (
 
 	"github.com/cli/cli/api"
 	"github.com/cli/cli/context"
-	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
-// TODO this is split between here and test/helpers.go. I did that because otherwise our test
-// package would have to import utils (for utils.Runnable) which felt wrong. while utils_test
-// currently doesn't import test helpers, i don't see why that ought to be precluded.
-// I'm wondering if this is a case for having a global package just for storing Interfaces.
-type CmdStubber struct {
-	Stubs []*test.OutputStub
-	Count int
-	Calls []*exec.Cmd
-}
-
-func initCmdStubber() (*CmdStubber, func()) {
-	cs := CmdStubber{}
-	teardown := utils.SetPrepareCmd(createStubbedPrepareCmd(&cs))
-	return &cs, teardown
-}
-
-func (cs *CmdStubber) Stub(desiredOutput string) {
-	// TODO maybe have some kind of command mapping but going simple for now
-	cs.Stubs = append(cs.Stubs, &test.OutputStub{[]byte(desiredOutput)})
-}
-
-func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) utils.Runnable {
-	return func(cmd *exec.Cmd) utils.Runnable {
-		cs.Calls = append(cs.Calls, cmd)
-		call := cs.Count
-		cs.Count += 1
-		if call >= len(cs.Stubs) {
-			panic(fmt.Sprintf("more execs than stubs. most recent call: %v", cmd))
-		}
-		return cs.Stubs[call]
-	}
-}
-
 type askStubber struct {
 	Asks  [][]*survey.Question
 	Count int
diff --git a/context/context.go b/context/context.go
index 6c3bd5aee..eb1ace0eb 100644
--- a/context/context.go
+++ b/context/context.go
@@ -51,7 +51,10 @@ func ResolveRemotesToRepos(remotes Remotes, client *api.Client, base string) (Re
 		repos = append(repos, baseOverride)
 	}
 
-	result := ResolvedRemotes{Remotes: remotes}
+	result := ResolvedRemotes{
+		Remotes:   remotes,
+		apiClient: client,
+	}
 	if hasBaseOverride {
 		result.BaseOverride = baseOverride
 	}
@@ -67,6 +70,7 @@ type ResolvedRemotes struct {
 	BaseOverride ghrepo.Interface
 	Remotes      Remotes
 	Network      api.RepoNetworkResult
+	apiClient    *api.Client
 }
 
 // BaseRepo is the first found repository in the "upstream", "github", "origin"
@@ -95,8 +99,30 @@ func (r ResolvedRemotes) BaseRepo() (*api.Repository, error) {
 	return nil, errors.New("not found")
 }
 
-// HeadRepo is the first found repository that has push access
+// HeadRepo is a fork of base repo (if any), or the first found repository that
+// has push access
 func (r ResolvedRemotes) HeadRepo() (*api.Repository, error) {
+	baseRepo, err := r.BaseRepo()
+	if err != nil {
+		return nil, err
+	}
+
+	// try to find a pushable fork among existing remotes
+	for _, repo := range r.Network.Repositories {
+		if repo != nil && repo.Parent != nil && repo.ViewerCanPush() && ghrepo.IsSame(repo.Parent, baseRepo) {
+			return repo, nil
+		}
+	}
+
+	// a fork might still exist on GitHub, so let's query for it
+	var notFound *api.NotFoundError
+	if repo, err := api.RepoFindFork(r.apiClient, baseRepo); err == nil {
+		return repo, nil
+	} else if !errors.As(err, &notFound) {
+		return nil, err
+	}
+
+	// fall back to any listed repository that has push access
 	for _, repo := range r.Network.Repositories {
 		if repo != nil && repo.ViewerCanPush() {
 			return repo, nil
@@ -184,7 +210,7 @@ func (c *fsContext) Branch() (string, error) {
 
 	currentBranch, err := git.CurrentBranch()
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("could not determine current branch: %w", err)
 	}
 
 	c.branch = currentBranch
diff --git a/context/remote_test.go b/context/remote_test.go
index 04ccbc56c..5c3c46bc7 100644
--- a/context/remote_test.go
+++ b/context/remote_test.go
@@ -1,6 +1,7 @@
 package context
 
 import (
+	"bytes"
 	"errors"
 	"net/url"
 	"testing"
@@ -61,6 +62,14 @@ func Test_translateRemotes(t *testing.T) {
 }
 
 func Test_resolvedRemotes_triangularSetup(t *testing.T) {
+	http := &api.FakeHTTP{}
+	apiClient := api.NewClient(api.ReplaceTripper(http))
+
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+	] } } } }
+	`))
+
 	resolved := ResolvedRemotes{
 		BaseOverride: nil,
 		Remotes: Remotes{
@@ -89,6 +98,7 @@ func Test_resolvedRemotes_triangularSetup(t *testing.T) {
 				},
 			},
 		},
+		apiClient: apiClient,
 	}
 
 	baseRepo, err := resolved.BaseRepo()
@@ -118,6 +128,53 @@ func Test_resolvedRemotes_triangularSetup(t *testing.T) {
 	}
 }
 
+func Test_resolvedRemotes_forkLookup(t *testing.T) {
+	http := &api.FakeHTTP{}
+	apiClient := api.NewClient(api.ReplaceTripper(http))
+
+	http.StubResponse(200, bytes.NewBufferString(`
+	{ "data": { "repository": { "forks": { "nodes": [
+		{ "id": "FORKID",
+		  "url": "https://github.com/FORKOWNER/REPO",
+		  "name": "REPO",
+		  "owner": { "login": "FORKOWNER" },
+		  "viewerPermission": "WRITE"
+		}
+	] } } } }
+	`))
+
+	resolved := ResolvedRemotes{
+		BaseOverride: nil,
+		Remotes: Remotes{
+			&Remote{
+				Remote: &git.Remote{Name: "origin"},
+				Owner:  "OWNER",
+				Repo:   "REPO",
+			},
+		},
+		Network: api.RepoNetworkResult{
+			Repositories: []*api.Repository{
+				&api.Repository{
+					Name:             "NEWNAME",
+					Owner:            api.RepositoryOwner{Login: "NEWOWNER"},
+					ViewerPermission: "READ",
+				},
+			},
+		},
+		apiClient: apiClient,
+	}
+
+	headRepo, err := resolved.HeadRepo()
+	if err != nil {
+		t.Fatalf("got %v", err)
+	}
+	eq(t, ghrepo.FullName(headRepo), "FORKOWNER/REPO")
+	_, err = resolved.RemoteForRepo(headRepo)
+	if err == nil {
+		t.Fatal("expected to not find a matching remote")
+	}
+}
+
 func Test_resolvedRemotes_clonedFork(t *testing.T) {
 	resolved := ResolvedRemotes{
 		BaseOverride: nil,
diff --git a/git/git.go b/git/git.go
index 37253462a..360917eab 100644
--- a/git/git.go
+++ b/git/git.go
@@ -10,36 +10,77 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/cli/cli/utils"
+	"github.com/cli/cli/internal/run"
 )
 
-func VerifyRef(ref string) bool {
-	showRef := exec.Command("git", "show-ref", "--verify", "--quiet", ref)
-	err := utils.PrepareCmd(showRef).Run()
-	return err == nil
+// Ref represents a git commit reference
+type Ref struct {
+	Hash string
+	Name string
+}
+
+// TrackingRef represents a ref for a remote tracking branch
+type TrackingRef struct {
+	RemoteName string
+	BranchName string
+}
+
+func (r TrackingRef) String() string {
+	return "refs/remotes/" + r.RemoteName + "/" + r.BranchName
+}
+
+// ShowRefs resolves fully-qualified refs to commit hashes
+func ShowRefs(ref ...string) ([]Ref, error) {
+	args := append([]string{"show-ref", "--verify", "--"}, ref...)
+	showRef := exec.Command("git", args...)
+	output, err := run.PrepareCmd(showRef).Output()
+
+	var refs []Ref
+	for _, line := range outputLines(output) {
+		parts := strings.SplitN(line, " ", 2)
+		if len(parts) < 2 {
+			continue
+		}
+		refs = append(refs, Ref{
+			Hash: parts[0],
+			Name: parts[1],
+		})
+	}
+
+	return refs, err
 }
 
 // CurrentBranch reads the checked-out branch for the git repository
 func CurrentBranch() (string, error) {
-	// we avoid using `git branch --show-current` for compatibility with git < 2.22
-	branchCmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
-	output, err := utils.PrepareCmd(branchCmd).Output()
-	branchName := firstLine(output)
-	if err == nil && branchName == "HEAD" {
-		return "", errors.New("git: not on any branch")
+	refCmd := GitCommand("symbolic-ref", "--quiet", "--short", "HEAD")
+
+	output, err := run.PrepareCmd(refCmd).Output()
+	if err == nil {
+		// Found the branch name
+		return firstLine(output), nil
 	}
-	return branchName, err
+
+	var cmdErr *run.CmdError
+	if errors.As(err, &cmdErr) {
+		if cmdErr.Stderr.Len() == 0 {
+			// Detached head
+			return "", errors.New("git: not on any branch")
+		}
+	}
+
+	// Unknown error
+	return "", err
 }
 
 func listRemotes() ([]string, error) {
 	remoteCmd := exec.Command("git", "remote", "-v")
-	output, err := utils.PrepareCmd(remoteCmd).Output()
+	output, err := run.PrepareCmd(remoteCmd).Output()
 	return outputLines(output), err
 }
 
 func Config(name string) (string, error) {
 	configCmd := exec.Command("git", "config", name)
-	output, err := utils.PrepareCmd(configCmd).Output()
+	output, err := run.PrepareCmd(configCmd).Output()
 	if err != nil {
 		return "", fmt.Errorf("unknown config key: %s", name)
 	}
@@ -54,7 +95,7 @@ var GitCommand = func(args ...string) *exec.Cmd {
 
 func UncommittedChangeCount() (int, error) {
 	statusCmd := GitCommand("status", "--porcelain")
-	output, err := utils.PrepareCmd(statusCmd).Output()
+	output, err := run.PrepareCmd(statusCmd).Output()
 	if err != nil {
 		return 0, err
 	}
@@ -81,7 +122,7 @@ func Commits(baseRef, headRef string) ([]*Commit, error) {
 		"-c", "log.ShowSignature=false",
 		"log", "--pretty=format:%H,%s",
 		"--cherry", fmt.Sprintf("%s...%s", baseRef, headRef))
-	output, err := utils.PrepareCmd(logCmd).Output()
+	output, err := run.PrepareCmd(logCmd).Output()
 	if err != nil {
 		return []*Commit{}, err
 	}
@@ -109,7 +150,7 @@ func Commits(baseRef, headRef string) ([]*Commit, error) {
 
 func CommitBody(sha string) (string, error) {
 	showCmd := GitCommand("-c", "log.ShowSignature=false", "show", "-s", "--pretty=format:%b", sha)
-	output, err := utils.PrepareCmd(showCmd).Output()
+	output, err := run.PrepareCmd(showCmd).Output()
 	if err != nil {
 		return "", err
 	}
@@ -121,7 +162,7 @@ func Push(remote string, ref string) error {
 	pushCmd := GitCommand("push", "--set-upstream", remote, ref)
 	pushCmd.Stdout = os.Stdout
 	pushCmd.Stderr = os.Stderr
-	return utils.PrepareCmd(pushCmd).Run()
+	return run.PrepareCmd(pushCmd).Run()
 }
 
 type BranchConfig struct {
@@ -134,7 +175,7 @@ type BranchConfig struct {
 func ReadBranchConfig(branch string) (cfg BranchConfig) {
 	prefix := regexp.QuoteMeta(fmt.Sprintf("branch.%s.", branch))
 	configCmd := GitCommand("config", "--get-regexp", fmt.Sprintf("^%s(remote|merge)$", prefix))
-	output, err := utils.PrepareCmd(configCmd).Output()
+	output, err := run.PrepareCmd(configCmd).Output()
 	if err != nil {
 		return
 	}
@@ -152,7 +193,7 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 					continue
 				}
 				cfg.RemoteURL = u
-			} else {
+			} else if !isFilesystemPath(parts[1]) {
 				cfg.RemoteName = parts[1]
 			}
 		case "merge":
@@ -162,10 +203,14 @@ func ReadBranchConfig(branch string) (cfg BranchConfig) {
 	return
 }
 
+func isFilesystemPath(p string) bool {
+	return p == "." || strings.HasPrefix(p, "./") || strings.HasPrefix(p, "/")
+}
+
 // ToplevelDir returns the top-level directory path of the current repository
 func ToplevelDir() (string, error) {
 	showCmd := exec.Command("git", "rev-parse", "--show-toplevel")
-	output, err := utils.PrepareCmd(showCmd).Output()
+	output, err := run.PrepareCmd(showCmd).Output()
 	return firstLine(output), err
 
 }
diff --git a/git/git_test.go b/git/git_test.go
index 9e3f9a333..b73104c95 100644
--- a/git/git_test.go
+++ b/git/git_test.go
@@ -4,8 +4,8 @@ import (
 	"os/exec"
 	"testing"
 
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/test"
-	"github.com/cli/cli/utils"
 )
 
 func Test_UncommittedChangeCount(t *testing.T) {
@@ -20,14 +20,14 @@ func Test_UncommittedChangeCount(t *testing.T) {
 		c{Label: "untracked file", Expected: 2, Output: " M poem.txt\n?? new.txt"},
 	}
 
-	teardown := utils.SetPrepareCmd(func(*exec.Cmd) utils.Runnable {
+	teardown := run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
 		return &test.OutputStub{}
 	})
 	defer teardown()
 
 	for _, v := range cases {
-		_ = utils.SetPrepareCmd(func(*exec.Cmd) utils.Runnable {
-			return &test.OutputStub{[]byte(v.Output)}
+		_ = run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
+			return &test.OutputStub{[]byte(v.Output), nil}
 		})
 		ucc, _ := UncommittedChangeCount()
 
@@ -36,3 +36,62 @@ func Test_UncommittedChangeCount(t *testing.T) {
 		}
 	}
 }
+
+func Test_CurrentBranch(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	expected := "branch-name"
+
+	cs.Stub(expected)
+
+	result, err := CurrentBranch()
+	if err != nil {
+		t.Errorf("got unexpected error: %w", err)
+	}
+	if len(cs.Calls) != 1 {
+		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
+	}
+	if result != expected {
+		t.Errorf("unexpected branch name: %s instead of %s", result, expected)
+	}
+}
+
+func Test_CurrentBranch_detached_head(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	cs.StubError("")
+
+	_, err := CurrentBranch()
+	if err == nil {
+		t.Errorf("expected an error")
+	}
+	expectedError := "git: not on any branch"
+	if err.Error() != expectedError {
+		t.Errorf("got unexpected error: %s instead of %s", err.Error(), expectedError)
+	}
+	if len(cs.Calls) != 1 {
+		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
+	}
+}
+
+func Test_CurrentBranch_unexpected_error(t *testing.T) {
+	cs, teardown := test.InitCmdStubber()
+	defer teardown()
+
+	cs.StubError("lol")
+
+	expectedError := "lol\nstub: lol"
+
+	_, err := CurrentBranch()
+	if err == nil {
+		t.Errorf("expected an error")
+	}
+	if err.Error() != expectedError {
+		t.Errorf("got unexpected error: %s instead of %s", err.Error(), expectedError)
+	}
+	if len(cs.Calls) != 1 {
+		t.Errorf("expected 1 git call, saw %d", len(cs.Calls))
+	}
+}
diff --git a/git/remote.go b/git/remote.go
index f98606a2e..6c8608da9 100644
--- a/git/remote.go
+++ b/git/remote.go
@@ -6,7 +6,7 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/cli/cli/utils"
+	"github.com/cli/cli/internal/run"
 )
 
 var remoteRE = regexp.MustCompile(`(.+)\s+(.+)\s+\((push|fetch)\)`)
@@ -71,34 +71,22 @@ func parseRemotes(gitRemotes []string) (remotes RemoteSet) {
 	return
 }
 
-// AddRemote adds a new git remote. The initURL is the remote URL with which the
-// automatic fetch is made and finalURL, if non-blank, is set as the remote URL
-// after the fetch.
-func AddRemote(name, initURL, finalURL string) (*Remote, error) {
-	addCmd := exec.Command("git", "remote", "add", "-f", name, initURL)
-	err := utils.PrepareCmd(addCmd).Run()
+// AddRemote adds a new git remote and auto-fetches objects from it
+func AddRemote(name, u string) (*Remote, error) {
+	addCmd := exec.Command("git", "remote", "add", "-f", name, u)
+	err := run.PrepareCmd(addCmd).Run()
 	if err != nil {
 		return nil, err
 	}
 
-	if finalURL == "" {
-		finalURL = initURL
-	} else {
-		setCmd := exec.Command("git", "remote", "set-url", name, finalURL)
-		err := utils.PrepareCmd(setCmd).Run()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	finalURLParsed, err := url.Parse(finalURL)
+	urlParsed, err := url.Parse(u)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Remote{
 		Name:     name,
-		FetchURL: finalURLParsed,
-		PushURL:  finalURLParsed,
+		FetchURL: urlParsed,
+		PushURL:  urlParsed,
 	}, nil
 }
diff --git a/go.mod b/go.mod
index 0d0afa834..896bfd300 100644
--- a/go.mod
+++ b/go.mod
@@ -17,6 +17,8 @@ require (
 	github.com/mattn/go-runewidth v0.0.8 // indirect
 	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b
 	github.com/mitchellh/go-homedir v1.1.0
+	github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0
+	github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f // indirect
 	github.com/spf13/cobra v0.0.6
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.4.0 // indirect
diff --git a/go.sum b/go.sum
index 816dc7102..40379e814 100644
--- a/go.sum
+++ b/go.sum
@@ -58,6 +58,7 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfU
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
@@ -146,6 +147,10 @@ github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0 h1:T9uus1QvcPgeLShS30YOnnzk3r9Vvygp45muhlrufgY=
+github.com/shurcooL/githubv4 v0.0.0-20191127044304-8f68eb5628d0/go.mod h1:hAF0iLZy4td2EX+/8Tw+4nodhlMrwN3HupfaXj3zkGo=
+github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f h1:tygelZueB1EtXkPI6mQ4o9DQ0+FKW41hTbunoXZCTqk=
+github.com/shurcooL/graphql v0.0.0-20181231061246-d48a9a75455f/go.mod h1:AuYgA5Kyo4c7HfUmvRGs/6rGlMMV/6B1bVnB9JxJEEg=
 github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
@@ -196,6 +201,7 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20200219183655-46282727080f h1:dB42wwhNuwPvh8f+5zZWNcU+F2Xs/B9wXXwvUCOH7r8=
 golang.org/x/net v0.0.0-20200219183655-46282727080f/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be h1:vEDujvNQGv4jgYKudGeI/+DAX4Jffq6hpD55MmoEvKs=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -221,6 +227,7 @@ golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+google.golang.org/appengine v1.1.0 h1:igQkv0AAhEIvTEpD5LIpAfav2eeVO9HBTjvKHVJPRSs=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
diff --git a/internal/ghrepo/repo.go b/internal/ghrepo/repo.go
index f683d9249..a4bfa82d6 100644
--- a/internal/ghrepo/repo.go
+++ b/internal/ghrepo/repo.go
@@ -8,21 +8,26 @@ import (
 
 const defaultHostname = "github.com"
 
+// Interface describes an object that represents a GitHub repository
 type Interface interface {
 	RepoName() string
 	RepoOwner() string
 }
 
+// New instantiates a GitHub repository from owner and name arguments
 func New(owner, repo string) Interface {
 	return &ghRepo{
 		owner: owner,
 		name:  repo,
 	}
 }
+
+// FullName serializes a GitHub repository into an "OWNER/REPO" string
 func FullName(r Interface) string {
 	return fmt.Sprintf("%s/%s", r.RepoOwner(), r.RepoName())
 }
 
+// FromFullName extracts the GitHub repository inforation from an "OWNER/REPO" string
 func FromFullName(nwo string) Interface {
 	var r ghRepo
 	parts := strings.SplitN(nwo, "/", 2)
@@ -32,8 +37,9 @@ func FromFullName(nwo string) Interface {
 	return &r
 }
 
+// FromURL extracts the GitHub repository information from a URL
 func FromURL(u *url.URL) (Interface, error) {
-	if !strings.EqualFold(u.Hostname(), defaultHostname) {
+	if !strings.EqualFold(u.Hostname(), defaultHostname) && !strings.EqualFold(u.Hostname(), "www."+defaultHostname) {
 		return nil, fmt.Errorf("unsupported hostname: %s", u.Hostname())
 	}
 	parts := strings.SplitN(strings.TrimPrefix(u.Path, "/"), "/", 3)
@@ -43,6 +49,7 @@ func FromURL(u *url.URL) (Interface, error) {
 	return New(parts[0], strings.TrimSuffix(parts[1], ".git")), nil
 }
 
+// IsSame compares two GitHub repositories
 func IsSame(a, b Interface) bool {
 	return strings.EqualFold(a.RepoOwner(), b.RepoOwner()) &&
 		strings.EqualFold(a.RepoName(), b.RepoName())
diff --git a/internal/ghrepo/repo_test.go b/internal/ghrepo/repo_test.go
index 6ff775c84..fef04fb8c 100644
--- a/internal/ghrepo/repo_test.go
+++ b/internal/ghrepo/repo_test.go
@@ -1,40 +1,66 @@
 package ghrepo
 
 import (
+	"errors"
+	"fmt"
 	"net/url"
 	"testing"
 )
 
 func Test_repoFromURL(t *testing.T) {
-	u, _ := url.Parse("http://github.com/monalisa/octo-cat.git")
-	repo, err := FromURL(u)
-	if err != nil {
-		t.Fatalf("got error %q", err)
+	tests := []struct {
+		name   string
+		input  string
+		result string
+		err    error
+	}{
+		{
+			name:   "github.com URL",
+			input:  "https://github.com/monalisa/octo-cat.git",
+			result: "monalisa/octo-cat",
+			err:    nil,
+		},
+		{
+			name:   "www.github.com URL",
+			input:  "http://www.GITHUB.com/monalisa/octo-cat.git",
+			result: "monalisa/octo-cat",
+			err:    nil,
+		},
+		{
+			name:   "unsupported hostname",
+			input:  "https://example.com/one/two",
+			result: "",
+			err:    errors.New("unsupported hostname: example.com"),
+		},
+		{
+			name:   "filesystem path",
+			input:  "/path/to/file",
+			result: "",
+			err:    errors.New("unsupported hostname: "),
+		},
 	}
-	if repo.RepoOwner() != "monalisa" {
-		t.Errorf("got owner %q", repo.RepoOwner())
-	}
-	if repo.RepoName() != "octo-cat" {
-		t.Errorf("got name %q", repo.RepoName())
-	}
-}
 
-func Test_repoFromURL_invalid(t *testing.T) {
-	cases := [][]string{
-		[]string{
-			"https://example.com/one/two",
-			"unsupported hostname: example.com",
-		},
-		[]string{
-			"/path/to/disk",
-			"unsupported hostname: ",
-		},
-	}
-	for _, c := range cases {
-		u, _ := url.Parse(c[0])
-		_, err := FromURL(u)
-		if err == nil || err.Error() != c[1] {
-			t.Errorf("got %q", err)
-		}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			u, err := url.Parse(tt.input)
+			if err != nil {
+				t.Fatalf("got error %q", err)
+			}
+
+			repo, err := FromURL(u)
+			if err != nil {
+				if tt.err == nil {
+					t.Fatalf("got error %q", err)
+				} else if tt.err.Error() == err.Error() {
+					return
+				}
+				t.Fatalf("got error %q", err)
+			}
+
+			got := fmt.Sprintf("%s/%s", repo.RepoOwner(), repo.RepoName())
+			if tt.result != got {
+				t.Errorf("expected %q, got %q", tt.result, got)
+			}
+		})
 	}
 }
diff --git a/utils/prepare_cmd.go b/internal/run/run.go
similarity index 99%
rename from utils/prepare_cmd.go
rename to internal/run/run.go
index 6b354cb80..67de76fa2 100644
--- a/utils/prepare_cmd.go
+++ b/internal/run/run.go
@@ -1,4 +1,4 @@
-package utils
+package run
 
 import (
 	"bytes"
diff --git a/test/helpers.go b/test/helpers.go
index 6bcfcadca..556b27157 100644
--- a/test/helpers.go
+++ b/test/helpers.go
@@ -1,76 +1,80 @@
 package test
 
 import (
+	"bytes"
+	"errors"
 	"fmt"
-	"io/ioutil"
-	"os"
 	"os/exec"
-	"path/filepath"
+	"regexp"
+	"testing"
+
+	"github.com/cli/cli/internal/run"
 )
 
 // OutputStub implements a simple utils.Runnable
 type OutputStub struct {
-	Out []byte
+	Out   []byte
+	Error error
 }
 
 func (s OutputStub) Output() ([]byte, error) {
+	if s.Error != nil {
+		return s.Out, s.Error
+	}
 	return s.Out, nil
 }
 
 func (s OutputStub) Run() error {
+	if s.Error != nil {
+		return s.Error
+	}
 	return nil
 }
 
-type TempGitRepo struct {
-	Remote   string
-	TearDown func()
+type CmdStubber struct {
+	Stubs []*OutputStub
+	Count int
+	Calls []*exec.Cmd
 }
 
-func UseTempGitRepo() *TempGitRepo {
-	pwd, _ := os.Getwd()
-	oldEnv := make(map[string]string)
-	overrideEnv := func(name, value string) {
-		oldEnv[name] = os.Getenv(name)
-		os.Setenv(name, value)
-	}
-
-	remotePath := filepath.Join(pwd, "..", "test", "fixtures", "test.git")
-	home, err := ioutil.TempDir("", "test-repo")
-	if err != nil {
-		panic(err)
-	}
-
-	overrideEnv("HOME", home)
-	overrideEnv("XDG_CONFIG_HOME", "")
-	overrideEnv("XDG_CONFIG_DIRS", "")
-
-	targetPath := filepath.Join(home, "test.git")
-	cmd := exec.Command("git", "clone", remotePath, targetPath)
-	if output, err := cmd.Output(); err != nil {
-		panic(fmt.Errorf("error running %s\n%s\n%s", cmd, err, output))
-	}
-
-	if err = os.Chdir(targetPath); err != nil {
-		panic(err)
-	}
-
-	// Our libs expect the origin to be a github url
-	cmd = exec.Command("git", "remote", "set-url", "origin", "https://github.com/github/FAKE-GITHUB-REPO-NAME")
-	if output, err := cmd.Output(); err != nil {
-		panic(fmt.Errorf("error running %s\n%s\n%s", cmd, err, output))
-	}
-
-	tearDown := func() {
-		if err := os.Chdir(pwd); err != nil {
-			panic(err)
-		}
-		for name, value := range oldEnv {
-			os.Setenv(name, value)
-		}
-		if err = os.RemoveAll(home); err != nil {
-			panic(err)
-		}
-	}
-
-	return &TempGitRepo{Remote: remotePath, TearDown: tearDown}
+func InitCmdStubber() (*CmdStubber, func()) {
+	cs := CmdStubber{}
+	teardown := run.SetPrepareCmd(createStubbedPrepareCmd(&cs))
+	return &cs, teardown
+}
+
+func (cs *CmdStubber) Stub(desiredOutput string) {
+	// TODO maybe have some kind of command mapping but going simple for now
+	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte(desiredOutput), nil})
+}
+
+func (cs *CmdStubber) StubError(errText string) {
+	// TODO support error types beyond CmdError
+	stderrBuff := bytes.NewBufferString(errText)
+	args := []string{"stub"} // TODO make more real?
+	err := errors.New(errText)
+	cs.Stubs = append(cs.Stubs, &OutputStub{[]byte{}, &run.CmdError{stderrBuff, args, err}})
+}
+
+func createStubbedPrepareCmd(cs *CmdStubber) func(*exec.Cmd) run.Runnable {
+	return func(cmd *exec.Cmd) run.Runnable {
+		cs.Calls = append(cs.Calls, cmd)
+		call := cs.Count
+		cs.Count += 1
+		if call >= len(cs.Stubs) {
+			panic(fmt.Sprintf("more execs than stubs. most recent call: %v", cmd))
+		}
+		return cs.Stubs[call]
+	}
+}
+
+func ExpectLines(t *testing.T, output string, lines ...string) {
+	var r *regexp.Regexp
+	for _, l := range lines {
+		r = regexp.MustCompile(l)
+		if !r.MatchString(output) {
+			t.Errorf("output did not match regexp /%s/\n> output\n%s\n", r, output)
+			return
+		}
+	}
 }
diff --git a/utils/utils.go b/utils/utils.go
index 8a0e79a44..5c221bfa3 100644
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/briandowns/spinner"
 	"github.com/charmbracelet/glamour"
+	"github.com/cli/cli/internal/run"
 	"github.com/cli/cli/pkg/browser"
 )
 
@@ -17,7 +18,7 @@ func OpenInBrowser(url string) error {
 	if err != nil {
 		return err
 	}
-	return PrepareCmd(browseCmd).Run()
+	return run.PrepareCmd(browseCmd).Run()
 }
 
 func RenderMarkdown(text string) (string, error) {