Skip to content
Velloreth
Developer Tools 9 min read

Task Runners Compared: Make, Just, and Taskfile

Make, Just, and go-task compared on syntax, dependencies, arguments, and cross-platform support — with the same project implemented three ways.

By

Every project accumulates the same commands: build it, test it, lint it, run it locally, ship it. Some teams put them in package.json, some in shell scripts, some in a Makefile copied from a template nobody has read.

The tool matters less than having one place where the commands live. But once you commit to a place, the differences between the three serious options are real.

Make, Just, and Task are not the same thing

The most useful distinction is old: Make is a build system. Just and Task are command runners.

Make decides whether work needs doing. It compares timestamps of targets and prerequisites, and skips a recipe when the output is newer than the input. That is what makes make fast on a large C project the second time you run it — and what makes it confusing when you just want to run a command.

Just and Task execute what you ask for, every time. If you want incremental behavior, you ask for it explicitly (Task can check file globs or status commands; Just leaves it to you).

MakeJustTask (go-task)
Origin1976, for C builds2016, Rust, inspired by Make2017, Go
FileMakefilejustfileTaskfile.yml
Config formatMake syntaxMake-like syntaxYAML
Incremental buildsYes, timestamp-basedNo (by design)Optional (sources/generates/status)
DependenciesPrerequisites graphRecipe dependenciesdeps + runs ordering
Arguments$1, automatic variablesPositional, flags, variadicVariables, CLI args after --
Cross-platformNeeds WSL/MSYS on WindowsNative everywhereNative everywhere
CategoryBuild system + runnerCommand runnerCommand runner

Make: the one you will meet anyway

You do not get to choose whether you learn Make. It ships with enough of the ecosystem that reading a Makefile is baseline literacy.

.PHONY: build test clean

BINARY := bin/server

build:
	go build -o $(BINARY) .

test:
	go test ./...

clean:
	rm -rf bin

Three things bite everyone:

Tabs, not spaces. Recipe lines must start with a tab character. Editors that convert tabs to spaces produce missing separator errors that look like nonsense until you know.

.PHONY. Targets that do not create a file of that name must be declared phony — otherwise a file named test in your directory silently breaks make test.

Automatic variables. $@ is the target, $< the first prerequisite, $^ all prerequisites. Compact and powerful, and unreadable six months later.

Where Make genuinely earns its keep is incremental builds:

$(BINARY): $(wildcard *.go)
	go build -o $(BINARY) .

Run it twice and the second run does nothing, because the binary is newer than the sources. For compiled languages this is not a convenience, it is the entire point.

Just: Make’s syntax without Make’s personality

Just describes itself as a command runner, not a build system, and the design follows from that. No .PHONY, no staleness detection, no automatic variables — recipes run when you invoke them.

default: build

build:
  go build -o bin/server .

test:
  go test ./...

clean:
  rm -rf bin

# comments above recipes show up in listings
lint *ARGS:
  golangci-lint run {{ARGS}}

The syntax will feel familiar if you have read a Makefile, with the important differences: spaces are fine for indentation, every recipe runs unconditionally, and arguments are first-class.

Features that tend to convert people:

set dotenv-load := true            # read .env into recipe environment
set shell := ["fish", "-c"]        # use a different shell

alias b := build

[private]                          # hide from `just --list`
trial:
  go test ./... -run TestTrial

# shebang recipes run in any language
publish:
  #!/usr/bin/env bash
  set -euo pipefail
  ./scripts/publish.sh

just also searches upward for a justfile (case-insensitive: Justfile, justfile, .justfile), so you can run it from any subdirectory. Unknown recipes and circular dependencies are caught before anything executes — a small thing that saves real time when you typo a name in CI.

Since 1.0, Just has a firm backwards-compatibility promise: existing justfiles keep working.

Task: YAML with the batteries included

go-task uses Taskfile.yml, and YAML is the pitch. Teams that do not want to learn a new syntax — and teams where shell fluency varies — tend to land here.

version: '3'

vars:
  BINARY: bin/server

tasks:
  build:
    cmds:
      - go build -o {{.BINARY}} .

  test:
    deps: [lint]
    cmds:
      - go test ./...

  lint:
    cmds:
      - golangci-lint run

  run:
    desc: Start the dev server
    prompt: Rebuild and restart the server?
    cmds:
      - go build -o {{.BINARY}} .
      - ./{{.BINARY}}

Details that matter in practice:

  • deps runs prerequisites in parallel; cmds runs in order. Knowing which is which prevents surprise concurrency.
  • Incremental support is built in. Declare sources (file globs) and generates (outputs), and Task skips the run when outputs are newer. status lets you supply a custom check command.
  • Remote Taskfiles. A Taskfile can include one from a URL or git repo, so an organization can centralize shared pipelines. It verifies a checksum and refuses untrusted sources by default.
  • Self-describing. task --list shows every task with a desc, task --init scaffolds a file, and missing tasks produce a “did you mean” suggestion.
  • Exit codes are configurable. --exit-code passes the child process’s code through, which CI scripts often need.

The costs: YAML’s whitespace sensitivity is worse than Make’s tab rule (though errors are clearer), and the file grows fast when tasks start nesting variables and conditions.

The same task, three times

Given a project that needs to lint, test, and build:

# Makefile
.PHONY: check
check: lint test build

lint:
	golangci-lint run
test:
	go test ./...
build:
	go build -o bin/server .
# justfile
check: lint test build

lint:
  golangci-lint run

test:
  go test ./...

build:
  go build -o bin/server .
# Taskfile.yml
version: '3'
tasks:
  check:
    deps: [lint, test, build]
  lint:
    cmds: [golangci-lint run]
  test:
    cmds: [go test ./...]
  build:
    cmds: [go build -o bin/server .]

All three run with one command. The differences show up later: Make will skip build if the binary is current, Just will always run it, and Task will run lint, test, and build concurrently as dependencies unless you order them with cmds.

Arguments, variables, and scaling to more files

The comparison above covers a three-task project. Real ones drift into arguments and multiple files, and this is where the tools diverge fastest.

Passing arguments. Make treats recipes as shell lines, so you pass flags through variables:

test:
	go test ./... $(TESTFLAGS)
make test TESTFLAGS="-run TestAuth"

Just builds argument handling into the syntax — positional parameters, variadic lists, and options:

test *ARGS:
  go test ./... {{ARGS}}

patch major minor:
  ./scripts/bump.sh {{major}} {{minor}}
just test -run TestAuth -v
just patch 1 4

Task passes everything after -- into CLI_ARGS:

tasks:
  test:
    vars:
      FLAGS: '{{default "" .CLI_ARGS}}'
    cmds:
      - go test ./... {{.FLAGS}}
task test -- -run TestAuth

All three work. Just is the most pleasant to read when arguments become routine; Task’s variable interpolation is the most expressive when conditionals enter the picture.

Splitting across files. Projects eventually outgrow one file:

  • Make: include common.mk and the optional -include, which silently ignores missing files.
  • Just: import 'modules/frontend.just', with modules kept as separate justfiles — and because Just searches upward, each subdirectory can carry its own recipes that still run from anywhere below.
  • Task: an includes: block with dir (scan a directory of Taskfiles), optional, and flatten (merge tasks into the parent namespace) — plus remote includes for organization-wide pipelines.

Task’s directory scanning is the most automated, Just’s upward search is the most transparent, and Make’s include is the one everybody has debugged at some point.

Running the same commands in CI

A task runner earns its keep when local and CI run identical entry points:

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Task
        run: go install github.com/go-task/task/v3/cmd/task@latest
      - run: task ci

Three practices keep this honest. Pin the runner version in CI (@latest above is for readability — real pipelines should pin, so a tool release cannot break your build). One entry point: the CI job calls task ci or just ci, not a re-typed sequence of commands that will silently drift from the local version. And use the listing as documentation — task --list and just --list in a README or a pipeline log tell a new contributor what exists without reading the file.

What about npm scripts?

For a JavaScript-only project, package.json scripts are a legitimate choice: every JS developer already has them, npm run build works with no install step, and npm run lists what exists.

They get awkward when scripts start composing:

{
  "scripts": {
    "prebuild": "npm run clean",
    "build": "tsc && vite build",
    "clean": "rimraf dist",
    "test": "vitest run",
    "ci": "npm run lint && npm run test && npm run build"
  }
}

At that point you have invented a task runner inside JSON — with worse syntax, no arguments, and lifecycle hooks that fire in surprising ways. The pragmatic split: keep per-package scripts in package.json, and put the top-level orchestration in Just or Task.

Choosing

Pick by the constraints, not the aesthetics:

  • Make, when the project already has a Makefile, when you need real incremental builds, or when the audience is C/C++/Go and Make is the house language.
  • Just, when you want a command runner that reads like a Makefile without Make’s quirks — strong default for a personal project or a team comfortable with the terminal.
  • Task, when you want YAML, descriptions out of the box, optional incremental checks, or shared Taskfiles across repositories.
  • npm scripts, when the project is JavaScript-only and the script list still fits on one screen.

A test worth applying before standardizing: write the three commands you run most often in each tool, hand the file to a teammate who has not seen it, and ask them to run the third one. The tool they can use without asking you a question is the right one for your team.

Migration is also cheaper than it looks. Because all three are thin wrappers around shell commands, moving from npm scripts to Just is usually an afternoon of copying command strings — the logic was never in the tool. Teams have also switched the other way, from a sprawling Makefile back to a handful of npm scripts, when it turned out they were maintaining a build system for a site that only needed two commands.

Whichever you choose, put the file in the repository root, give every task a description, and make sure ci is just another task. The goal is that a new contributor can clone the project and run the whole pipeline without reading the README first.

Frequently asked questions

Do I need a task runner if I already have npm scripts?
Not always. npm scripts cover single commands and simple chains well. A dedicated runner earns its place when you need dependencies between tasks, arguments, conditional logic, or the same commands available to non-JavaScript team members.
Is Make still worth learning in 2026?
Yes, because you will meet it. Makefiles ship with C/C++ projects, Docker setups, and countless legacy repositories. Understanding targets, prerequisites, and automatic variables takes an afternoon and pays off whenever you touch someone else's build.
Which one works best on Windows?
Just and Task both run natively on Windows with no extra layer. Make typically requires WSL, MSYS2, or Git Bash, which is the most common reason teams drop it on mixed environments.
Can these tools replace shell scripts entirely?
They replace the entry points, not the logic. Keep substantial logic in proper scripts or programs, and let the task file call them — a task file full of multi-hundred-line shell blocks is a maintenance problem in disguise.