diff --git a/pkg/reconciler/pipelinerun/pipelinerun_test.go b/pkg/reconciler/pipelinerun/pipelinerun_test.go
index 5b0d7a30174..a8e392249ed 100644
--- a/pkg/reconciler/pipelinerun/pipelinerun_test.go
+++ b/pkg/reconciler/pipelinerun/pipelinerun_test.go
@@ -343,7 +343,7 @@ func TestReconcile_PipelineSpecTaskSpec(t *testing.T) {
 		tb.TaskRunLabel("tekton.dev/pipeline", "test-pipeline"),
 		tb.TaskRunLabel("tekton.dev/pipelineRun", "test-pipeline-run-success"),
 		tb.TaskRunLabel(pipeline.GroupName+pipeline.PipelineTaskLabelKey, "unit-test-task-spec"),
-		tb.TaskRunSpec(tb.TaskRunTaskSpec(tb.Step("mystep", "myimage"))),
+		tb.TaskRunSpec(tb.TaskRunTaskSpec(tb.Step("myimage", tb.StepName("mystep")))),
 	)
 
 	// ignore IgnoreUnexported ignore both after and before steps fields
@@ -1610,7 +1610,7 @@ func makeExpectedTr(condName, ccName string, labels map[string]string) *v1alpha1
 		tb.TaskRunAnnotation("PipelineRunAnnotation", "PipelineRunValue"),
 		tb.TaskRunSpec(
 			tb.TaskRunTaskSpec(
-				tb.Step("condition-check-"+condName, "foo", tb.StepArgs("bar")),
+				tb.Step("foo", tb.StepName("condition-check-"+condName), tb.StepArgs("bar")),
 				tb.TaskInputs(),
 			),
 			tb.TaskRunServiceAccountName("test-sa"),
diff --git a/pkg/reconciler/taskrun/taskrun_test.go b/pkg/reconciler/taskrun/taskrun_test.go
index 61e910a467e..a1ae1271b36 100644
--- a/pkg/reconciler/taskrun/taskrun_test.go
+++ b/pkg/reconciler/taskrun/taskrun_test.go
@@ -85,7 +85,7 @@ var (
 	cloudEventTarget1 = "https://foo"
 	cloudEventTarget2 = "https://bar"
 
-	simpleStep  = tb.Step("simple-step", "foo", tb.StepCommand("/mycmd"))
+	simpleStep  = tb.Step("foo", tb.StepName("simple-step"), tb.StepCommand("/mycmd"))
 	simpleTask  = tb.Task("test-task", "foo", tb.TaskSpec(simpleStep))
 	clustertask = tb.ClusterTask("test-cluster-task", tb.ClusterTaskSpec(simpleStep))
 
@@ -97,7 +97,7 @@ var (
 		tb.TaskOutputs(tb.OutputsResource(gitResource.Name, v1alpha1.PipelineResourceTypeGit)),
 	))
 
-	saTask = tb.Task("test-with-sa", "foo", tb.TaskSpec(tb.Step("sa-step", "foo", tb.StepCommand("/mycmd"))))
+	saTask = tb.Task("test-with-sa", "foo", tb.TaskSpec(tb.Step("foo", tb.StepName("sa-step"), tb.StepCommand("/mycmd"))))
 
 	templatedTask = tb.Task("test-task-with-substitution", "foo", tb.TaskSpec(
 		tb.TaskInputs(
@@ -107,13 +107,13 @@ var (
 			tb.InputsParamSpec("configmapname", v1alpha1.ParamTypeString),
 		),
 		tb.TaskOutputs(tb.OutputsResource("myimage", v1alpha1.PipelineResourceTypeImage)),
-		tb.Step("mycontainer", "myimage", tb.StepCommand("/mycmd"), tb.StepArgs(
+		tb.Step("myimage", tb.StepName("mycontainer"), tb.StepCommand("/mycmd"), tb.StepArgs(
 			"--my-arg=$(inputs.params.myarg)",
 			"--my-arg-with-default=$(inputs.params.myarghasdefault)",
 			"--my-arg-with-default2=$(inputs.params.myarghasdefault2)",
 			"--my-additional-arg=$(outputs.resources.myimage.url)",
 		)),
-		tb.Step("myothercontainer", "myotherimage", tb.StepCommand("/mycmd"), tb.StepArgs(
+		tb.Step("myotherimage", tb.StepName("myothercontainer"), tb.StepCommand("/mycmd"), tb.StepArgs(
 			"--my-other-arg=$(inputs.resources.workspace.url)",
 		)),
 		tb.TaskVolume("volume-configmap", tb.VolumeSource(corev1.VolumeSource{
@@ -461,7 +461,7 @@ func TestReconcile(t *testing.T) {
 				tb.InputsResource("workspace", v1alpha1.PipelineResourceTypeGit),
 				tb.InputsParamSpec("myarg", v1alpha1.ParamTypeString, tb.ParamSpecDefault("mydefault")),
 			),
-			tb.Step("mycontainer", "myimage", tb.StepCommand("/mycmd"),
+			tb.Step("myimage", tb.StepName("mycontainer"), tb.StepCommand("/mycmd"),
 				tb.StepArgs("--my-arg=$(inputs.params.myarg)"),
 			),
 		),
@@ -483,7 +483,7 @@ func TestReconcile(t *testing.T) {
 		tb.TaskRunTaskSpec(
 			tb.TaskInputs(
 				tb.InputsResource("workspace", v1alpha1.PipelineResourceTypeGit)),
-			tb.Step("mystep", "ubuntu", tb.StepCommand("/mycmd")),
+			tb.Step("ubuntu", tb.StepName("mystep"), tb.StepCommand("/mycmd")),
 		),
 	))
 
diff --git a/pkg/reconciler/taskrun/validate_resources_test.go b/pkg/reconciler/taskrun/validate_resources_test.go
index 8341f0d7b3e..10550360a09 100644
--- a/pkg/reconciler/taskrun/validate_resources_test.go
+++ b/pkg/reconciler/taskrun/validate_resources_test.go
@@ -28,7 +28,7 @@ import (
 func TestValidateResolvedTaskResources_ValidResources(t *testing.T) {
 	rtr := tb.ResolvedTaskResources(
 		tb.ResolvedTaskResourcesTaskSpec(
-			tb.Step("mystep", "myimage", tb.StepCommand("mycmd")),
+			tb.Step("myimage", tb.StepCommand("mycmd")),
 			tb.TaskInputs(
 				tb.InputsResource("resource-to-build", v1alpha1.PipelineResourceTypeGit),
 				tb.InputsResource("optional-resource-to-build", v1alpha1.PipelineResourceTypeGit, tb.ResourceOptional(true)),
@@ -59,7 +59,7 @@ func TestValidateResolvedTaskResources_ValidResources(t *testing.T) {
 
 func TestValidateResolvedTaskResources_ValidParams(t *testing.T) {
 	rtr := tb.ResolvedTaskResources(tb.ResolvedTaskResourcesTaskSpec(
-		tb.Step("mystep", "myimage", tb.StepCommand("mycmd")),
+		tb.Step("myimage", tb.StepCommand("mycmd")),
 		tb.TaskInputs(tb.InputsParamSpec("foo", v1alpha1.ParamTypeString), tb.InputsParamSpec("bar", v1alpha1.ParamTypeString)),
 	))
 	p := []v1alpha1.Param{{
@@ -82,7 +82,7 @@ func TestValidateResolvedTaskResources_InvalidParams(t *testing.T) {
 	}{{
 		name: "missing-params",
 		rtr: tb.ResolvedTaskResources(tb.ResolvedTaskResourcesTaskSpec(
-			tb.Step("mystep", "myimage", tb.StepCommand("mycmd")),
+			tb.Step("myimage", tb.StepCommand("mycmd")),
 			tb.TaskInputs(tb.InputsParamSpec("foo", v1alpha1.ParamTypeString)),
 		)),
 		params: []v1alpha1.Param{{
@@ -92,7 +92,7 @@ func TestValidateResolvedTaskResources_InvalidParams(t *testing.T) {
 	}, {
 		name: "missing-params",
 		rtr: tb.ResolvedTaskResources(tb.ResolvedTaskResourcesTaskSpec(
-			tb.Step("mystep", "myimage", tb.StepCommand("mycmd")),
+			tb.Step("myimage", tb.StepCommand("mycmd")),
 			tb.TaskInputs(tb.InputsParamSpec("foo", v1alpha1.ParamTypeString)),
 		)),
 		params: []v1alpha1.Param{{
diff --git a/pkg/reconciler/timeout_handler_test.go b/pkg/reconciler/timeout_handler_test.go
index 2f55a0e0947..76dfaed429a 100644
--- a/pkg/reconciler/timeout_handler_test.go
+++ b/pkg/reconciler/timeout_handler_test.go
@@ -37,7 +37,7 @@ import (
 
 var (
 	testNs     = "foo"
-	simpleStep = tb.Step("simple-step", testNs, tb.StepCommand("/mycmd"))
+	simpleStep = tb.Step(testNs, tb.StepCommand("/mycmd"))
 	simpleTask = tb.Task("test-task", testNs, tb.TaskSpec(simpleStep))
 )
 
diff --git a/test/artifact_bucket_test.go b/test/artifact_bucket_test.go
index 5e2bb411bf3..0b93af0b35e 100644
--- a/test/artifact_bucket_test.go
+++ b/test/artifact_bucket_test.go
@@ -72,7 +72,7 @@ func TestStorageBucketPipelineRun(t *testing.T) {
 				SecretName: bucketSecretName,
 			},
 		})),
-		tb.Step("step1", "google/cloud-sdk:alpine",
+		tb.Step("google/cloud-sdk:alpine", tb.StepName("step1"),
 			tb.StepCommand("/bin/bash"),
 			tb.StepArgs("-c", fmt.Sprintf("gcloud auth activate-service-account --key-file /var/secret/bucket-secret/bucket-secret-key && gsutil mb gs://%s", bucketName)),
 			tb.StepVolumeMount("bucket-secret-volume", fmt.Sprintf("/var/secret/%s", bucketSecretName)),
@@ -132,10 +132,10 @@ func TestStorageBucketPipelineRun(t *testing.T) {
 	addFileTask := tb.Task(addFileTaskName, namespace, tb.TaskSpec(
 		tb.TaskInputs(tb.InputsResource(helloworldResourceName, v1alpha1.PipelineResourceTypeGit)),
 		tb.TaskOutputs(tb.OutputsResource(helloworldResourceName, v1alpha1.PipelineResourceTypeGit)),
-		tb.Step("addfile", "ubuntu", tb.StepCommand("/bin/bash"),
+		tb.Step("ubuntu", tb.StepName("addfile"), tb.StepCommand("/bin/bash"),
 			tb.StepArgs("-c", "'#!/bin/bash\necho hello' > /workspace/helloworldgit/newfile"),
 		),
-		tb.Step("make-executable", "ubuntu", tb.StepCommand("chmod"),
+		tb.Step("ubuntu", tb.StepName("make-executable"), tb.StepCommand("chmod"),
 			tb.StepArgs("+x", "/workspace/helloworldgit/newfile")),
 	))
 	if _, err := c.TaskClient.Create(addFileTask); err != nil {
@@ -145,7 +145,7 @@ func TestStorageBucketPipelineRun(t *testing.T) {
 	t.Logf("Creating Task %s", runFileTaskName)
 	readFileTask := tb.Task(runFileTaskName, namespace, tb.TaskSpec(
 		tb.TaskInputs(tb.InputsResource(helloworldResourceName, v1alpha1.PipelineResourceTypeGit)),
-		tb.Step("runfile", "ubuntu", tb.StepCommand("/workspace/helloworld/newfile")),
+		tb.Step("ubuntu", tb.StepName("runfile"), tb.StepCommand("/workspace/helloworld/newfile")),
 	))
 	if _, err := c.TaskClient.Create(readFileTask); err != nil {
 		t.Fatalf("Failed to create Task `%s`: %s", runFileTaskName, err)
@@ -238,7 +238,7 @@ func runTaskToDeleteBucket(c *clients, t *testing.T, namespace, bucketName, buck
 				SecretName: bucketSecretName,
 			},
 		})),
-		tb.Step("step1", "google/cloud-sdk:alpine",
+		tb.Step("google/cloud-sdk:alpine", tb.StepName("step1"),
 			tb.StepCommand("/bin/bash"),
 			tb.StepArgs("-c", fmt.Sprintf("gcloud auth activate-service-account --key-file /var/secret/bucket-secret/bucket-secret-key && gsutil rm -r gs://%s", bucketName)),
 			tb.StepVolumeMount("bucket-secret-volume", fmt.Sprintf("/var/secret/%s", bucketSecretName)),
diff --git a/test/builder/examples_test.go b/test/builder/examples_test.go
index a43ead56470..2cb8c86163f 100644
--- a/test/builder/examples_test.go
+++ b/test/builder/examples_test.go
@@ -29,10 +29,10 @@ var t *testing.T
 
 func ExampleTask() {
 	// You can declare re-usable modifiers
-	myStep := tb.Step("my-step", "myimage")
+	myStep := tb.Step("myimage")
 	// … and use them in a Task definition
 	myTask := tb.Task("my-task", "namespace", tb.TaskSpec(
-		tb.Step("simple-step", "myotherimage", tb.StepCommand("/mycmd")),
+		tb.Step("myotherimage", tb.StepCommand("/mycmd")),
 		myStep,
 	))
 	// … and another one.
@@ -58,7 +58,7 @@ func ExampleTask() {
 
 func ExampleClusterTask() {
 	myClusterTask := tb.ClusterTask("my-task", tb.ClusterTaskSpec(
-		tb.Step("simple-step", "myotherimage", tb.StepCommand("/mycmd")),
+		tb.Step("myotherimage", tb.StepCommand("/mycmd")),
 	))
 	expectedClusterTask := &v1alpha1.Task{
 		// […]
@@ -85,7 +85,7 @@ func ExampleTaskRun() {
 				tb.InputsResource("workspace", v1alpha1.PipelineResourceTypeGit),
 				tb.InputsParamSpec("myarg", v1alpha1.ParamTypeString, tb.ParamSpecDefault("mydefault")),
 			),
-			tb.Step("mycontainer", "myimage", tb.StepCommand("/mycmd"),
+			tb.Step("myimage", tb.StepCommand("/mycmd"),
 				tb.StepArgs("--my-arg=$(inputs.params.myarg)"),
 			),
 		),
diff --git a/test/builder/step.go b/test/builder/step.go
index 1ac47b16131..2905ce9de93 100644
--- a/test/builder/step.go
+++ b/test/builder/step.go
@@ -22,6 +22,13 @@ import (
 // StepOp is an operation which modifies a Container struct.
 type StepOp func(*v1alpha1.Step)
 
+// StepName sets the name of the step.
+func StepName(name string) StepOp {
+	return func(step *v1alpha1.Step) {
+		step.Name = name
+	}
+}
+
 // StepCommand sets the command to the Container (step in this case).
 func StepCommand(args ...string) StepOp {
 	return func(step *v1alpha1.Step) {
diff --git a/test/builder/task.go b/test/builder/task.go
index 0b12d46522e..61ac4986ed5 100644
--- a/test/builder/task.go
+++ b/test/builder/task.go
@@ -138,13 +138,12 @@ func TaskSpec(ops ...TaskSpecOp) TaskOp {
 
 // Step adds a step with the specified name and image to the TaskSpec.
 // Any number of Container modifier can be passed to transform it.
-func Step(name, image string, ops ...StepOp) TaskSpecOp {
+func Step(image string, ops ...StepOp) TaskSpecOp {
 	return func(spec *v1alpha1.TaskSpec) {
 		if spec.Steps == nil {
 			spec.Steps = []v1alpha1.Step{}
 		}
 		step := v1alpha1.Step{Container: corev1.Container{
-			Name:  name,
 			Image: image,
 		}}
 		for _, op := range ops {
diff --git a/test/builder/task_test.go b/test/builder/task_test.go
index 0557f623ac4..60970bdf739 100644
--- a/test/builder/task_test.go
+++ b/test/builder/task_test.go
@@ -52,10 +52,10 @@ func TestTask(t *testing.T) {
 			tb.OutputsResource("myotherimage", v1alpha1.PipelineResourceTypeImage),
 			tb.OutputsResource("myoptionalimage", v1alpha1.PipelineResourceTypeImage, tb.ResourceOptional(true)),
 		),
-		tb.Step("mycontainer", "myimage", tb.StepCommand("/mycmd"), tb.StepArgs(
+		tb.Step("myimage", tb.StepName("mycontainer"), tb.StepCommand("/mycmd"), tb.StepArgs(
 			"--my-other-arg=$(inputs.resources.workspace.url)",
 		)),
-		tb.Step("mycontainer2", "myimage2", tb.StepScript("echo foo")),
+		tb.Step("myimage2", tb.StepScript("echo foo")),
 		tb.TaskVolume("foo", tb.VolumeSource(corev1.VolumeSource{
 			HostPath: &corev1.HostPathVolumeSource{Path: "/foo/bar"},
 		})),
@@ -73,7 +73,6 @@ func TestTask(t *testing.T) {
 				Command: []string{"/mycmd"},
 				Args:    []string{"--my-other-arg=$(inputs.resources.workspace.url)"},
 			}}, {Script: "echo foo", Container: corev1.Container{
-				Name:  "mycontainer2",
 				Image: "myimage2",
 			}}},
 			Inputs: &v1alpha1.Inputs{
@@ -140,7 +139,7 @@ func TestTask(t *testing.T) {
 
 func TestClusterTask(t *testing.T) {
 	task := tb.ClusterTask("test-clustertask", tb.ClusterTaskSpec(
-		tb.Step("mycontainer", "myimage", tb.StepCommand("/mycmd"), tb.StepArgs(
+		tb.Step("myimage", tb.StepCommand("/mycmd"), tb.StepArgs(
 			"--my-other-arg=$(inputs.resources.workspace.url)",
 		)),
 	))
@@ -148,7 +147,6 @@ func TestClusterTask(t *testing.T) {
 		ObjectMeta: metav1.ObjectMeta{Name: "test-clustertask"},
 		Spec: v1alpha1.TaskSpec{
 			Steps: []v1alpha1.Step{{Container: corev1.Container{
-				Name:    "mycontainer",
 				Image:   "myimage",
 				Command: []string{"/mycmd"},
 				Args:    []string{"--my-other-arg=$(inputs.resources.workspace.url)"},
@@ -295,7 +293,7 @@ func TestTaskRunWithTaskRef(t *testing.T) {
 func TestTaskRunWithTaskSpec(t *testing.T) {
 	taskRun := tb.TaskRun("test-taskrun", "foo", tb.TaskRunSpec(
 		tb.TaskRunTaskSpec(
-			tb.Step("step", "image", tb.StepCommand("/mycmd")),
+			tb.Step("image", tb.StepCommand("/mycmd")),
 			tb.TaskInputs(tb.InputsResource("workspace", v1alpha1.PipelineResourceTypeGit, tb.ResourceOptional(true))),
 		),
 		tb.TaskRunServiceAccountName("sa"),
@@ -310,7 +308,6 @@ func TestTaskRunWithTaskSpec(t *testing.T) {
 		Spec: v1alpha1.TaskRunSpec{
 			TaskSpec: &v1alpha1.TaskSpec{
 				Steps: []v1alpha1.Step{{Container: corev1.Container{
-					Name:    "step",
 					Image:   "image",
 					Command: []string{"/mycmd"},
 				}}},
@@ -337,7 +334,7 @@ func TestTaskRunWithTaskSpec(t *testing.T) {
 func TestResolvedTaskResources(t *testing.T) {
 	resolvedTaskResources := tb.ResolvedTaskResources(
 		tb.ResolvedTaskResourcesTaskSpec(
-			tb.Step("step", "image", tb.StepCommand("/mycmd")),
+			tb.Step("image", tb.StepCommand("/mycmd")),
 		),
 		tb.ResolvedTaskResourcesInputs("foo", tb.PipelineResource("bar", "baz")),
 		tb.ResolvedTaskResourcesOutputs("qux", tb.PipelineResource("quux", "quuz")),
@@ -345,7 +342,6 @@ func TestResolvedTaskResources(t *testing.T) {
 	expectedResolvedTaskResources := &resources.ResolvedTaskResources{
 		TaskSpec: &v1alpha1.TaskSpec{
 			Steps: []v1alpha1.Step{{Container: corev1.Container{
-				Name:    "step",
 				Image:   "image",
 				Command: []string{"/mycmd"},
 			}}},
diff --git a/test/cancel_test.go b/test/cancel_test.go
index 9b8441e9aa5..b2568efe1a0 100644
--- a/test/cancel_test.go
+++ b/test/cancel_test.go
@@ -69,7 +69,7 @@ func TestTaskRunPipelineRunCancel(t *testing.T) {
 
 			t.Logf("Creating Task in namespace %s", namespace)
 			task := tb.Task("banana", namespace, tb.TaskSpec(
-				tb.Step("foo", "ubuntu", tb.StepCommand("/bin/bash"), tb.StepArgs("-c", "sleep 5000")),
+				tb.Step("ubuntu", tb.StepCommand("/bin/bash"), tb.StepArgs("-c", "sleep 5000")),
 			))
 			if _, err := c.TaskClient.Create(task); err != nil {
 				t.Fatalf("Failed to create Task `banana`: %s", err)
diff --git a/test/cluster_resource_test.go b/test/cluster_resource_test.go
index 5c5012243df..a35e2306b51 100644
--- a/test/cluster_resource_test.go
+++ b/test/cluster_resource_test.go
@@ -107,13 +107,14 @@ func getClusterResourceTask(namespace, name, configName string) *v1alpha1.Task {
 				},
 			},
 		})),
-		tb.Step("check-file-existence", "ubuntu",
+		tb.Step("ubuntu", tb.StepName("check-file-existence"),
 			tb.StepCommand("cat"), tb.StepArgs("/workspace/helloworld-cluster/kubeconfig"),
 		),
-		tb.Step("check-config-data", "ubuntu", tb.StepCommand("cat"), tb.StepArgs("/config/test.data"),
+		tb.Step("ubuntu", tb.StepName("check-config-data"),
+			tb.StepCommand("cat"), tb.StepArgs("/config/test.data"),
 			tb.StepVolumeMount("config-vol", "/config"),
 		),
-		tb.Step("check-contents", "ubuntu",
+		tb.Step("ubuntu", tb.StepName("check-contents"),
 			tb.StepCommand("bash"), tb.StepArgs("-c", "cmp -b /workspace/helloworld-cluster/kubeconfig /config/test.data"),
 			tb.StepVolumeMount("config-vol", "/config"),
 		),
diff --git a/test/dag_test.go b/test/dag_test.go
index 6da83e75ce4..0e23e2d34af 100644
--- a/test/dag_test.go
+++ b/test/dag_test.go
@@ -55,8 +55,8 @@ func TestDAGPipelineRun(t *testing.T) {
 			tb.InputsParamSpec("text", v1alpha1.ParamTypeString, tb.ParamSpecDescription("The text that should be echoed")),
 		),
 		tb.TaskOutputs(tb.OutputsResource("repo", v1alpha1.PipelineResourceTypeGit)),
-		tb.Step("echo-text", "busybox", tb.StepCommand("echo"), tb.StepArgs("$(inputs.params.text)")),
-		tb.Step("ln", "busybox", tb.StepCommand("ln"), tb.StepArgs("-s", "$(inputs.resources.repo.path)", "$(outputs.resources.repo.path)")),
+		tb.Step("busybox", tb.StepCommand("echo"), tb.StepArgs("$(inputs.params.text)")),
+		tb.Step("busybox", tb.StepCommand("ln"), tb.StepArgs("-s", "$(inputs.resources.repo.path)", "$(outputs.resources.repo.path)")),
 	))
 	if _, err := c.TaskClient.Create(echoTask); err != nil {
 		t.Fatalf("Failed to create echo Task: %s", err)
diff --git a/test/duplicate_test.go b/test/duplicate_test.go
index d8e6e2e3a7d..083dbf5cba1 100644
--- a/test/duplicate_test.go
+++ b/test/duplicate_test.go
@@ -44,7 +44,7 @@ func TestDuplicatePodTaskRun(t *testing.T) {
 		t.Logf("Creating taskrun %q.", taskrunName)
 
 		taskrun := tb.TaskRun(taskrunName, namespace, tb.TaskRunSpec(
-			tb.TaskRunTaskSpec(tb.Step("echo", "busybox",
+			tb.TaskRunTaskSpec(tb.Step("busybox",
 				tb.StepCommand("/bin/echo"),
 				tb.StepArgs("simple"),
 			)),
diff --git a/test/embed_test.go b/test/embed_test.go
index de83a6ad709..acd3af16926 100644
--- a/test/embed_test.go
+++ b/test/embed_test.go
@@ -65,11 +65,11 @@ func getEmbeddedTask(namespace string, args []string) *v1alpha1.Task {
 	return tb.Task(embedTaskName, namespace,
 		tb.TaskSpec(
 			tb.TaskInputs(tb.InputsResource("docs", v1alpha1.PipelineResourceTypeGit)),
-			tb.Step("read", "ubuntu",
+			tb.Step("ubuntu",
 				tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "cat /workspace/docs/LICENSE"),
 			),
-			tb.Step("helloworld-busybox", "busybox", tb.StepCommand(args...)),
+			tb.Step("busybox", tb.StepCommand(args...)),
 		))
 }
 
diff --git a/test/entrypoint_test.go b/test/entrypoint_test.go
index dcda1573ece..9f21ebe8314 100644
--- a/test/entrypoint_test.go
+++ b/test/entrypoint_test.go
@@ -43,8 +43,8 @@ func TestEntrypointRunningStepsInOrder(t *testing.T) {
 
 	t.Logf("Creating Task and TaskRun in namespace %s", namespace)
 	task := tb.Task(epTaskName, namespace, tb.TaskSpec(
-		tb.Step("step1", "ubuntu", tb.StepArgs("-c", "sleep 3 && touch foo")),
-		tb.Step("step2", "ubuntu", tb.StepArgs("-c", "ls", "foo")),
+		tb.Step("ubuntu", tb.StepArgs("-c", "sleep 3 && touch foo")),
+		tb.Step("ubuntu", tb.StepArgs("-c", "ls", "foo")),
 	))
 	if _, err := c.TaskClient.Create(task); err != nil {
 		t.Fatalf("Failed to create Task: %s", err)
diff --git a/test/git_checkout_test.go b/test/git_checkout_test.go
index 47fe736f9e9..bf81c2deb85 100644
--- a/test/git_checkout_test.go
+++ b/test/git_checkout_test.go
@@ -157,7 +157,7 @@ func getGitPipelineResource(namespace, revision string) *v1alpha1.PipelineResour
 func getGitCheckTask(namespace string) *v1alpha1.Task {
 	return tb.Task(gitTestTaskName, namespace, tb.TaskSpec(
 		tb.TaskInputs(tb.InputsResource("gitsource", v1alpha1.PipelineResourceTypeGit)),
-		tb.Step("git", "alpine/git", tb.StepArgs("--git-dir=/workspace/gitsource/.git", "show")),
+		tb.Step("alpine/git", tb.StepArgs("--git-dir=/workspace/gitsource/.git", "show")),
 	))
 }
 
diff --git a/test/helm_task_test.go b/test/helm_task_test.go
index 4fa8a6afb21..47cfe1802d1 100644
--- a/test/helm_task_test.go
+++ b/test/helm_task_test.go
@@ -157,7 +157,7 @@ func getCreateImageTask(namespace string) *v1alpha1.Task {
 	return tb.Task(createImageTaskName, namespace, tb.TaskSpec(
 		tb.TaskInputs(tb.InputsResource("gitsource", v1alpha1.PipelineResourceTypeGit)),
 		tb.TaskOutputs(tb.OutputsResource("builtimage", v1alpha1.PipelineResourceTypeImage)),
-		tb.Step("kaniko", "gcr.io/kaniko-project/executor:v0.15.0", tb.StepArgs(
+		tb.Step("gcr.io/kaniko-project/executor:v0.15.0", tb.StepName("kaniko"), tb.StepArgs(
 			"--dockerfile=/workspace/gitsource/test/gohelloworld/Dockerfile",
 			"--context=/workspace/gitsource/",
 			"--destination=$(outputs.resources.builtimage.url)",
@@ -173,8 +173,8 @@ func getHelmDeployTask(namespace string) *v1alpha1.Task {
 			tb.InputsParamSpec("pathToHelmCharts", v1alpha1.ParamTypeString, tb.ParamSpecDescription("Path to the helm charts")),
 			tb.InputsParamSpec("chartname", v1alpha1.ParamTypeString, tb.ParamSpecDefault("")),
 		),
-		tb.Step("helm-init", "alpine/helm:2.14.0", tb.StepArgs("init", "--wait")),
-		tb.Step("helm-deploy", "alpine/helm:2.14.0", tb.StepArgs(
+		tb.Step("alpine/helm:2.14.0", tb.StepArgs("init", "--wait")),
+		tb.Step("alpine/helm:2.14.0", tb.StepArgs(
 			"install",
 			"--debug",
 			"--name=$(inputs.params.chartname)",
@@ -305,7 +305,7 @@ func helmCleanup(c *clients, t *testing.T, namespace string) {
 func removeAllHelmReleases(c *clients, t *testing.T, namespace string) {
 	helmRemoveAllTaskName := "helm-remove-all-task"
 	helmRemoveAllTask := tb.Task(helmRemoveAllTaskName, namespace, tb.TaskSpec(
-		tb.Step("helm-remove-all", "alpine/helm:2.14.0", tb.StepCommand("/bin/sh"),
+		tb.Step("alpine/helm:2.14.0", tb.StepName("helm-remove-all"), tb.StepCommand("/bin/sh"),
 			tb.StepArgs("-c", "helm ls --short --all | xargs -n1 helm del --purge"),
 		),
 	))
@@ -334,7 +334,7 @@ func removeAllHelmReleases(c *clients, t *testing.T, namespace string) {
 func removeHelmFromCluster(c *clients, t *testing.T, namespace string) {
 	helmResetTaskName := "helm-reset-task"
 	helmResetTask := tb.Task(helmResetTaskName, namespace, tb.TaskSpec(
-		tb.Step("helm-reset", "alpine/helm:2.14.0", tb.StepArgs("reset", "--force")),
+		tb.Step("alpine/helm:2.14.0", tb.StepArgs("reset", "--force")),
 	))
 
 	helmResetTaskRunName := "helm-reset-taskrun"
diff --git a/test/kaniko_task_test.go b/test/kaniko_task_test.go
index 215af7ff160..bfacb7cb895 100644
--- a/test/kaniko_task_test.go
+++ b/test/kaniko_task_test.go
@@ -144,6 +144,7 @@ func getTask(repo, namespace string) *v1alpha1.Task {
 		tb.TaskOutputs(tb.OutputsResource("builtImage", v1alpha1.PipelineResourceTypeImage)),
 	}
 	stepOps := []tb.StepOp{
+		tb.StepName("kaniko"),
 		tb.StepArgs(
 			"--dockerfile=/workspace/gitsource/integration/dockerfiles/Dockerfile_test_label",
 			fmt.Sprintf("--destination=%s", repo),
@@ -155,7 +156,7 @@ func getTask(repo, namespace string) *v1alpha1.Task {
 		),
 		tb.StepSecurityContext(&corev1.SecurityContext{RunAsUser: &root}),
 	}
-	step := tb.Step("kaniko", "gcr.io/kaniko-project/executor:v0.15.0", stepOps...)
+	step := tb.Step("gcr.io/kaniko-project/executor:v0.15.0", stepOps...)
 	taskSpecOps = append(taskSpecOps, step)
 	sidecar := tb.Sidecar("registry", "registry")
 	taskSpecOps = append(taskSpecOps, sidecar)
diff --git a/test/pipelinerun_test.go b/test/pipelinerun_test.go
index e2b220d8e1e..575c67996ae 100644
--- a/test/pipelinerun_test.go
+++ b/test/pipelinerun_test.go
@@ -98,7 +98,7 @@ func TestPipelineRun(t *testing.T) {
 				tb.TaskInputs(tb.InputsParamSpec("path", v1alpha1.ParamTypeString),
 					tb.InputsParamSpec("dest", v1alpha1.ParamTypeString)),
 				// Reference build: https://github.com/knative/build/tree/master/test/docker-basic
-				tb.Step("config-docker", "quay.io/rhpipeline/skopeo:alpine",
+				tb.Step("quay.io/rhpipeline/skopeo:alpine", tb.StepName("config-docker"),
 					tb.StepCommand("skopeo"),
 					tb.StepArgs("copy", "$(inputs.params.path)", "$(inputs.params.dest)"),
 				),
@@ -125,7 +125,7 @@ func TestPipelineRun(t *testing.T) {
 			}
 
 			task := tb.Task(getName(taskName, index), namespace, tb.TaskSpec(
-				tb.Step("echo-hello", "ubuntu",
+				tb.Step("ubuntu",
 					tb.StepCommand("/bin/bash"),
 					tb.StepArgs("-c", "echo hello, world"),
 				),
@@ -247,30 +247,30 @@ func getFanInFanOutTasks(namespace string) []*v1alpha1.Task {
 				tb.ResourceTargetPath("brandnewspace"),
 			)),
 			tb.TaskOutputs(outWorkspaceResource),
-			tb.Step("write-data-task-0-step-0", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("write-data-task-0-step-0"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "echo stuff > $(outputs.resources.workspace.path)/stuff"),
 			),
-			tb.Step("write-data-task-0-step-1", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("write-data-task-0-step-1"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "echo other > $(outputs.resources.workspace.path)/other"),
 			),
 		)),
 		tb.Task("check-create-files-exists", namespace, tb.TaskSpec(
 			tb.TaskInputs(inWorkspaceResource),
 			tb.TaskOutputs(outWorkspaceResource),
-			tb.Step("read-from-task-0", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("read-from-task-0"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "[[ stuff == $(cat $(inputs.resources.workspace.path)/stuff) ]]"),
 			),
-			tb.Step("write-data-task-1", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("write-data-task-1"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "echo something > $(outputs.resources.workspace.path)/something"),
 			),
 		)),
 		tb.Task("check-create-files-exists-2", namespace, tb.TaskSpec(
 			tb.TaskInputs(inWorkspaceResource),
 			tb.TaskOutputs(outWorkspaceResource),
-			tb.Step("read-from-task-0", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("read-from-task-0"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "[[ other == $(cat $(inputs.resources.workspace.path)/other) ]]"),
 			),
-			tb.Step("write-data-task-1", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("write-data-task-1"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "echo else > $(outputs.resources.workspace.path)/else"),
 			),
 		)),
@@ -278,10 +278,10 @@ func getFanInFanOutTasks(namespace string) []*v1alpha1.Task {
 			tb.TaskInputs(tb.InputsResource("workspace", v1alpha1.PipelineResourceTypeGit,
 				tb.ResourceTargetPath("readingspace"),
 			)),
-			tb.Step("read-from-task-0", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("read-from-task-0"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "[[ something == $(cat $(inputs.resources.workspace.path)/something) ]]"),
 			),
-			tb.Step("read-from-task-1", "ubuntu", tb.StepCommand("/bin/bash"),
+			tb.Step("ubuntu", tb.StepName("read-from-task-1"), tb.StepCommand("/bin/bash"),
 				tb.StepArgs("-c", "[[ else == $(cat $(inputs.resources.workspace.path)/else) ]]"),
 			),
 		)),
diff --git a/test/sidecar_test.go b/test/sidecar_test.go
index b77ffc1fd51..e65ef9dfc7d 100644
--- a/test/sidecar_test.go
+++ b/test/sidecar_test.go
@@ -63,8 +63,8 @@ func TestSidecarTaskSupport(t *testing.T) {
 			task := tb.Task(sidecarTaskName, namespace,
 				tb.TaskSpec(
 					tb.Step(
-						primaryContainerName,
 						"busybox:1.31.0-musl",
+						tb.StepName(primaryContainerName),
 						tb.StepCommand(test.stepCommand...),
 					),
 					tb.Sidecar(
diff --git a/test/status_test.go b/test/status_test.go
index 6eaf1f37bd2..31cd8791c5a 100644
--- a/test/status_test.go
+++ b/test/status_test.go
@@ -37,7 +37,7 @@ func TestTaskRunPipelineRunStatus(t *testing.T) {
 
 	t.Logf("Creating Task and TaskRun in namespace %s", namespace)
 	task := tb.Task("banana", namespace, tb.TaskSpec(
-		tb.Step("foo", "busybox", tb.StepCommand("ls", "-la")),
+		tb.Step("busybox", tb.StepCommand("ls", "-la")),
 	))
 	if _, err := c.TaskClient.Create(task); err != nil {
 		t.Fatalf("Failed to create Task: %s", err)
diff --git a/test/taskrun_test.go b/test/taskrun_test.go
index 06306dce093..7ac7a7fbd50 100644
--- a/test/taskrun_test.go
+++ b/test/taskrun_test.go
@@ -42,13 +42,13 @@ func TestTaskRunFailure(t *testing.T) {
 
 	t.Logf("Creating Task and TaskRun in namespace %s", namespace)
 	task := tb.Task("failing-task", namespace, tb.TaskSpec(
-		tb.Step("hello", "busybox",
+		tb.Step("busybox",
 			tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "echo hello"),
 		),
-		tb.Step("exit", "busybox",
+		tb.Step("busybox",
 			tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "exit 1"),
 		),
-		tb.Step("world", "busybox",
+		tb.Step("busybox",
 			tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "sleep 30s"),
 		),
 	))
@@ -79,8 +79,8 @@ func TestTaskRunFailure(t *testing.T) {
 				Reason:   "Completed",
 			},
 		},
-		Name:          "hello",
-		ContainerName: "step-hello",
+		Name:          "unnamed-0",
+		ContainerName: "step-unnamed-0",
 	}, {
 		ContainerState: corev1.ContainerState{
 			Terminated: &corev1.ContainerStateTerminated{
@@ -88,8 +88,8 @@ func TestTaskRunFailure(t *testing.T) {
 				Reason:   "Error",
 			},
 		},
-		Name:          "exit",
-		ContainerName: "step-exit",
+		Name:          "unnamed-1",
+		ContainerName: "step-unnamed-1",
 	}, {
 		ContainerState: corev1.ContainerState{
 			Terminated: &corev1.ContainerStateTerminated{
@@ -97,8 +97,8 @@ func TestTaskRunFailure(t *testing.T) {
 				Reason:   "Error",
 			},
 		},
-		Name:          "world",
-		ContainerName: "step-world",
+		Name:          "unnamed-2",
+		ContainerName: "step-unnamed-2",
 	}}
 	ignoreTerminatedFields := cmpopts.IgnoreFields(corev1.ContainerStateTerminated{}, "StartedAt", "FinishedAt", "ContainerID")
 	ignoreStepFields := cmpopts.IgnoreFields(v1alpha1.StepState{}, "ImageID")
@@ -120,7 +120,7 @@ func TestTaskRunStatus(t *testing.T) {
 	t.Logf("Creating Task and TaskRun in namespace %s", namespace)
 	task := tb.Task("status-task", namespace, tb.TaskSpec(
 		// This was the digest of the latest tag as of 8/12/2019
-		tb.Step("hello", "busybox@sha256:895ab622e92e18d6b461d671081757af7dbaa3b00e3e28e12505af7817f73649",
+		tb.Step("busybox@sha256:895ab622e92e18d6b461d671081757af7dbaa3b00e3e28e12505af7817f73649",
 			tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "echo hello"),
 		),
 	))
@@ -151,8 +151,8 @@ func TestTaskRunStatus(t *testing.T) {
 				Reason:   "Completed",
 			},
 		},
-		Name:          "hello",
-		ContainerName: "step-hello",
+		Name:          "unnamed-0",
+		ContainerName: "step-unnamed-0",
 	}}
 
 	ignoreTerminatedFields := cmpopts.IgnoreFields(corev1.ContainerStateTerminated{}, "StartedAt", "FinishedAt", "ContainerID")
diff --git a/test/timeout_test.go b/test/timeout_test.go
index 8a984b605cb..292cad7d98a 100644
--- a/test/timeout_test.go
+++ b/test/timeout_test.go
@@ -45,7 +45,7 @@ func TestPipelineRunTimeout(t *testing.T) {
 
 	t.Logf("Creating Task in namespace %s", namespace)
 	task := tb.Task("banana", namespace, tb.TaskSpec(
-		tb.Step("foo", "busybox", tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "sleep 10"))))
+		tb.Step("busybox", tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "sleep 10"))))
 	if _, err := c.TaskClient.Create(task); err != nil {
 		t.Fatalf("Failed to create Task `%s`: %s", "banana", err)
 	}
@@ -191,7 +191,7 @@ func TestPipelineRunFailedAndRetry(t *testing.T) {
 
 	t.Logf("Creating Task in namespace %s", namespace)
 	task := tb.Task("banana", namespace, tb.TaskSpec(
-		tb.Step("foo", "busybox", tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "exit 1")),
+		tb.Step("busybox", tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "exit 1")),
 	))
 	if _, err := c.TaskClient.Create(task); err != nil {
 		t.Fatalf("Failed to create Task `%s`: %s", "banana", err)
@@ -243,7 +243,7 @@ func TestTaskRunTimeout(t *testing.T) {
 
 	t.Logf("Creating Task and TaskRun in namespace %s", namespace)
 	if _, err := c.TaskClient.Create(tb.Task("giraffe", namespace,
-		tb.TaskSpec(tb.Step("amazing-busybox", "busybox", tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "sleep 3000"))))); err != nil {
+		tb.TaskSpec(tb.Step("busybox", tb.StepCommand("/bin/sh"), tb.StepArgs("-c", "sleep 3000"))))); err != nil {
 		t.Fatalf("Failed to create Task `%s`: %s", "giraffe", err)
 	}
 	if _, err := c.TaskRunClient.Create(tb.TaskRun("run-giraffe", namespace, tb.TaskRunSpec(tb.TaskRunTaskRef("giraffe"),
diff --git a/test/workingdir_test.go b/test/workingdir_test.go
index 9681dfbe8e4..3c91beb42f0 100644
--- a/test/workingdir_test.go
+++ b/test/workingdir_test.go
@@ -41,7 +41,7 @@ func TestWorkingDirCreated(t *testing.T) {
 	defer tearDown(t, c, namespace)
 
 	task := tb.Task(wdTaskName, namespace, tb.TaskSpec(
-		tb.Step("step1", "ubuntu", tb.StepWorkingDir("/workspace/HELLOMOTO"), tb.StepArgs("-c", "echo YES")),
+		tb.Step("ubuntu", tb.StepWorkingDir("/workspace/HELLOMOTO"), tb.StepArgs("-c", "echo YES")),
 	))
 	if _, err := c.TaskClient.Create(task); err != nil {
 		t.Fatalf("Failed to create Task: %s", err)
@@ -95,7 +95,7 @@ func TestWorkingDirIgnoredNonSlashWorkspace(t *testing.T) {
 	defer tearDown(t, c, namespace)
 
 	task := tb.Task(wdTaskName, namespace, tb.TaskSpec(
-		tb.Step("step1", "ubuntu", tb.StepWorkingDir("/HELLOMOTO"), tb.StepArgs("-c", "echo YES")),
+		tb.Step("ubuntu", tb.StepWorkingDir("/HELLOMOTO"), tb.StepArgs("-c", "echo YES")),
 	))
 	if _, err := c.TaskClient.Create(task); err != nil {
 		t.Fatalf("Failed to create Task: %s", err)
diff --git a/test/workspace_test.go b/test/workspace_test.go
index 2756c9f232d..beb3b27dbea 100644
--- a/test/workspace_test.go
+++ b/test/workspace_test.go
@@ -38,7 +38,7 @@ func TestWorkspaceReadOnlyDisallowsWrite(t *testing.T) {
 	defer tearDown(t, c, namespace)
 
 	task := tb.Task(taskName, namespace, tb.TaskSpec(
-		tb.Step("attempt-write", "alpine", tb.StepScript("echo foo > /workspace/test/file")),
+		tb.Step("alpine", tb.StepScript("echo foo > /workspace/test/file")),
 		tb.TaskWorkspace("test", "test workspace", "/workspace/test", true),
 	))
 	if _, err := c.TaskClient.Create(task); err != nil {