Inspect .gitlab-ci.yml as the dependency graph it is — needs cycles, forward references, rules alongside only, shared cache keys and unguarded deploys.
Waiting for .gitlab-ci.yml
No GitLab instance is contacted and no pipeline is triggered.
The findings appear here
A needs cycle, a dependency on a renamed job, rules alongside only, a fixed cache key shared across branches, and a deploy with no conditions on it.
This reads the file as YAML. It does not contact GitLab, run the CI lint, resolve an include from another project, or expand a !reference — so a job defined by an include is invisible here, and a file that reads cleanly can still be rejected.
GitLab CI Inspector runs entirely on your device — credential-shaped variables are reported by name only, and no pipeline is triggered.
You’re on the Free plan. Compare plans
A GitLab pipeline is a graph twice over: `stages` orders things coarsely, and `needs` overrides that with a DAG. The mistakes that cost the most time are graph mistakes — a `needs` pointing at a job that was renamed, a `needs` pointing forward into a later stage, which GitLab rejects outright, a cycle, or a job whose `stage` is not in the `stages` list at all.
None of those are visible by reading one job, and all of them are cheap to find by building the graph. The start order is shown as well, which is the fastest way to confirm a pipeline will run the way you think it will.
The other recurring trap is `rules` alongside `only` or `except`. GitLab fails the pipeline rather than preferring one, and the error does not always name the job — so a file that worked for a year breaks the moment someone adds a `rules` block to a job that still had an `only`.
Configuration on a hidden template is checked, because it is inherited. An `image: node:latest` on a `.node` template is a `latest` tag on every job that extends it, and reporting it once against the template is both accurate and less noisy than reporting it on each job.
Nothing is triggered. No GitLab instance is contacted, no `include:` from another project is resolved, and no `!reference` is expanded — so a job defined by an include is invisible here, and a file that reads cleanly can still be rejected.
Because a job has both `rules` and `only` or `except`. GitLab does not prefer one — it fails the whole pipeline. `rules` is the current form and expresses everything only/except can, so the only/except keys are the ones to remove.
No. needs can skip ahead past earlier stages but cannot look forward — GitLab rejects a dependency on a job in a later stage. This builds the graph against your declared stage order and reports it as an error.
Every branch and every change shares one cache entry, so a stale dependency set from another branch can be restored over a correct one. The result is a failure that disappears when the cache is cleared and comes back later. `key: files: [package-lock.json]` rekeys when the lockfile changes.
No. It reads the file you paste and nothing else, so a job or template defined by an include is invisible. Where includes are present, a missing reference is reported as a warning rather than an error, because the include may well supply it.