Author SHA1 Message Date
sneak 15aab336ad Check builds use Docker's normal cache (closes #177)
check / check (push) Successful in 12s
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 and re-vendoring it in one
commit are gone; the rule that a planted defect proves a new or changed
check stays. The README, the Go style guide and both checklists restated
the cache-busting rules and are updated to match. The existing-repo
checklist asks that no script pass --no-cache or CACHEBUST.

Model: opus-5-5
2026-11-16 21:49:00 +00:00
3 changed files with 33 additions and 8 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`.
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
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 .`
passing while the gate never runs. Confirm by planting a violation, not by
reading the file.
- [ ] No `docker build` in `script/` passes `--no-cache` or a cache-busting
build argument such as `CACHEBUST`, and no `Dockerfile` stage declares
`ARG CACHEBUST`.
- [ ] Go: each Go stage downloads the modules (`COPY go.mod go.sum ./`,
`RUN go mod download`) before `COPY . .`; the steps that compile
(`golangci-lint run`, `go test`, `go build`) mount Go's build cache
+26 -8
View File
@@ -297,6 +297,23 @@ style conventions are in separate documents:
- the settings
- 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
Nothing needs to run again on an unchanged tree. Never prune the build cache
(`docker builder prune` and the like): it is shared with every other build
on the host. When a check is added or changed, prove it works:
- plant a defect it must catch
- watch the run fail on it
- revert the defect
A green run alone shows neither that the check ran nor that it covers what
it should.
- **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
hash), so lint failures surface in seconds rather than after a full compile.
@@ -600,7 +617,8 @@ style conventions are in separate documents:
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.
`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
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
@@ -714,13 +732,13 @@ style conventions are in separate documents:
tests. It leaves the build cache alone, so it costs the runtime of the suite
and no recompilation.
That cache is Go's own. Go stores a passing result in its cache directory
(`GOCACHE`). When the same tests run again on unchanged code, it prints that
result, marked `(cached)`, without running them. The directory lasts from
one run to the next on a developer's machine, where this target runs. The
directory also lasts in the `test` phase of the `Dockerfile`, which mounts
it to keep compiled packages between check builds, so the phase's `go test`
runs carry `-count=1` too.
That cache is Go's own, separate from Docker's layer cache. Go stores a
passing result in its cache directory (`GOCACHE`). When the same tests run
again on unchanged code, it prints that result, marked `(cached)`, without
running them. The directory lasts from one run to the next on a developer's
machine, where this target runs. The directory also lasts in the `test`
phase of the `Dockerfile`, which mounts it to keep compiled packages between
check builds, so the phase's `go test` runs carry `-count=1` too.
Python example: