Programmable CI English: Dagger and Earthly Vocabulary

Introduction

Traditional CI systems use YAML to describe pipelines, but tools like Dagger and Earthly take a different approach: they let you write your pipelines in actual programming languages or a Makefile-like syntax. This shift brings new vocabulary that engineers use when discussing these tools. If your team is adopting programmable CI, you will encounter terms like modules, caching layers, reproducibility, and pipeline as code in daily discussions. This guide explains the key concepts and the English phrases engineers use around them.

Dagger: Pipelines in Code

Dagger lets you write CI pipelines in Python, Go, TypeScript, or other languages. The core vocabulary:

• Dagger module — a reusable package of pipeline functions; “we publish a module for our linting pipeline”
• function — the unit of work in Dagger; “we define a function that builds the Docker image”
• pipeline — a composed series of functions; “we wire the functions into a pipeline”
• containerise — run a pipeline step inside a container; “each function runs containerised for isolation”
• call — invoke a Dagger function; “we call the test function from the build function”

A key Dagger concept is that everything runs in containers. Engineers describe this as: “We get isolation and reproducibility for free because every step runs in a defined container.” The phrase “runs containerised” is specific to Dagger discussions.

The Dagger Engine is the daemon that executes the pipeline. Engineers say “the engine caches intermediate results between runs” — meaning if you re-run a pipeline and the inputs have not changed, Dagger reuses cached container layers.

When engineers discuss Dagger’s value proposition, they often say: “We write our CI logic in Python, the same language as our application code — this means developers can test the pipeline locally before pushing.” The phrase “test locally” is a key selling point: Dagger pipelines run identically on a developer’s laptop and in CI.

Earthly: Makefile meets Docker

Earthly uses its own syntax (Earthfiles) that combines the target-based approach of Makefiles with Docker-style layer caching. The vocabulary:

• Earthfile — the file that defines targets, similar to a Makefile
• target — a named unit of work in an Earthfile; “we define a +test target and a +docker target”
• artifact — a file produced by a target and saved for later steps; “the build target produces a binary artifact”
• image — a Docker image produced by a target; “the +docker target produces the final image”
• “Save artifact” — Earthly’s syntax for capturing output from a step; a phrase that appears literally in Earthfiles
• reproducible build — a build that produces identical output given identical input, regardless of environment

Engineers say: “Earthly gives us reproducible builds because every target runs inside a container with a defined environment.” The word reproducible is central to Earthly’s marketing and documentation, and engineers use it consistently.

Earthly’s caching is described with Docker-layer vocabulary: “We cache the dependency installation step — if the go.sum file hasn’t changed, Earthly reuses the cached layer and skips the download.” The phrase “skips the step” or “reuses the cached layer” is common in discussions about build optimisation.

Shared Vocabulary: Programmable CI

Both tools share vocabulary that applies to programmable CI generally:

• pipeline as code — the principle that CI pipelines should be written in a real programming language or structured syntax, versioned alongside application code
• “Run the pipeline locally” — execute CI steps on a developer’s machine; a key advantage of both tools
• “Cache invalidation” — when a cached step is outdated and must be re-run; “changing the Dockerfile invalidates the cache for that layer and everything after it”
• DAG (Directed Acyclic Graph) — the dependency graph of pipeline steps; “Dagger builds a DAG of your functions and executes independent steps in parallel”
• “Parallelise steps” — run independent pipeline steps at the same time to reduce total build time

A common architecture discussion phrase: “We moved from a YAML-based CI configuration to Dagger because YAML doesn’t compose well — with Dagger, we can write reusable functions and call them across multiple pipelines.”

Key Vocabulary

Term	Definition
pipeline as code	CI pipelines written in a real programming language and versioned with the app
Dagger module	A reusable package of Dagger pipeline functions
Earthfile	The file that defines Earthly targets, analogous to a Makefile
target	A named unit of work in an Earthfile
artifact	A file produced by a build step and captured for later use
reproducible build	A build that produces identical output given identical inputs
cache invalidation	When a cached step is outdated due to input changes
DAG	Directed Acyclic Graph — the dependency structure of pipeline steps
containerised	Running in an isolated container with a defined environment
run locally	Execute CI pipeline steps on a developer’s machine

Practice Tips

1. Explain “pipeline as code” to a sceptical colleague in English. Practise this explanation: “With YAML, you can’t write unit tests for your pipeline logic. With Dagger, your pipeline is a Python function — you can write tests for it, import it in other pipelines, and run it locally with the same result as in CI.”

2. Use “reproducible” precisely. In build tooling discussions, “reproducible” means the same inputs always produce the same outputs. Practise using it in context: “Our Earthly build is reproducible because every step runs in a pinned container image with no ambient dependencies.”

3. Discuss cache invalidation in English. “The cache was invalidated when we updated the base image” is a common explanation for unexpectedly slow builds. Understanding this phrase helps you debug and communicate build performance issues.

4. Read Dagger and Earthly GitHub issue trackers. Real-world problems and their solutions are discussed in plain English. This is excellent practice for reading technical English in a real context.

Conclusion

Programmable CI tools like Dagger and Earthly are growing in adoption, and their vocabulary — pipeline as code, reproducible builds, cache invalidation, modules, targets — is becoming standard in DevOps and platform engineering discussions. Mastering these terms helps you evaluate tools, contribute to migration discussions, and write clear documentation about your CI architecture. The shift from YAML to code is as much a conceptual shift as a technical one.