Author SHA1 Message Date
sneak ca36d0372c Check builds use Docker's normal cache (closes #177)
check / check (push) Successful in 1m33s
Drop the CACHEBUST build argument from script/lint, script/test,
script/docker, script/cibuild and every Dockerfile stage. REPO_POLICIES
now says check builds use Docker's normal cache: an unchanged tree reuses
each step's stored result, which Docker keeps only for steps that
succeeded. The rules on placing ARG CACHEBUST, re-vendoring it in one
commit and planting a defect to prove a changed check are gone. The
README, the Go style guide and both checklists restated those rules and
are updated to match.

Model: opus-5-5
2026-11-16 21:17:42 +00:00
3 changed files with 31 additions and 12 deletions

No files matched your search

+4
View File
@@ -144,6 +144,10 @@ alpine. We provide:
`make hooks` installs the pre-commit hook that runs `script/precommit`. `make hooks` installs the pre-commit hook that runs `script/precommit`.
The builds use Docker's normal cache: a step runs again only when its inputs
change. This repo's own `Dockerfile` installs git, make, node and yarn right
after `FROM` in every stage, so a change to `script/` keeps that layer.
## Rationale ## Rationale
LLM prompts, especially development policies, benefit from version control and a LLM prompts, especially development policies, benefit from version control and a
+3
View File
@@ -49,6 +49,9 @@ with your task.
`--target` names it, so a lost `COPY --from=` edge leaves `docker build .` `--target` names it, so a lost `COPY --from=` edge leaves `docker build .`
passing while the gate never runs. Confirm by planting a violation, not by passing while the gate never runs. Confirm by planting a violation, not by
reading the file. reading the file.
- [ ] Check builds use Docker's normal cache: no `docker build` in `script/`
passes a build argument whose only job is to make steps run again, and no
`Dockerfile` stage declares one.
- [ ] Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`, - [ ] Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`,
`RUN go mod download`) before `COPY . .`; the steps that compile `RUN go mod download`) before `COPY . .`; the steps that compile
(`golangci-lint run`, `go test`, `go build`) mount Go's build cache (`golangci-lint run`, `go test`, `go build`) mount Go's build cache
+24 -12
View File
@@ -243,9 +243,10 @@ style conventions are in separate documents:
The development environment stage installs development prerequisites by The development environment stage installs development prerequisites by
running `script/bootstrap`. Only system packages may be installed inline running `script/bootstrap`. Only system packages may be installed inline
above it, so that check builds keep them; the `prompts` repo's own above it, so that a change to `script/` does not install them again; the
`Dockerfile` does this. A stage that runs `script/bootstrap` COPYs `script/` `prompts` repo's own `Dockerfile` does this. A stage that runs
and the dependency manifests it needs before running it. These are examples: `script/bootstrap` COPYs `script/` and the dependency manifests it needs
before running it. These are examples:
- `package.json`, `yarn.lock`, `.yarnrc.yml` and `.yarn/releases/` - `package.json`, `yarn.lock`, `.yarnrc.yml` and `.yarn/releases/`
- `go.mod` and `go.sum` - `go.mod` and `go.sum`
@@ -297,6 +298,16 @@ style conventions are in separate documents:
- the settings - the settings
- the golangci-lint version - the golangci-lint version
- **Check builds use Docker's normal cache.** On an unchanged tree Docker reuses
each step's stored result, and it stores a result only for a step that
succeeded. A step runs again when one of these changes:
- the base image
- its own line or a line above it
- the files copied before it
Never prune the build cache (`docker builder prune` and the like): it is
shared with every other build on the host.
- **The gate phases are separate stages, and the build stage depends on both.** - **The gate phases are separate stages, and the build stage depends on both.**
The lint phase is based on the `golangci/golangci-lint` image (pinned by The lint phase is based on the `golangci/golangci-lint` image (pinned by
hash), so lint failures surface in seconds rather than after a full compile. hash), so lint failures surface in seconds rather than after a full compile.
@@ -480,7 +491,7 @@ style conventions are in separate documents:
already do. already do.
- **A Python `test` phase that installs its packages from `Pipfile.lock` does it - **A Python `test` phase that installs its packages from `Pipfile.lock` does it
before `COPY . .`, so check builds keep them.** The steps are: before `COPY . .`, so a change to the code keeps them.** The steps are:
- `COPY script/ script/` - `COPY script/ script/`
- `COPY Pipfile Pipfile.lock ./` - `COPY Pipfile Pipfile.lock ./`
- `RUN script/bootstrap` - `RUN script/bootstrap`
@@ -600,7 +611,8 @@ style conventions are in separate documents:
A new push then cancels the older run on the same branch, queued or running, A new push then cancels the older run on the same branch, queued or running,
and no other: runs for replaced commits do not hold up the shared runner. and no other: runs for replaced commits do not hold up the shared runner.
`script/cibuild` bootstraps, runs the gate phases, and then builds the image, `script/cibuild` bootstraps, runs the gate phases, and then builds the image,
so a successful run means every check passed. The `check` job sets so a successful run means every check passed. The image build reuses the gate
phases that the check has just built. The `check` job sets
`timeout-minutes: 20`, so a hung build frees the shared runner after 20 `timeout-minutes: 20`, so a hung build frees the shared runner after 20
minutes. That allows for the three Docker builds described above, each held to minutes. That allows for the three Docker builds described above, each held to
the 5-minute Docker build limit below, plus the bootstrap. Those builds are the 5-minute Docker build limit below, plus the bootstrap. Those builds are
@@ -714,13 +726,13 @@ style conventions are in separate documents:
tests. It leaves the build cache alone, so it costs the runtime of the suite tests. It leaves the build cache alone, so it costs the runtime of the suite
and no recompilation. and no recompilation.
That cache is Go's own. Go stores a passing result in its cache directory That cache is Go's own, separate from Docker's layer cache. Go stores a
(`GOCACHE`). When the same tests run again on unchanged code, it prints that passing result in its cache directory (`GOCACHE`). When the same tests run
result, marked `(cached)`, without running them. The directory lasts from again on unchanged code, it prints that result, marked `(cached)`, without
one run to the next on a developer's machine, where this target runs. The running them. The directory lasts from one run to the next on a developer's
directory also lasts in the `test` phase of the `Dockerfile`, which mounts machine, where this target runs. The directory also lasts in the `test`
it to keep compiled packages between check builds, so the phase's `go test` phase of the `Dockerfile`, which mounts it to keep compiled packages between
runs carry `-count=1` too. check builds, so the phase's `go test` runs carry `-count=1` too.
Python example: Python example: