diff --git a/CHANGELOG.md b/CHANGELOG.md
index cc7ed5de24..4cc6c72dc6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,8 @@ All notable changes to `src-cli` are documented in this file.
 
 ### Added
 
+- Starting with Sourcegraph 3.28.0 batch spec `steps` can contain an `if: <template string>` attribute that determines whether the given step will be executed. [#520](https://github.com/sourcegraph/src-cli/pull/520)
+
 ### Changed
 
 ### Fixed
diff --git a/cmd/src/batch_common.go b/cmd/src/batch_common.go
index e54662a1b8..50a44d5842 100644
--- a/cmd/src/batch_common.go
+++ b/cmd/src/batch_common.go
@@ -201,6 +201,7 @@ type executeBatchSpecOpts struct {
 // Sourcegraph, including execution as needed and applying the resulting batch
 // spec if specified.
 func executeBatchSpec(ctx context.Context, opts executeBatchSpecOpts) error {
+	batches.DebugOut = opts.out
 	svc := service.New(&service.Opts{
 		AllowUnsupported: opts.flags.allowUnsupported,
 		AllowIgnored:     opts.flags.allowIgnored,
@@ -285,11 +286,15 @@ func executeBatchSpec(ctx context.Context, opts executeBatchSpecOpts) error {
 	}
 
 	pending = batchCreatePending(opts.out, "Determining workspaces")
-	tasks, err := svc.BuildTasks(ctx, repos, batchSpec)
+	tb, err := executor.NewTaskBuilder(batchSpec, svc)
 	if err != nil {
-		return errors.Wrap(err, "Calculating execution plan")
+		return errors.Wrap(err, "Parsing batch spec to determine workspaces")
 	}
-	batchCompletePending(pending, fmt.Sprintf("Found %d workspaces", len(tasks)))
+	tasks, err := tb.BuildAll(ctx, repos)
+	if err != nil {
+		return err
+	}
+	batchCompletePending(pending, fmt.Sprintf("Found %d workspaces with steps to execute", len(tasks)))
 
 	execOpts := executor.Opts{
 		CacheDir:    opts.flags.cacheDir,
diff --git a/internal/batches/batch_spec.go b/internal/batches/batch_spec.go
index 22fe53d2c1..bcf32f159d 100644
--- a/internal/batches/batch_spec.go
+++ b/internal/batches/batch_spec.go
@@ -94,9 +94,25 @@ type Step struct {
 	Files     map[string]string `json:"files,omitempty" yaml:"files,omitempty"`
 	Outputs   Outputs           `json:"outputs,omitempty" yaml:"outputs,omitempty"`
 
+	If interface{} `json:"if,omitempty" yaml:"if,omitempty"`
+
 	image docker.Image
 }
 
+func (s *Step) IfCondition() string {
+	switch v := s.If.(type) {
+	case bool:
+		if v {
+			return "true"
+		}
+		return "false"
+	case string:
+		return v
+	default:
+		return ""
+	}
+}
+
 func (s *Step) SetImage(image docker.Image) {
 	s.image = image
 }
@@ -178,6 +194,17 @@ func ParseBatchSpec(data []byte, features FeatureFlags) (*BatchSpec, error) {
 		errs = multierror.Append(errs, errors.New("batch spec includes workspaces, which is not supported in this Sourcegraph version"))
 	}
 
+	if !features.AllowConditionalExec {
+		for i, step := range spec.Steps {
+			if step.IfCondition() != "" {
+				errs = multierror.Append(errs, fmt.Errorf(
+					"step %d in batch spec uses the 'if' attribute for conditional execution, which is not supported in this Sourcegraph version",
+					i+1,
+				))
+			}
+		}
+	}
+
 	return &spec, errs.ErrorOrNil()
 }
 
diff --git a/internal/batches/batch_spec_test.go b/internal/batches/batch_spec_test.go
index a13502ac4f..339871d318 100644
--- a/internal/batches/batch_spec_test.go
+++ b/internal/batches/batch_spec_test.go
@@ -1,6 +1,9 @@
 package batches
 
-import "testing"
+import (
+	"fmt"
+	"testing"
+)
 
 func TestParseBatchSpec(t *testing.T) {
 	t.Run("valid", func(t *testing.T) {
@@ -87,4 +90,84 @@ changesetTemplate:
 			t.Fatalf("wrong error. want=%q, have=%q", wantErr, haveErr)
 		}
 	})
+
+	t.Run("uses unsupported conditional exec", func(t *testing.T) {
+		const spec = `
+name: hello-world
+description: Add Hello World to READMEs
+on:
+  - repositoriesMatchingQuery: file:README.md
+steps:
+  - run: echo Hello World | tee -a $(find -name README.md)
+    if: "false"
+    container: alpine:3
+
+changesetTemplate:
+  title: Hello World
+  body: My first batch change!
+  branch: hello-world
+  commit:
+    message: Append Hello World to all README.md files
+  published: false
+`
+
+		_, err := ParseBatchSpec([]byte(spec), FeatureFlags{})
+		if err == nil {
+			t.Fatal("no error returned")
+		}
+
+		wantErr := `1 error occurred:
+	* step 1 in batch spec uses the 'if' attribute for conditional execution, which is not supported in this Sourcegraph version
+
+`
+		haveErr := err.Error()
+		if haveErr != wantErr {
+			t.Fatalf("wrong error. want=%q, have=%q", wantErr, haveErr)
+		}
+	})
+
+	t.Run("parsing if attribute", func(t *testing.T) {
+		const specTemplate = `
+name: hello-world
+description: Add Hello World to READMEs
+on:
+  - repositoriesMatchingQuery: file:README.md
+steps:
+  - run: echo Hello World | tee -a $(find -name README.md)
+    if: %s
+    container: alpine:3
+
+changesetTemplate:
+  title: Hello World
+  body: My first batch change!
+  branch: hello-world
+  commit:
+    message: Append Hello World to all README.md files
+  published: false
+`
+
+		for _, tt := range []struct {
+			raw  string
+			want string
+		}{
+			{raw: `"true"`, want: "true"},
+			{raw: `"false"`, want: "false"},
+			{raw: `true`, want: "true"},
+			{raw: `false`, want: "false"},
+			{raw: `"${{ foobar }}"`, want: "${{ foobar }}"},
+			{raw: `${{ foobar }}`, want: "${{ foobar }}"},
+			{raw: `foobar`, want: "foobar"},
+		} {
+			spec := fmt.Sprintf(specTemplate, tt.raw)
+			batchSpec, err := ParseBatchSpec([]byte(spec), FeatureFlags{AllowConditionalExec: true})
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			fmt.Printf("len(batchSpec.Steps)=%d", len(batchSpec.Steps))
+			if batchSpec.Steps[0].IfCondition() != tt.want {
+				t.Fatalf("wrong IfCondition. want=%q, got=%q", tt.want, batchSpec.Steps[0].IfCondition())
+			}
+		}
+	})
 }
diff --git a/internal/batches/debug.go b/internal/batches/debug.go
index a8eb696ecd..7fd55f51e5 100644
--- a/internal/batches/debug.go
+++ b/internal/batches/debug.go
@@ -1,6 +1,8 @@
 package batches
 
-import "github.com/sourcegraph/sourcegraph/lib/output"
+import (
+	"github.com/sourcegraph/sourcegraph/lib/output"
+)
 
 // DebugOut can be used to print debug messages in development to the TUI.
 // For that it needs to be set to an actual *output.Output.
diff --git a/internal/batches/executor/executor_test.go b/internal/batches/executor/executor_test.go
index 532c91e00d..56b060a4a3 100644
--- a/internal/batches/executor/executor_test.go
+++ b/internal/batches/executor/executor_test.go
@@ -305,7 +305,6 @@ output4=integration-test-batch-change`,
 			wantAuthorName:    "myOutputName1=main.go",
 			wantAuthorEmail:   "myOutputName1=main.go",
 		},
-
 		{
 			name: "workspaces",
 			archives: []mock.RepoArchive{
@@ -374,6 +373,40 @@ output4=integration-test-batch-change`,
 				},
 			},
 		},
+		{
+			name: "step condition",
+			archives: []mock.RepoArchive{
+				{Repo: srcCLIRepo, Files: map[string]string{
+					"README.md": "# Welcome to the README\n",
+				}},
+				{Repo: sourcegraphRepo, Files: map[string]string{
+					"README.md": "# Sourcegraph README\n",
+				}},
+			},
+			steps: []batches.Step{
+				{Run: `echo -e "foobar\n" >> README.md`},
+				{
+					Run: `echo "foobar" >> hello.txt`,
+					If:  `${{ matches repository.name "github.com/sourcegraph/sourcegra*" }}`,
+				},
+				{
+					Run: `echo "foobar" >> in-path.txt`,
+					If:  `${{ matches steps.path "sub/directory/of/repo" }}`,
+				},
+			},
+			tasks: []*Task{
+				{Repository: srcCLIRepo},
+				{Repository: sourcegraphRepo, Path: "sub/directory/of/repo"},
+			},
+			wantFilesChanged: filesByRepository{
+				srcCLIRepo.ID: filesByBranch{
+					changesetTemplateBranch: []string{"README.md"},
+				},
+				sourcegraphRepo.ID: {
+					changesetTemplateBranch: []string{"README.md", "hello.txt", "in-path.txt"},
+				},
+			},
+		},
 	}
 
 	for _, tc := range tests {
@@ -949,5 +982,6 @@ func featuresAllEnabled() batches.FeatureFlags {
 		UseGzipCompression:       true,
 		AllowTransformChanges:    true,
 		AllowWorkspaces:          true,
+		AllowConditionalExec:     true,
 	}
 }
diff --git a/internal/batches/executor/partial_eval.go b/internal/batches/executor/partial_eval.go
new file mode 100644
index 0000000000..36848fad5f
--- /dev/null
+++ b/internal/batches/executor/partial_eval.go
@@ -0,0 +1,383 @@
+package executor
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"text/template"
+	"text/template/parse"
+)
+
+// isStaticBool parses the input as a text/template and attempts to evaluate it
+// with only the ahead-of-execution information available in StepContext.
+//
+// To do that it first calls parseAndPartialEval to evaluate the template as
+// much as possible.
+//
+// If, after evaluation, more than text is left (i.e. because the template
+// requires information that's only available later) the function returns with
+// the first return value being false, because the template is not "static".
+// first return value is true.
+//
+// If only text is left we check whether that text equals "true". The result of
+// that check is the second return value.
+func isStaticBool(input string, ctx *StepContext) (isStatic bool, boolVal bool, err error) {
+	t, err := parseAndPartialEval(input, ctx)
+	if err != nil {
+		return false, false, err
+	}
+
+	isStatic = true
+	for _, n := range t.Tree.Root.Nodes {
+		if n.Type() != parse.NodeText {
+			isStatic = false
+			break
+		}
+	}
+	if !isStatic {
+		return isStatic, false, nil
+	}
+
+	return true, isTrueOutput(t.Tree.Root), nil
+}
+
+// parseAndPartialEval parses input as a text/template and then attempts to
+// partially evaluate the parts of the template it can evaluate ahead of time
+// (meaning: before we've executed any batch spec steps and have a full
+// StepContext available).
+//
+// If it's possible to evaluate a parse.ActionNode (which is what sits between
+// delimiters in a text/template), the node is rewritten into a parse.TextNode,
+// to make it look like it's always been text in the template.
+//
+// Partial evaluation is done in a best effort manner: if it's not possible to
+// evaluate a node (because it requires information that we only later get, or
+// because it's too complex, etc.) we degrade gracefully and simply abort the
+// partial evaluation and leave the node as is.
+//
+// It also should be noted that we don't do "full" partial evaluation: if we
+// come across value that we can't partially evaluate we abort the process *for
+// the whole node* without replacing the sub-nodes that we've successfully
+// evaluated. Why? Because we can't construct correct `*parse.Node` from
+// outside the `parse` package. In other words: we evaluate
+// all-parse.ActionNode-or-nothing.
+func parseAndPartialEval(input string, ctx *StepContext) (*template.Template, error) {
+	t, err := template.
+		New("partial-eval").
+		Delims(startDelim, endDelim).
+		Funcs(builtins).
+		Funcs(ctx.ToFuncMap()).
+		Parse(input)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for i, n := range t.Tree.Root.Nodes {
+		t.Tree.Root.Nodes[i] = rewriteNode(n, ctx)
+	}
+
+	return t, nil
+}
+
+// rewriteNode takes the given parse.Parse and tries to partially evaluate it.
+// If that's possible, the output of the evaluation is turned into text and
+// instead of the node that was passed in a new parse.TextNode is returned that
+// represents the output of the evaluation.
+func rewriteNode(n parse.Node, ctx *StepContext) parse.Node {
+	switch n := n.(type) {
+	case *parse.ActionNode:
+		if val, ok := evalPipe(ctx, n.Pipe); ok {
+			var out bytes.Buffer
+			fmt.Fprint(&out, val.Interface())
+			return &parse.TextNode{
+				Text:     out.Bytes(),
+				Pos:      n.Pos,
+				NodeType: parse.NodeText,
+			}
+		}
+
+		return n
+
+	default:
+		return n
+	}
+}
+
+// noValue is returned by the functions that partially evaluate a parse.Node
+// to signify that evaluation was not possible or did not yield a value.
+var noValue reflect.Value
+
+func evalPipe(ctx *StepContext, p *parse.PipeNode) (finalVal reflect.Value, ok bool) {
+	// If the pipe contains declaration we abort evaluation.
+	if len(p.Decl) > 0 {
+		return noValue, false
+	}
+
+	// TODO: Support finalVal
+	// finalVal is the value of the previous Cmd in a pipe (i.e. `${{ 3 + 3 | eq 6 }}`)
+	// It needs to be the final (fixed) argument of a call if it's set.
+
+	for _, c := range p.Cmds {
+		finalVal, ok = evalCmd(ctx, c, finalVal)
+		if !ok {
+			return noValue, false
+		}
+	}
+
+	return finalVal, ok
+}
+
+func evalCmd(ctx *StepContext, c *parse.CommandNode, previousValue reflect.Value) (reflect.Value, bool) {
+	switch first := c.Args[0].(type) {
+	case *parse.BoolNode, *parse.NumberNode, *parse.StringNode, *parse.ChainNode:
+		if len(c.Args) == 1 {
+			return evalNode(ctx, first)
+		}
+		return noValue, false
+
+	case *parse.IdentifierNode:
+		// A function call always starts with an identifier
+		return evalFunction(ctx, first, first.Ident, c.Args, previousValue)
+
+	default:
+		// Node type that we don't care about, so we don't even try to evaluate it
+		return noValue, false
+	}
+}
+
+func evalNode(ctx *StepContext, n parse.Node) (reflect.Value, bool) {
+	switch n := n.(type) {
+	case *parse.BoolNode:
+		return reflect.ValueOf(n.True), true
+
+	case *parse.NumberNode:
+		// This case branch is lifted from Go's text/template execution engine:
+		// https://sourcegraph.com/github.com/golang/go@2c9f5a1da823773c436f8b2c119635797d6db2d3/-/blob/src/text/template/exec.go#L493-530
+		// The difference is that we don't do any error handling but simply abort.
+		switch {
+		case n.IsComplex:
+			return reflect.ValueOf(n.Complex128), true
+
+		case n.IsFloat &&
+			!isHexInt(n.Text) && !isRuneInt(n.Text) &&
+			strings.ContainsAny(n.Text, ".eEpP"):
+			return reflect.ValueOf(n.Float64), true
+
+		case n.IsInt:
+			num := int(n.Int64)
+			if int64(num) != n.Int64 {
+				return noValue, false
+			}
+			return reflect.ValueOf(num), true
+
+		case n.IsUint:
+			return noValue, false
+		}
+
+	case *parse.StringNode:
+		return reflect.ValueOf(n.Text), true
+
+	case *parse.ChainNode:
+		// For now we only support fields that are 1 level deep (see below).
+		// Should we ever want to support more than one level, we need to
+		// revise this.
+		if len(n.Field) != 1 {
+			return noValue, false
+		}
+
+		if ident, ok := n.Node.(*parse.IdentifierNode); ok {
+			switch ident.Ident {
+			case "repository":
+				switch n.Field[0] {
+				case "search_result_paths":
+					// TODO: We don't eval search_result_paths for now, since it's a
+					// "complex" value, a slice of strings, and turning that
+					// into text might not be useful to the user. So we abort.
+					return noValue, false
+				case "name":
+					return reflect.ValueOf(ctx.Repository.Name), true
+				}
+
+			case "batch_change":
+				switch n.Field[0] {
+				case "name":
+					return reflect.ValueOf(ctx.BatchChange.Name), true
+				case "description":
+					return reflect.ValueOf(ctx.BatchChange.Description), true
+				}
+			}
+		}
+		return noValue, false
+
+	case *parse.PipeNode:
+		return evalPipe(ctx, n)
+	}
+
+	return noValue, false
+}
+
+func isRuneInt(s string) bool {
+	return len(s) > 0 && s[0] == '\''
+}
+
+func isHexInt(s string) bool {
+	return len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && !strings.ContainsAny(s, "pP")
+}
+
+func evalFunction(ctx *StepContext, fn *parse.IdentifierNode, name string, args []parse.Node, previousValue reflect.Value) (val reflect.Value, success bool) {
+	defer func() {
+		if r := recover(); r != nil {
+			val = noValue
+			success = false
+		}
+	}()
+
+	switch name {
+	case "eq":
+		return evalEqCall(ctx, args[1:])
+
+	case "ne":
+		equal, ok := evalEqCall(ctx, args[1:])
+		if !ok {
+			return noValue, false
+		}
+		return reflect.ValueOf(!equal.Bool()), true
+
+	case "not":
+		return evalNotCall(ctx, args[1:])
+
+	default:
+		concreteFn, ok := builtins[name]
+		if !ok {
+			return noValue, false
+		}
+
+		fn := reflect.ValueOf(concreteFn)
+
+		// We can eval only if all args are static:
+		var evaluatedArgs []reflect.Value
+		for _, a := range args[1:] {
+			v, ok := evalNode(ctx, a)
+			if !ok {
+				// One of the args is not static, abort
+				return noValue, false
+			}
+			evaluatedArgs = append(evaluatedArgs, v)
+
+		}
+
+		ret := fn.Call(evaluatedArgs)
+		if len(ret) == 2 && !ret[1].IsNil() {
+			return noValue, false
+		}
+		return ret[0], true
+	}
+}
+
+func evalNotCall(ctx *StepContext, args []parse.Node) (reflect.Value, bool) {
+	// We only support 1 arg for now:
+	if len(args) != 1 {
+		return noValue, false
+	}
+
+	arg, ok := evalNode(ctx, args[0])
+	if !ok {
+		return noValue, false
+	}
+
+	return reflect.ValueOf(!isTrue(arg)), true
+}
+
+func evalEqCall(ctx *StepContext, args []parse.Node) (reflect.Value, bool) {
+	// We only support 2 args for now:
+	if len(args) != 2 {
+		return noValue, false
+	}
+
+	// We only eval `eq` if all args are static:
+	var evaluatedArgs []reflect.Value
+	for _, a := range args {
+		v, ok := evalNode(ctx, a)
+		if !ok {
+			// One of the args is not static, abort
+			return noValue, false
+		}
+		evaluatedArgs = append(evaluatedArgs, v)
+	}
+
+	if len(evaluatedArgs) != 2 {
+		// safety check
+		return noValue, false
+	}
+
+	isEqual := evaluatedArgs[0].Interface() == evaluatedArgs[1].Interface()
+	return reflect.ValueOf(isEqual), true
+}
+
+// isTrue is taken from Go's text/template/exec.go and simplified
+func isTrue(val reflect.Value) (truth bool) {
+	if !val.IsValid() {
+		// Something like var x interface{}, never set. It's a form of nil.
+		return false
+	}
+	switch val.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return val.Len() > 0
+	case reflect.Bool:
+		return val.Bool()
+	case reflect.Complex64, reflect.Complex128:
+		return val.Complex() != 0
+	case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface:
+		return !val.IsNil()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return val.Int() != 0
+	case reflect.Float32, reflect.Float64:
+		return val.Float() != 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return val.Uint() != 0
+	case reflect.Struct:
+		return true // Struct values are always true.
+	default:
+		return false
+	}
+}
+
+// debugParseNode can be used to produce a debug-friendly version of a parse.Node.
+func debugParseNode(n parse.Node) string {
+	switch n := n.(type) {
+	case *parse.ActionNode:
+		return fmt.Sprintf("parse.ActionNode. n.Pipe=%#v", n.Pipe)
+
+	case *parse.IdentifierNode:
+		return fmt.Sprintf("parse.IdentifierNode: %+v", n)
+
+	case *parse.FieldNode:
+		return fmt.Sprintf("parse.FieldNode: %+v", n)
+
+	case *parse.ChainNode:
+		return fmt.Sprintf("parse.ChainNode. n.Node=(%s), chain.Field: %+v", debugParseNode(n.Node), n.Field)
+
+	case *parse.TextNode:
+		return fmt.Sprintf("parse.TextNode. n.Text=%q", n.Text)
+
+	case *parse.BoolNode:
+		return fmt.Sprintf("parse.BoolNode")
+
+	case *parse.CommandNode:
+		return fmt.Sprintf("parse.CommandNode")
+
+	case *parse.NilNode:
+		return fmt.Sprintf("parse.NilNode")
+
+	case *parse.NumberNode:
+		return fmt.Sprintf("parse.NumberNode")
+
+	case *parse.PipeNode:
+		return fmt.Sprintf("parse.PipeNode")
+
+	default:
+		return fmt.Sprintf("UNHANDLED parse.Node TYPE: %s", n.String())
+	}
+}
diff --git a/internal/batches/executor/partial_eval_test.go b/internal/batches/executor/partial_eval_test.go
new file mode 100644
index 0000000000..f6f9ba46ce
--- /dev/null
+++ b/internal/batches/executor/partial_eval_test.go
@@ -0,0 +1,295 @@
+package executor
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/sourcegraph/src-cli/internal/batches/graphql"
+)
+
+var partialEvalStepCtx = &StepContext{
+	BatchChange: BatchChangeAttributes{
+		Name:        "test-batch-change",
+		Description: "test-description",
+	},
+	// Step is not set when evalStepCondition is called
+	Repository: graphql.Repository{
+		Name: "github.com/sourcegraph/src-cli",
+		FileMatches: map[string]bool{
+			"README.md": true,
+			"main.go":   true,
+		},
+	},
+}
+
+func runParseAndPartialTest(t *testing.T, in, want string) {
+	t.Helper()
+
+	tmpl, err := parseAndPartialEval(in, partialEvalStepCtx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tmplStr := tmpl.Tree.Root.String()
+	if tmplStr != want {
+		t.Fatalf("wrong output:\n%s", cmp.Diff(want, tmplStr))
+	}
+}
+
+func TestParseAndPartialEval(t *testing.T) {
+	t.Run("evaluated", func(t *testing.T) {
+		for _, tt := range []struct{ input, want string }{
+			{
+				// Literal constants:
+				`this is my template ${{ "hardcoded string" }}`,
+				`this is my template hardcoded string`,
+			},
+			{
+				`${{ 1234 }}`,
+				`1234`,
+			},
+			{
+				`${{ true }} ${{ false }}`,
+				`true false`,
+			},
+			{
+				// Evaluated, since they're static values:
+				`${{ repository.name }} ${{ batch_change.name }} ${{ batch_change.description }}`,
+				`github.com/sourcegraph/src-cli test-batch-change test-description`,
+			},
+			{
+				`AAA${{ repository.name }}BBB${{ batch_change.name }}CCC${{ batch_change.description }}DDD`,
+				`AAAgithub.com/sourcegraph/src-cliBBBtest-batch-changeCCCtest-descriptionDDD`,
+			},
+			{
+				// Function call with static value and runtime value:
+				`${{ eq repository.name outputs.repo.name }}`,
+				// Aborts, since one of them is runtime value
+				`{{eq repository.name outputs.repo.name}}`,
+			},
+			{
+				// "eq" call with 2 static values:
+				`${{ eq repository.name "github.com/sourcegraph/src-cli" }}`,
+				`true`,
+			},
+			{
+				// "eq" call with 2 literal values:
+				`${{ eq 5 5 }}`,
+				`true`,
+			},
+			{
+				// "not" call:
+				`${{ not (eq repository.name "bitbucket-repo") }}`,
+				`true`,
+			},
+			{
+				// "not" call:
+				`${{ not 1234 }} ${{ not false }} ${{ not true }}`,
+				`false true false`,
+			},
+			{
+				// "ne" call with 2 static values:
+				`${{ ne repository.name "github.com/sourcegraph/src-cli" }}`,
+				`false`,
+			},
+			{
+				// "ne" call with 2 literal values:
+				`${{ ne 5 5 }}`,
+				`false`,
+			},
+			{
+				// Function call with builtin function and static values:
+				`${{ matches repository.name "github.com*" }}`,
+				`true`,
+			},
+			{
+				// Nested function call with builtin function and static values:
+				`${{ eq false (matches repository.name "github.com*") }}`,
+				`false`,
+			},
+			{
+				// Nested nested function call with builtin function and static values:
+				`${{ eq false (eq false (matches repository.name "github.com*")) }}`,
+				`true`,
+			},
+		} {
+			runParseAndPartialTest(t, tt.input, tt.want)
+		}
+	})
+
+	t.Run("aborted", func(t *testing.T) {
+		for _, tt := range []struct{ input, want string }{
+			{
+				// Field that doesn't exist
+				`${{ repository.secretlocation }}`,
+				`{{repository.secretlocation}}`,
+			},
+			{
+				// Field access that's too deep
+				`${{ repository.name.doesnotexist }}`,
+				`{{repository.name.doesnotexist}}`,
+			},
+			{
+				// Complex value
+				`${{ repository.search_result_paths }}`,
+				// String representation of templates uses standard delimiters
+				`{{repository.search_result_paths}}`,
+			},
+			{
+				// Runtime value
+				`${{ outputs.runtime.value }}`,
+				`{{outputs.runtime.value}}`,
+			},
+			{
+				// Runtime value
+				`${{ step.modified_files }}`,
+				`{{step.modified_files}}`,
+			},
+			{
+				// Runtime value
+				`${{ previous_step.modified_files }}`,
+				`{{previous_step.modified_files}}`,
+			},
+			{
+				// "eq" call with static value and runtime value:
+				`${{ eq repository.name outputs.repo.name }}`,
+				// Aborts, since one of them is runtime value
+				`{{eq repository.name outputs.repo.name}}`,
+			},
+			{
+				// "eq" call with more than 2 arguments:
+				`${{ eq repository.name "github.com/sourcegraph/src-cli" "github.com/sourcegraph/sourcegraph" }}`,
+				`{{eq repository.name "github.com/sourcegraph/src-cli" "github.com/sourcegraph/sourcegraph"}}`,
+			},
+			{
+				// Nested nested function call with builtin function but runtime values:
+				`${{ eq false (eq false (matches outputs.runtime.value "github.com*")) }}`,
+				`{{eq false (eq false (matches outputs.runtime.value "github.com*"))}}`,
+			},
+		} {
+			runParseAndPartialTest(t, tt.input, tt.want)
+		}
+	})
+}
+
+func TestParseAndPartialEval_BuiltinFunctions(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		for _, tt := range []struct{ input, want string }{
+			{
+				`${{ join (split repository.name "/") "-" }}`,
+				`github.com-sourcegraph-src-cli`,
+			},
+			{
+				`${{ split repository.name "/" "-" }}`,
+				`{{split repository.name "/" "-"}}`,
+			},
+			{
+				`${{ replace repository.name "github" "foobar" }}`,
+				`foobar.com/sourcegraph/src-cli`,
+			},
+			{
+				`${{ join_if "SEP" repository.name "postfix" }}`,
+				`github.com/sourcegraph/src-cliSEPpostfix`,
+			},
+			{
+				`${{ matches repository.name "github.com*" }}`,
+				`true`,
+			},
+		} {
+			runParseAndPartialTest(t, tt.input, tt.want)
+		}
+	})
+
+	t.Run("aborted", func(t *testing.T) {
+		for _, tt := range []struct{ input, want string }{
+			{
+				// Wrong argument type
+				`${{ join "foobar" "-" }}`,
+				`{{join "foobar" "-"}}`,
+			},
+			{
+				// Wrong argument count
+				`${{ join (split repository.name "/") "-" "too" "many" "args" }}`,
+				`{{join (split repository.name "/") "-" "too" "many" "args"}}`,
+			},
+		} {
+			runParseAndPartialTest(t, tt.input, tt.want)
+		}
+	})
+}
+
+func TestIsStaticBool(t *testing.T) {
+	tests := []struct {
+		name         string
+		template     string
+		wantIsStatic bool
+		wantBoolVal  bool
+	}{
+
+		{
+			name:         "true literal",
+			template:     `true`,
+			wantIsStatic: true,
+			wantBoolVal:  true,
+		},
+		{
+			name:         "false literal",
+			template:     `false`,
+			wantIsStatic: true,
+			wantBoolVal:  false,
+		},
+		{
+			name:         "static non bool value",
+			template:     `${{ repository.name }}`,
+			wantIsStatic: true,
+			wantBoolVal:  false,
+		},
+		{
+			name:         "function call true val",
+			template:     `${{ eq repository.name "github.com/sourcegraph/src-cli" }}`,
+			wantIsStatic: true,
+			wantBoolVal:  true,
+		},
+		{
+			name:         "function call false val",
+			template:     `${{ eq repository.name "hans wurst" }}`,
+			wantIsStatic: true,
+			wantBoolVal:  false,
+		},
+		{
+			name:         "nested function call and whitespace",
+			template:     `   ${{ eq false (eq false (matches repository.name "github.com*")) }}   `,
+			wantIsStatic: true,
+			wantBoolVal:  true,
+		},
+		{
+			name:         "nested function call with runtime value",
+			template:     `${{ eq false (eq false (matches outputs.repo.name "github.com*")) }}`,
+			wantIsStatic: false,
+			wantBoolVal:  false,
+		},
+		{
+			name:         "random string",
+			template:     `adfadsfasdfadsfasdfasdfadsf`,
+			wantIsStatic: true,
+			wantBoolVal:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			isStatic, boolVal, err := isStaticBool(tt.template, partialEvalStepCtx)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if isStatic != tt.wantIsStatic {
+				t.Fatalf("wrong isStatic value. want=%t, got=%t", tt.wantIsStatic, isStatic)
+			}
+			if boolVal != tt.wantBoolVal {
+				t.Fatalf("wrong boolVal value. want=%t, got=%t", tt.wantBoolVal, boolVal)
+			}
+		})
+	}
+}
diff --git a/internal/batches/executor/run_steps.go b/internal/batches/executor/run_steps.go
index fed8f908c5..f65eb67d45 100644
--- a/internal/batches/executor/run_steps.go
+++ b/internal/batches/executor/run_steps.go
@@ -77,13 +77,30 @@ func runSteps(ctx context.Context, opts *executionOpts) (result executionResult,
 	results := make([]StepResult, len(opts.steps))
 
 	for i, step := range opts.steps {
-		opts.reportProgress(fmt.Sprintf("Preparing step %d", i+1))
-
-		stepContext := StepContext{BatchChange: *opts.batchChangeAttributes, Repository: *opts.repo, Outputs: execResult.Outputs}
+		stepContext := StepContext{
+			BatchChange: *opts.batchChangeAttributes,
+			Repository:  *opts.repo,
+			Outputs:     execResult.Outputs,
+			Steps: StepsContext{
+				Path: execResult.Path,
+			},
+		}
 		if i > 0 {
 			stepContext.PreviousStep = results[i-1]
+			stepContext.Steps.Changes = results[i-1].files
 		}
 
+		cond, err := evalStepCondition(step.IfCondition(), &stepContext)
+		if err != nil {
+			return execResult, errors.Wrap(err, "evaluating step condition")
+		}
+		if !cond {
+			opts.reportProgress(fmt.Sprintf("Skipping step %d", i+1))
+			continue
+		}
+
+		opts.reportProgress(fmt.Sprintf("Preparing step %d", i+1))
+
 		// Find a location that we can use for a cidfile, which will contain the
 		// container ID that is used below. We can then use this to remove the
 		// container on a successful run, rather than leaving it dangling.
diff --git a/internal/batches/executor/task_builder.go b/internal/batches/executor/task_builder.go
new file mode 100644
index 0000000000..034c37a8bd
--- /dev/null
+++ b/internal/batches/executor/task_builder.go
@@ -0,0 +1,189 @@
+package executor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gobwas/glob"
+	"github.com/sourcegraph/src-cli/internal/batches"
+	"github.com/sourcegraph/src-cli/internal/batches/graphql"
+)
+
+type DirectoryFinder interface {
+	FindDirectoriesInRepos(ctx context.Context, fileName string, repos ...*graphql.Repository) (map[*graphql.Repository][]string, error)
+}
+
+type TaskBuilder struct {
+	spec   *batches.BatchSpec
+	finder DirectoryFinder
+
+	initializedWorkspaceConfigs []batches.WorkspaceConfiguration
+}
+
+func NewTaskBuilder(spec *batches.BatchSpec, finder DirectoryFinder) (*TaskBuilder, error) {
+	tb := &TaskBuilder{spec: spec, finder: finder}
+
+	for _, conf := range tb.spec.Workspaces {
+		g, err := glob.Compile(conf.In)
+		if err != nil {
+			return nil, err
+		}
+		conf.SetGlob(g)
+		tb.initializedWorkspaceConfigs = append(tb.initializedWorkspaceConfigs, conf)
+	}
+
+	return tb, nil
+}
+
+func (tb *TaskBuilder) buildTask(r *graphql.Repository, path string, onlyWorkspace bool) (*Task, bool, error) {
+	stepCtx := &StepContext{
+		Repository: *r,
+		BatchChange: BatchChangeAttributes{
+			Name:        tb.spec.Name,
+			Description: tb.spec.Description,
+		},
+	}
+
+	var taskSteps []batches.Step
+	for _, step := range tb.spec.Steps {
+		if step.IfCondition() == "" {
+			taskSteps = append(taskSteps, step)
+			continue
+		}
+
+		static, boolVal, err := isStaticBool(step.IfCondition(), stepCtx)
+		if err != nil {
+			return nil, false, err
+		}
+
+		// If we could evaluate the condition statically and the resulting
+		// boolean is false, we don't add that step.
+		if !static {
+			taskSteps = append(taskSteps, step)
+		} else if boolVal {
+			taskSteps = append(taskSteps, step)
+		}
+	}
+
+	// If the task doesn't have any steps we don't need to execute it
+	if len(taskSteps) == 0 {
+		return nil, false, nil
+	}
+
+	// "." means the path is root, but in the executor we use "" to signify root
+	if path == "." {
+		path = ""
+	}
+
+	return &Task{
+		Repository:         r,
+		Path:               path,
+		Steps:              taskSteps,
+		OnlyFetchWorkspace: onlyWorkspace,
+
+		TransformChanges: tb.spec.TransformChanges,
+		Template:         tb.spec.ChangesetTemplate,
+		BatchChangeAttributes: &BatchChangeAttributes{
+			Name:        tb.spec.Name,
+			Description: tb.spec.Description,
+		},
+	}, true, nil
+}
+
+func (tb *TaskBuilder) BuildAll(ctx context.Context, repos []*graphql.Repository) ([]*Task, error) {
+	// Find workspaces in repositories, if configured
+	workspaces, root, err := tb.findWorkspaces(ctx, repos, tb.initializedWorkspaceConfigs)
+	if err != nil {
+		return nil, err
+	}
+
+	var tasks []*Task
+	for repo, ws := range workspaces {
+		for _, path := range ws.paths {
+			t, ok, err := tb.buildTask(repo, path, ws.onlyFetchWorkspace)
+			if err != nil {
+				return nil, err
+			}
+
+			if ok {
+				tasks = append(tasks, t)
+			}
+		}
+	}
+
+	for _, repo := range root {
+		t, ok, err := tb.buildTask(repo, "", false)
+		if err != nil {
+			return nil, err
+		}
+
+		if ok {
+			tasks = append(tasks, t)
+		}
+	}
+
+	return tasks, nil
+}
+
+type repoWorkspaces struct {
+	paths              []string
+	onlyFetchWorkspace bool
+}
+
+// findWorkspaces matches the given repos to the workspace configs and
+// searches, via the Sourcegraph instance, the locations of the workspaces in
+// each repository.
+// The repositories that were matched by a workspace config are returned in
+// workspaces. root contains the repositories that didn't match a config.
+// If the user didn't specify any workspaces, the repositories are returned as
+// root repositories.
+func (tb *TaskBuilder) findWorkspaces(
+	ctx context.Context,
+	repos []*graphql.Repository,
+	configs []batches.WorkspaceConfiguration,
+) (workspaces map[*graphql.Repository]repoWorkspaces, root []*graphql.Repository, err error) {
+	if len(configs) == 0 {
+		return nil, repos, nil
+	}
+
+	matched := map[int][]*graphql.Repository{}
+
+	for _, repo := range repos {
+		found := false
+
+		for idx, conf := range configs {
+			if !conf.Matches(repo.Name) {
+				continue
+			}
+
+			if found {
+				return nil, nil, fmt.Errorf("repository %s matches multiple workspaces.in globs in the batch spec. glob: %q", repo.Name, conf.In)
+			}
+
+			matched[idx] = append(matched[idx], repo)
+			found = true
+		}
+
+		if !found {
+			root = append(root, repo)
+		}
+	}
+
+	workspaces = map[*graphql.Repository]repoWorkspaces{}
+	for idx, repos := range matched {
+		conf := configs[idx]
+		repoDirs, err := tb.finder.FindDirectoriesInRepos(ctx, conf.RootAtLocationOf, repos...)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		for repo, dirs := range repoDirs {
+			workspaces[repo] = repoWorkspaces{
+				paths:              dirs,
+				onlyFetchWorkspace: conf.OnlyFetchWorkspace,
+			}
+		}
+	}
+
+	return workspaces, root, nil
+}
diff --git a/internal/batches/executor/task_builder_test.go b/internal/batches/executor/task_builder_test.go
new file mode 100644
index 0000000000..fd204de0ee
--- /dev/null
+++ b/internal/batches/executor/task_builder_test.go
@@ -0,0 +1,310 @@
+package executor
+
+import (
+	"context"
+	"sort"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/sourcegraph/src-cli/internal/batches"
+	"github.com/sourcegraph/src-cli/internal/batches/graphql"
+)
+
+func TestTaskBuilder_BuildTask_IfConditions(t *testing.T) {
+	repo := &graphql.Repository{Name: "github.com/sourcegraph/automation-testing"}
+
+	tests := map[string]struct {
+		spec *batches.BatchSpec
+
+		wantSteps []batches.Step
+	}{
+		"no if": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1"},
+				},
+			},
+			wantSteps: []batches.Step{
+				{Run: "echo 1"},
+			},
+		},
+
+		"if has static true value": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1", If: "true"},
+				},
+			},
+			wantSteps: []batches.Step{
+				{Run: "echo 1", If: "true"},
+			},
+		},
+
+		"one of many steps has if with static true value": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1"},
+					{Run: "echo 2", If: "true"},
+					{Run: "echo 3"},
+				},
+			},
+			wantSteps: []batches.Step{
+				{Run: "echo 1"},
+				{Run: "echo 2", If: "true"},
+				{Run: "echo 3"},
+			},
+		},
+
+		"if has static non-true value": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1", If: "this is not true"},
+				},
+			},
+			wantSteps: nil,
+		},
+
+		"one of many steps has if with static non-true value": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1"},
+					{Run: "echo 2", If: "every type system needs generics"},
+					{Run: "echo 3"},
+				},
+			},
+			wantSteps: []batches.Step{
+				{Run: "echo 1"},
+				{Run: "echo 3"},
+			},
+		},
+
+		"if expression that can be partially evaluated to true": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1", If: `${{ matches repository.name "github.com/sourcegraph/automation*" }}`},
+				},
+			},
+			wantSteps: []batches.Step{
+				{Run: "echo 1", If: `${{ matches repository.name "github.com/sourcegraph/automation*" }}`},
+			},
+		},
+
+		"if expression that can be partially evaluated to false": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1", If: `${{ matches repository.name "horse" }}`},
+				},
+			},
+			wantSteps: nil,
+		},
+
+		"one of many steps has if expression that can be evaluated to true": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1", If: `${{ matches repository.name "horse" }}`},
+				},
+			},
+			wantSteps: nil,
+		},
+
+		"if expression that can NOT be partially evaluated": {
+			spec: &batches.BatchSpec{
+				Steps: []batches.Step{
+					{Run: "echo 1", If: `${{ eq outputs.value "foobar" }}`},
+				},
+			},
+			wantSteps: []batches.Step{
+				{Run: "echo 1", If: `${{ eq outputs.value "foobar" }}`},
+			},
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			builder, err := NewTaskBuilder(tt.spec, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			task, ok, err := builder.buildTask(repo, "", false)
+			if err != nil {
+				t.Fatalf("unexpected err: %s", err)
+			}
+
+			if !ok {
+				if tt.wantSteps != nil {
+					t.Fatalf("no task built, but steps expected")
+				}
+				return
+			}
+
+			opts := cmpopts.IgnoreUnexported(batches.Step{})
+			if diff := cmp.Diff(tt.wantSteps, task.Steps, opts); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestTaskBuilder_BuildAll_Workspaces(t *testing.T) {
+	repos := []*graphql.Repository{
+		{ID: "repo-id-0", Name: "github.com/sourcegraph/automation-testing"},
+		{ID: "repo-id-1", Name: "github.com/sourcegraph/sourcegraph"},
+		{ID: "repo-id-2", Name: "bitbucket.sgdev.org/SOUR/automation-testing"},
+	}
+	steps := []batches.Step{{Run: "echo 1"}}
+
+	type finderResults map[*graphql.Repository][]string
+
+	type wantTask struct {
+		Path               string
+		ArchivePathToFetch string
+	}
+
+	tests := map[string]struct {
+		spec          *batches.BatchSpec
+		finderResults map[*graphql.Repository][]string
+
+		wantNumTasks int
+
+		// tasks per repository ID and in which path they are executed
+		wantTasks map[string][]wantTask
+	}{
+		"no workspace configuration": {
+			spec:          &batches.BatchSpec{Steps: steps},
+			finderResults: finderResults{},
+			wantNumTasks:  len(repos),
+			wantTasks: map[string][]wantTask{
+				repos[0].ID: {{Path: ""}},
+				repos[1].ID: {{Path: ""}},
+				repos[2].ID: {{Path: ""}},
+			},
+		},
+
+		"workspace configuration matching no repos": {
+			spec: &batches.BatchSpec{
+				Steps: steps,
+				Workspaces: []batches.WorkspaceConfiguration{
+					{In: "this-does-not-match", RootAtLocationOf: "package.json"},
+				},
+			},
+			finderResults: finderResults{},
+			wantNumTasks:  len(repos),
+			wantTasks: map[string][]wantTask{
+				repos[0].ID: {{Path: ""}},
+				repos[1].ID: {{Path: ""}},
+				repos[2].ID: {{Path: ""}},
+			},
+		},
+
+		"workspace configuration matching 2 repos with no results": {
+			spec: &batches.BatchSpec{
+				Steps: steps,
+				Workspaces: []batches.WorkspaceConfiguration{
+					{In: "*automation-testing", RootAtLocationOf: "package.json"},
+				},
+			},
+			finderResults: finderResults{
+				repos[0]: []string{},
+				repos[2]: []string{},
+			},
+			wantNumTasks: 1,
+			wantTasks: map[string][]wantTask{
+				repos[1].ID: {{Path: ""}},
+			},
+		},
+
+		"workspace configuration matching 2 repos with 3 results each": {
+			spec: &batches.BatchSpec{
+				Steps: steps,
+				Workspaces: []batches.WorkspaceConfiguration{
+					{In: "*automation-testing", RootAtLocationOf: "package.json"},
+				},
+			},
+			finderResults: finderResults{
+				repos[0]: {"a/b", "a/b/c", "d/e/f"},
+				repos[2]: {"a/b", "a/b/c", "d/e/f"},
+			},
+			wantNumTasks: 7,
+			wantTasks: map[string][]wantTask{
+				repos[0].ID: {{Path: "a/b"}, {Path: "a/b/c"}, {Path: "d/e/f"}},
+				repos[1].ID: {{Path: ""}},
+				repos[2].ID: {{Path: "a/b"}, {Path: "a/b/c"}, {Path: "d/e/f"}},
+			},
+		},
+
+		"workspace configuration matches repo with OnlyFetchWorkspace": {
+			spec: &batches.BatchSpec{
+				Steps: steps,
+				Workspaces: []batches.WorkspaceConfiguration{
+					{
+						OnlyFetchWorkspace: true,
+						In:                 "*automation-testing",
+						RootAtLocationOf:   "package.json",
+					},
+				},
+			},
+			finderResults: finderResults{
+				repos[0]: {"a/b", "a/b/c", "d/e/f"},
+				repos[2]: {"a/b", "a/b/c", "d/e/f"},
+			},
+			wantNumTasks: 7,
+			wantTasks: map[string][]wantTask{
+				repos[0].ID: {
+					{Path: "a/b", ArchivePathToFetch: "a/b"},
+					{Path: "a/b/c", ArchivePathToFetch: "a/b/c"},
+					{Path: "d/e/f", ArchivePathToFetch: "d/e/f"},
+				},
+				repos[1].ID: {{Path: ""}},
+				repos[2].ID: {
+					{Path: "a/b", ArchivePathToFetch: "a/b"},
+					{Path: "a/b/c", ArchivePathToFetch: "a/b/c"},
+					{Path: "d/e/f", ArchivePathToFetch: "d/e/f"},
+				},
+			},
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			finder := &mockDirectoryFinder{results: tt.finderResults}
+			tb, err := NewTaskBuilder(tt.spec, finder)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			tasks, err := tb.BuildAll(context.Background(), repos)
+			if err != nil {
+				t.Fatalf("unexpected err: %s", err)
+			}
+
+			if have := len(tasks); have != tt.wantNumTasks {
+				t.Fatalf("wrong number of tasks. want=%d, got=%d", tt.wantNumTasks, have)
+			}
+
+			haveTasks := map[string][]wantTask{}
+			for _, task := range tasks {
+				haveTasks[task.Repository.ID] = append(haveTasks[task.Repository.ID], wantTask{
+					Path:               task.Path,
+					ArchivePathToFetch: task.ArchivePathToFetch(),
+				})
+			}
+
+			for _, tasks := range haveTasks {
+				sort.Slice(tasks, func(i, j int) bool { return tasks[i].Path < tasks[j].Path })
+			}
+
+			if diff := cmp.Diff(tt.wantTasks, haveTasks); diff != "" {
+				t.Errorf("mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+type mockDirectoryFinder struct {
+	results map[*graphql.Repository][]string
+}
+
+func (m *mockDirectoryFinder) FindDirectoriesInRepos(ctx context.Context, fileName string, repos ...*graphql.Repository) (map[*graphql.Repository][]string, error) {
+	return m.results, nil
+}
diff --git a/internal/batches/executor/templating.go b/internal/batches/executor/templating.go
index f0e9322f1b..a152e73009 100644
--- a/internal/batches/executor/templating.go
+++ b/internal/batches/executor/templating.go
@@ -6,13 +6,56 @@ import (
 	"strings"
 	"text/template"
 
+	"github.com/gobwas/glob"
 	"github.com/pkg/errors"
 	"github.com/sourcegraph/src-cli/internal/batches/git"
 	"github.com/sourcegraph/src-cli/internal/batches/graphql"
 )
 
+const startDelim = "${{"
+const endDelim = "}}"
+
+var builtins = template.FuncMap{
+	"join":    strings.Join,
+	"split":   strings.Split,
+	"replace": strings.ReplaceAll,
+	"join_if": func(sep string, elems ...string) string {
+		var nonBlank []string
+		for _, e := range elems {
+			if e != "" {
+				nonBlank = append(nonBlank, e)
+			}
+		}
+		return strings.Join(nonBlank, sep)
+	},
+	"matches": func(in, pattern string) (bool, error) {
+		g, err := glob.Compile(pattern)
+		if err != nil {
+			return false, err
+		}
+		return g.Match(in), nil
+	},
+}
+
+func isTrueOutput(output interface{ String() string }) bool {
+	return strings.TrimSpace(output.String()) == "true"
+}
+
+func evalStepCondition(condition string, stepCtx *StepContext) (bool, error) {
+	if condition == "" {
+		return true, nil
+	}
+
+	var out bytes.Buffer
+	if err := renderStepTemplate("step-condition", condition, &out, stepCtx); err != nil {
+		return false, errors.Wrap(err, "parsing step if")
+	}
+
+	return isTrueOutput(&out), nil
+}
+
 func renderStepTemplate(name, tmpl string, out io.Writer, stepCtx *StepContext) error {
-	t, err := parseAsTemplate(name, tmpl, stepCtx)
+	t, err := template.New(name).Delims(startDelim, endDelim).Funcs(builtins).Funcs(stepCtx.ToFuncMap()).Parse(tmpl)
 	if err != nil {
 		return errors.Wrap(err, "parsing step run")
 	}
@@ -20,10 +63,6 @@ func renderStepTemplate(name, tmpl string, out io.Writer, stepCtx *StepContext)
 	return t.Execute(out, stepCtx)
 }
 
-func parseAsTemplate(name, input string, stepCtx *StepContext) (*template.Template, error) {
-	return template.New(name).Delims("${{", "}}").Funcs(stepCtx.ToFuncMap()).Parse(input)
-}
-
 func renderStepMap(m map[string]string, stepCtx *StepContext) (map[string]string, error) {
 	rendered := make(map[string]string, len(m))
 
@@ -56,6 +95,9 @@ type StepContext struct {
 	// Step is the result of the current step. Empty when evaluating the "run" field
 	// but filled when evaluating the "outputs" field.
 	Step StepResult
+	// Steps contains the path in which the steps are being executed and the
+	// changes made by all steps that were executed up until the current step.
+	Steps StepsContext
 	// PreviousStep is the result of the previous step. Empty when there is no
 	// previous step.
 	PreviousStep StepResult
@@ -96,24 +138,17 @@ func (stepCtx *StepContext) ToFuncMap() template.FuncMap {
 	}
 
 	return template.FuncMap{
-		"join":    strings.Join,
-		"split":   strings.Split,
-		"replace": strings.ReplaceAll,
-		"join_if": func(sep string, elems ...string) string {
-			var nonBlank []string
-			for _, e := range elems {
-				if e != "" {
-					nonBlank = append(nonBlank, e)
-				}
-			}
-			return strings.Join(nonBlank, sep)
-		},
 		"previous_step": func() map[string]interface{} {
 			return newStepResult(&stepCtx.PreviousStep)
 		},
 		"step": func() map[string]interface{} {
 			return newStepResult(&stepCtx.Step)
 		},
+		"steps": func() map[string]interface{} {
+			res := newStepResult(&StepResult{files: stepCtx.Steps.Changes})
+			res["path"] = stepCtx.Steps.Path
+			return res
+		},
 		"outputs": func() map[string]interface{} {
 			return stepCtx.Outputs
 		},
@@ -204,18 +239,6 @@ type ChangesetTemplateContext struct {
 // text/template.
 func (tmplCtx *ChangesetTemplateContext) ToFuncMap() template.FuncMap {
 	return template.FuncMap{
-		"join":    strings.Join,
-		"split":   strings.Split,
-		"replace": strings.ReplaceAll,
-		"join_if": func(sep string, elems ...string) string {
-			var nonBlank []string
-			for _, e := range elems {
-				if e != "" {
-					nonBlank = append(nonBlank, e)
-				}
-			}
-			return strings.Join(nonBlank, sep)
-		},
 		"repository": func() map[string]interface{} {
 			return map[string]interface{}{
 				"search_result_paths": tmplCtx.Repository.SearchResultPaths(),
@@ -250,7 +273,7 @@ func (tmplCtx *ChangesetTemplateContext) ToFuncMap() template.FuncMap {
 func renderChangesetTemplateField(name, tmpl string, tmplCtx *ChangesetTemplateContext) (string, error) {
 	var out bytes.Buffer
 
-	t, err := template.New(name).Delims("${{", "}}").Funcs(tmplCtx.ToFuncMap()).Parse(tmpl)
+	t, err := template.New(name).Delims(startDelim, endDelim).Funcs(builtins).Funcs(tmplCtx.ToFuncMap()).Parse(tmpl)
 	if err != nil {
 		return "", err
 	}
diff --git a/internal/batches/executor/templating_test.go b/internal/batches/executor/templating_test.go
index dcb9839de8..16881b4f77 100644
--- a/internal/batches/executor/templating_test.go
+++ b/internal/batches/executor/templating_test.go
@@ -10,6 +10,65 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+var testChanges = &git.Changes{
+	Modified: []string{"go.mod"},
+	Added:    []string{"main.go.swp"},
+	Deleted:  []string{".DS_Store"},
+	Renamed:  []string{"new-filename.txt"},
+}
+
+func TestEvalStepCondition(t *testing.T) {
+	stepCtx := &StepContext{
+		BatchChange: BatchChangeAttributes{
+			Name:        "test-batch-change",
+			Description: "This batch change is just an experiment",
+		},
+		PreviousStep: StepResult{
+			files:  testChanges,
+			Stdout: bytes.NewBufferString("this is previous step's stdout"),
+			Stderr: bytes.NewBufferString("this is previous step's stderr"),
+		},
+		Steps: StepsContext{
+			Changes: testChanges,
+			Path:    "sub/directory/of/repo",
+		},
+		Outputs: map[string]interface{}{},
+		// Step is not set when evalStepCondition is called
+		Repository: graphql.Repository{
+			Name: "github.com/sourcegraph/src-cli",
+			FileMatches: map[string]bool{
+				"README.md": true,
+				"main.go":   true,
+			},
+		},
+	}
+
+	tests := []struct {
+		run  string
+		want bool
+	}{
+		{run: `true`, want: true},
+		{run: `  true    `, want: true},
+		{run: `TRUE`, want: false},
+		{run: `false`, want: false},
+		{run: `FALSE`, want: false},
+		{run: `${{ eq repository.name "github.com/sourcegraph/src-cli" }}`, want: true},
+		{run: `${{ eq steps.path "sub/directory/of/repo" }}`, want: true},
+		{run: `${{ matches repository.name "github.com/sourcegraph/*" }}`, want: true},
+	}
+
+	for _, tc := range tests {
+		got, err := evalStepCondition(tc.run, stepCtx)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if got != tc.want {
+			t.Fatalf("wrong value. want=%t, got=%t", tc.want, got)
+		}
+	}
+}
+
 const rawYaml = `dist: release
 env:
   - GO111MODULE=on
@@ -36,12 +95,7 @@ func TestRenderStepTemplate(t *testing.T) {
 			Description: "This batch change is just an experiment",
 		},
 		PreviousStep: StepResult{
-			files: &git.Changes{
-				Modified: []string{"go.mod"},
-				Added:    []string{"main.go.swp"},
-				Deleted:  []string{".DS_Store"},
-				Renamed:  []string{"new-filename.txt"},
-			},
+			files:  testChanges,
 			Stdout: bytes.NewBufferString("this is previous step's stdout"),
 			Stderr: bytes.NewBufferString("this is previous step's stderr"),
 		},
@@ -50,15 +104,11 @@ func TestRenderStepTemplate(t *testing.T) {
 			"project":  parsedYaml,
 		},
 		Step: StepResult{
-			files: &git.Changes{
-				Modified: []string{"step-go.mod"},
-				Added:    []string{"step-main.go.swp"},
-				Deleted:  []string{"step-.DS_Store"},
-				Renamed:  []string{"step-new-filename.txt"},
-			},
+			files:  testChanges,
 			Stdout: bytes.NewBufferString("this is current step's stdout"),
 			Stderr: bytes.NewBufferString("this is current step's stderr"),
 		},
+		Steps: StepsContext{Changes: testChanges, Path: "sub/directory/of/repo"},
 		Repository: graphql.Repository{
 			Name: "github.com/sourcegraph/src-cli",
 			FileMatches: map[string]bool{
@@ -95,6 +145,11 @@ ${{ step.deleted_files }}
 ${{ step.renamed_files }}
 ${{ step.stdout}}
 ${{ step.stderr}}
+${{ steps.modified_files }}
+${{ steps.added_files }}
+${{ steps.deleted_files }}
+${{ steps.renamed_files }}
+${{ steps.path }}
 `,
 			want: `README.md main.go
 github.com/sourcegraph/src-cli
@@ -108,12 +163,17 @@ this is previous step's stdout
 this is previous step's stderr
 lastLine is this
 CGO_ENABLED=0
-[step-go.mod]
-[step-main.go.swp]
-[step-.DS_Store]
-[step-new-filename.txt]
+[go.mod]
+[main.go.swp]
+[.DS_Store]
+[new-filename.txt]
 this is current step's stdout
 this is current step's stderr
+[go.mod]
+[main.go.swp]
+[.DS_Store]
+[new-filename.txt]
+sub/directory/of/repo
 `,
 		},
 		{
@@ -135,6 +195,11 @@ ${{ step.deleted_files }}
 ${{ step.renamed_files }}
 ${{ step.stdout}}
 ${{ step.stderr}}
+${{ steps.modified_files }}
+${{ steps.added_files }}
+${{ steps.deleted_files }}
+${{ steps.renamed_files }}
+${{ steps.path }}
 `,
 			want: `
 
@@ -152,6 +217,11 @@ ${{ step.stderr}}
 []
 
 
+[]
+[]
+[]
+[]
+
 `,
 		},
 	}
@@ -175,12 +245,7 @@ ${{ step.stderr}}
 func TestRenderStepMap(t *testing.T) {
 	stepCtx := &StepContext{
 		PreviousStep: StepResult{
-			files: &git.Changes{
-				Modified: []string{"go.mod"},
-				Added:    []string{"main.go.swp"},
-				Deleted:  []string{".DS_Store"},
-				Renamed:  []string{"new-filename.txt"},
-			},
+			files:  testChanges,
 			Stdout: bytes.NewBufferString("this is previous step's stdout"),
 			Stderr: bytes.NewBufferString("this is previous step's stderr"),
 		},
@@ -255,13 +320,13 @@ func TestRenderChangesetTemplateField(t *testing.T) {
 	tests := []struct {
 		name    string
 		tmplCtx *ChangesetTemplateContext
-		run     string
+		tmpl    string
 		want    string
 	}{
 		{
 			name:    "lower-case aliases",
 			tmplCtx: tmplCtx,
-			run: `${{ repository.search_result_paths }}
+			tmpl: `${{ repository.search_result_paths }}
 ${{ repository.name }}
 ${{ batch_change.name }}
 ${{ batch_change.description }}
@@ -288,7 +353,7 @@ infrastructure/sub-project`,
 		{
 			name:    "empty context",
 			tmplCtx: &ChangesetTemplateContext{},
-			run: `${{ repository.search_result_paths }}
+			tmpl: `${{ repository.search_result_paths }}
 ${{ repository.name }}
 ${{ outputs.lastLine }}
 ${{ outputs.project }}
@@ -308,7 +373,7 @@ ${{ steps.renamed_files }}
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			out, err := renderChangesetTemplateField("testing", tc.run, tc.tmplCtx)
+			out, err := renderChangesetTemplateField("testing", tc.tmpl, tc.tmplCtx)
 			if err != nil {
 				t.Fatal(err)
 			}
diff --git a/internal/batches/features.go b/internal/batches/features.go
index 3ca075cb41..945d44fa7f 100644
--- a/internal/batches/features.go
+++ b/internal/batches/features.go
@@ -14,6 +14,7 @@ type FeatureFlags struct {
 	AllowTransformChanges    bool
 	AllowWorkspaces          bool
 	BatchChanges             bool
+	AllowConditionalExec     bool
 }
 
 func (ff *FeatureFlags) SetFromVersion(version string) error {
@@ -28,6 +29,7 @@ func (ff *FeatureFlags) SetFromVersion(version string) error {
 		{&ff.AllowTransformChanges, ">= 3.23.0", "2020-12-11"},
 		{&ff.AllowWorkspaces, ">= 3.25.0", "2021-01-29"},
 		{&ff.BatchChanges, ">= 3.26.0", "2021-03-07"},
+		{&ff.AllowConditionalExec, ">= 3.28.0", "2021-05-05"},
 	} {
 		value, err := api.CheckSourcegraphVersion(version, feature.constraint, feature.minDate)
 		if err != nil {
diff --git a/internal/batches/service/service.go b/internal/batches/service/service.go
index e8b575207d..8fdac712df 100644
--- a/internal/batches/service/service.go
+++ b/internal/batches/service/service.go
@@ -13,7 +13,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gobwas/glob"
 	"github.com/hashicorp/go-multierror"
 	"github.com/pkg/errors"
 	"github.com/sourcegraph/src-cli/internal/api"
@@ -185,96 +184,12 @@ func (svc *Service) EnsureImage(ctx context.Context, name string) (docker.Image,
 }
 
 func (svc *Service) BuildTasks(ctx context.Context, repos []*graphql.Repository, spec *batches.BatchSpec) ([]*executor.Task, error) {
-	workspaceConfigs := []batches.WorkspaceConfiguration{}
-	for _, conf := range spec.Workspaces {
-		g, err := glob.Compile(conf.In)
-		if err != nil {
-			return nil, err
-		}
-		conf.SetGlob(g)
-		workspaceConfigs = append(workspaceConfigs, conf)
-	}
-
-	// rootWorkspace contains all the repositories that didn't match a
-	// `workspaces` configuration.
-	rootWorkspace := map[*graphql.Repository]struct{}{}
-	// reposByWorkspaceConfig maps workspace config to repositories in which
-	// the workspace config should be used.
-	reposByWorkspaceConfig := make(map[int][]*graphql.Repository, len(workspaceConfigs))
-
-	for _, repo := range repos {
-		matched := false
-
-		for i, conf := range workspaceConfigs {
-			if !conf.Matches(repo.Name) {
-				continue
-			}
-
-			if matched {
-				return nil, fmt.Errorf("repository %s matches multiple workspaces.in globs in the batch spec. glob: %q", repo.Name, conf.In)
-			}
-
-			if rs, ok := reposByWorkspaceConfig[i]; ok {
-				reposByWorkspaceConfig[i] = append(rs, repo)
-			} else {
-				reposByWorkspaceConfig[i] = []*graphql.Repository{repo}
-			}
-			matched = true
-		}
-
-		if !matched {
-			rootWorkspace[repo] = struct{}{}
-		}
-	}
-
-	var tasks []*executor.Task
-
-	attr := &executor.BatchChangeAttributes{Name: spec.Name, Description: spec.Description}
-
-	for configIndex, repos := range reposByWorkspaceConfig {
-		workspaceConfig := workspaceConfigs[configIndex]
-		repoDirs, err := svc.FindDirectoriesInRepos(ctx, workspaceConfig.RootAtLocationOf, repos...)
-		if err != nil {
-			return nil, err
-		}
-
-		for repo, dirs := range repoDirs {
-			for _, d := range dirs {
-				// Directory is root.
-				if d == "." {
-					// This shouldn't happen, but sanity check:
-					if _, ok := rootWorkspace[repo]; ok {
-						continue
-					} else {
-						d = ""
-					}
-				}
-
-				tasks = append(tasks, &executor.Task{
-					Repository:            repo,
-					Path:                  d,
-					Steps:                 spec.Steps,
-					TransformChanges:      spec.TransformChanges,
-					Template:              spec.ChangesetTemplate,
-					BatchChangeAttributes: attr,
-					OnlyFetchWorkspace:    workspaceConfig.OnlyFetchWorkspace,
-				})
-			}
-		}
-	}
-
-	for r := range rootWorkspace {
-		tasks = append(tasks, &executor.Task{
-			Repository:            r,
-			Path:                  "",
-			Steps:                 spec.Steps,
-			TransformChanges:      spec.TransformChanges,
-			Template:              spec.ChangesetTemplate,
-			BatchChangeAttributes: attr,
-		})
+	builder, err := executor.NewTaskBuilder(spec, svc)
+	if err != nil {
+		return nil, err
 	}
 
-	return tasks, nil
+	return builder.BuildAll(ctx, repos)
 }
 
 func (svc *Service) RunExecutor(ctx context.Context, opts executor.Opts, tasks []*executor.Task, spec *batches.BatchSpec, progress func([]*executor.TaskStatus), skipErrors bool) ([]*batches.ChangesetSpec, []string, error) {
diff --git a/internal/batches/service/service_test.go b/internal/batches/service/service_test.go
index 704f0eb06d..867134ca18 100644
--- a/internal/batches/service/service_test.go
+++ b/internal/batches/service/service_test.go
@@ -3,11 +3,8 @@ package service
 import (
 	"bytes"
 	"context"
-	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"sort"
 	"strings"
 	"testing"
 
@@ -408,213 +405,6 @@ const testFindDirectoriesInRepos = `{
 }
 `
 
-func TestService_BuildTasks(t *testing.T) {
-	repos := []*graphql.Repository{
-		{ID: "repo-id-0", Name: "github.com/sourcegraph/automation-testing"},
-		{ID: "repo-id-1", Name: "github.com/sourcegraph/sourcegraph"},
-		{ID: "repo-id-2", Name: "bitbucket.sgdev.org/SOUR/automation-testing"},
-	}
-
-	type wantTask struct {
-		Path               string
-		ArchivePathToFetch string
-	}
-
-	tests := map[string]struct {
-		spec  *batches.BatchSpec
-		repos []*graphql.Repository
-
-		searchResults filesInRepos
-
-		wantNumTasks int
-
-		// tasks per repository ID and in which path they are executed
-		wantTasks map[string][]wantTask
-	}{
-		"no workspace configuration": {
-			spec:          &batches.BatchSpec{},
-			repos:         repos,
-			searchResults: filesInRepos{},
-			wantNumTasks:  len(repos),
-			wantTasks: map[string][]wantTask{
-				repos[0].ID: {{Path: ""}},
-				repos[1].ID: {{Path: ""}},
-				repos[2].ID: {{Path: ""}},
-			},
-		},
-
-		"workspace configuration matching no repos": {
-			spec: &batches.BatchSpec{
-				Workspaces: []batches.WorkspaceConfiguration{
-					{In: "this-does-not-match", RootAtLocationOf: "package.json"},
-				},
-			},
-			searchResults: filesInRepos{},
-			repos:         repos,
-			wantNumTasks:  len(repos),
-			wantTasks: map[string][]wantTask{
-				repos[0].ID: {{Path: ""}},
-				repos[1].ID: {{Path: ""}},
-				repos[2].ID: {{Path: ""}},
-			},
-		},
-
-		"workspace configuration matching 2 repos with no results": {
-			spec: &batches.BatchSpec{
-				Workspaces: []batches.WorkspaceConfiguration{
-					{In: "*automation-testing", RootAtLocationOf: "package.json"},
-				},
-			},
-			searchResults: filesInRepos{
-				{},
-				{},
-			},
-			repos:        repos,
-			wantNumTasks: 1,
-			wantTasks: map[string][]wantTask{
-				repos[1].ID: {{Path: ""}},
-			},
-		},
-
-		"workspace configuration matching 2 repos with 3 results each": {
-			spec: &batches.BatchSpec{
-				Workspaces: []batches.WorkspaceConfiguration{
-					{In: "*automation-testing", RootAtLocationOf: "package.json"},
-				},
-			},
-			searchResults: filesInRepos{
-				{
-					"a/b/package.json",
-					"a/b/c/package.json.json",
-					"d/e/f/package.json",
-				},
-				{
-					"a/b/package.json",
-					"a/b/c/package.json.json",
-					"d/e/f/package.json",
-				},
-			},
-			repos:        repos,
-			wantNumTasks: 7,
-			wantTasks: map[string][]wantTask{
-				repos[0].ID: {{Path: "a/b"}, {Path: "a/b/c"}, {Path: "d/e/f"}},
-				repos[1].ID: {{Path: ""}},
-				repos[2].ID: {{Path: "a/b"}, {Path: "a/b/c"}, {Path: "d/e/f"}},
-			},
-		},
-
-		"workspace configuration matches repo with OnlyFetchWorkspace": {
-			spec: &batches.BatchSpec{
-				Workspaces: []batches.WorkspaceConfiguration{
-					{
-						OnlyFetchWorkspace: true,
-						In:                 "*automation-testing",
-						RootAtLocationOf:   "package.json",
-					},
-				},
-			},
-			searchResults: filesInRepos{
-				{
-					"a/b/package.json",
-					"a/b/c/package.json.json",
-					"d/e/f/package.json",
-				},
-				{
-					"a/b/package.json",
-					"a/b/c/package.json.json",
-					"d/e/f/package.json",
-				},
-			},
-			repos:        repos,
-			wantNumTasks: 7,
-			wantTasks: map[string][]wantTask{
-				repos[0].ID: {
-					{Path: "a/b", ArchivePathToFetch: "a/b"},
-					{Path: "a/b/c", ArchivePathToFetch: "a/b/c"},
-					{Path: "d/e/f", ArchivePathToFetch: "d/e/f"},
-				},
-				repos[1].ID: {{Path: ""}},
-				repos[2].ID: {
-					{Path: "a/b", ArchivePathToFetch: "a/b"},
-					{Path: "a/b/c", ArchivePathToFetch: "a/b/c"},
-					{Path: "d/e/f", ArchivePathToFetch: "d/e/f"},
-				},
-			},
-		},
-	}
-
-	for name, tt := range tests {
-		t.Run(name, func(t *testing.T) {
-			client, done := mockDirectoriesInReposResults(t, tt.searchResults)
-			defer done()
-
-			svc := &Service{client: client}
-
-			tasks, err := svc.BuildTasks(context.Background(), tt.repos, tt.spec)
-			if err != nil {
-				t.Fatalf("unexpected err: %s", err)
-			}
-
-			if have := len(tasks); have != tt.wantNumTasks {
-				t.Fatalf("wrong number of tasks. want=%d, got=%d", tt.wantNumTasks, have)
-			}
-
-			haveTasks := map[string][]wantTask{}
-			for _, task := range tasks {
-				haveTasks[task.Repository.ID] = append(haveTasks[task.Repository.ID], wantTask{
-					Path:               task.Path,
-					ArchivePathToFetch: task.ArchivePathToFetch(),
-				})
-			}
-
-			for _, tasks := range haveTasks {
-				sort.Slice(tasks, func(i, j int) bool { return tasks[i].Path < tasks[j].Path })
-			}
-
-			if diff := cmp.Diff(tt.wantTasks, haveTasks); diff != "" {
-				t.Errorf("mismatch (-want +got):\n%s", diff)
-			}
-		})
-	}
-}
-
-// Ordered list of files that are returned for each GraphQL query.
-type filesInRepos [][]string
-
-func mockDirectoriesInReposResults(t *testing.T, filesPerRepo filesInRepos) (client api.Client, done func()) {
-	t.Helper()
-
-	response := struct {
-		Data map[string]interface{}
-	}{
-		Data: map[string]interface{}{},
-	}
-
-	for i, files := range filesPerRepo {
-		fileResults := []map[string]interface{}{}
-
-		for _, f := range files {
-			fileResults = append(fileResults, map[string]interface{}{
-				"__typename": "FileMatch",
-				"file":       map[string]interface{}{"path": f},
-			})
-		}
-
-		response.Data[fmt.Sprintf("repo_%d", i)] = map[string]interface{}{
-			"results": map[string]interface{}{
-				"results": fileResults,
-			},
-		}
-	}
-
-	rawRes, err := json.Marshal(response)
-	if err != nil {
-		t.Fatalf("failed to marshal search results to JSON: %s", err)
-	}
-
-	return mockGraphQLClient(string(rawRes))
-}
-
 func TestService_ValidateChangesetSpecs(t *testing.T) {
 	repo1 := &graphql.Repository{ID: "repo-graphql-id-1", Name: "github.com/sourcegraph/src-cli"}
 	repo2 := &graphql.Repository{ID: "repo-graphql-id-2", Name: "github.com/sourcegraph/sourcegraph"}
diff --git a/schema/batch_spec.schema.json b/schema/batch_spec.schema.json
index 0e9ed0ffc2..76fac1c3d6 100644
--- a/schema/batch_spec.schema.json
+++ b/schema/batch_spec.schema.json
@@ -144,7 +144,9 @@
                     {
                       "type": "object",
                       "description": "An environment variable to set in the step environment: the value will be passed through from the environment src is running within.",
-                      "additionalProperties": { "type": "string" },
+                      "additionalProperties": {
+                        "type": "string"
+                      },
                       "minProperties": 1,
                       "maxProperties": 1
                     }
@@ -156,7 +158,19 @@
           "files": {
             "type": "object",
             "description": "Files that should be mounted into or be created inside the Docker container.",
-            "additionalProperties": { "type": "string" }
+            "additionalProperties": {
+              "type": "string"
+            }
+          },
+          "if": {
+            "oneOf": [{ "type": "boolean" }, { "type": "string" }],
+            "description": "A condition to check before executing steps. Supports templating. The value 'true' is interpreted as true.",
+            "examples": [
+              "true",
+              "${{ matches repository.name \"github.com/my-org/my-repo*\" }}",
+              "${{ outputs.goModFileExists }}",
+              "${{ eq previous_step.stdout \"success\" }}"
+            ]
           }
         }
       }
@@ -208,7 +222,14 @@
             "description": "The changesets to import from the code host. For GitHub this is the PR number, for GitLab this is the MR number, for Bitbucket Server this is the PR number.",
             "uniqueItems": true,
             "items": {
-              "oneOf": [{ "type": "string" }, { "type": "integer" }]
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
             },
             "examples": [120, "120"]
           }
@@ -268,7 +289,15 @@
           "description": "Whether to publish the changeset. An unpublished changeset can be previewed on Sourcegraph by any person who can view the batch change, but its commit, branch, and pull request aren't created on the code host. A published changeset results in a commit, branch, and pull request being created on the code host.",
           "oneOf": [
             {
-              "oneOf": [{ "type": "boolean" }, { "type": "string", "pattern": "^draft$" }],
+              "oneOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "pattern": "^draft$"
+                }
+              ],
               "description": "A single flag to control the publishing state for the entire batch change."
             },
             {
@@ -278,7 +307,15 @@
                 "type": "object",
                 "description": "An object with one field: the key is the glob pattern to match against repository names; the value will be used as the published flag for matching repositories.",
                 "additionalProperties": {
-                  "oneOf": [{ "type": "boolean" }, { "type": "string", "pattern": "^draft$" }]
+                  "oneOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "string",
+                      "pattern": "^draft$"
+                    }
+                  ]
                 },
                 "minProperties": 1,
                 "maxProperties": 1
diff --git a/schema/batch_spec_stringdata.go b/schema/batch_spec_stringdata.go
index 3577b90f44..3de4f703ef 100644
--- a/schema/batch_spec_stringdata.go
+++ b/schema/batch_spec_stringdata.go
@@ -149,7 +149,9 @@ const BatchSpecJSON = `{
                     {
                       "type": "object",
                       "description": "An environment variable to set in the step environment: the value will be passed through from the environment src is running within.",
-                      "additionalProperties": { "type": "string" },
+                      "additionalProperties": {
+                        "type": "string"
+                      },
                       "minProperties": 1,
                       "maxProperties": 1
                     }
@@ -161,7 +163,19 @@ const BatchSpecJSON = `{
           "files": {
             "type": "object",
             "description": "Files that should be mounted into or be created inside the Docker container.",
-            "additionalProperties": { "type": "string" }
+            "additionalProperties": {
+              "type": "string"
+            }
+          },
+          "if": {
+            "oneOf": [{ "type": "boolean" }, { "type": "string" }],
+            "description": "A condition to check before executing steps. Supports templating. The value 'true' is interpreted as true.",
+            "examples": [
+              "true",
+              "${{ matches repository.name \"github.com/my-org/my-repo*\" }}",
+              "${{ outputs.goModFileExists }}",
+              "${{ eq previous_step.stdout \"success\" }}"
+            ]
           }
         }
       }
@@ -213,7 +227,14 @@ const BatchSpecJSON = `{
             "description": "The changesets to import from the code host. For GitHub this is the PR number, for GitLab this is the MR number, for Bitbucket Server this is the PR number.",
             "uniqueItems": true,
             "items": {
-              "oneOf": [{ "type": "string" }, { "type": "integer" }]
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
             },
             "examples": [120, "120"]
           }
@@ -273,7 +294,15 @@ const BatchSpecJSON = `{
           "description": "Whether to publish the changeset. An unpublished changeset can be previewed on Sourcegraph by any person who can view the batch change, but its commit, branch, and pull request aren't created on the code host. A published changeset results in a commit, branch, and pull request being created on the code host.",
           "oneOf": [
             {
-              "oneOf": [{ "type": "boolean" }, { "type": "string", "pattern": "^draft$" }],
+              "oneOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "pattern": "^draft$"
+                }
+              ],
               "description": "A single flag to control the publishing state for the entire batch change."
             },
             {
@@ -283,7 +312,15 @@ const BatchSpecJSON = `{
                 "type": "object",
                 "description": "An object with one field: the key is the glob pattern to match against repository names; the value will be used as the published flag for matching repositories.",
                 "additionalProperties": {
-                  "oneOf": [{ "type": "boolean" }, { "type": "string", "pattern": "^draft$" }]
+                  "oneOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "string",
+                      "pattern": "^draft$"
+                    }
+                  ]
                 },
                 "minProperties": 1,
                 "maxProperties": 1