Appearance
How Scanning Works
Pipeline
Every scan runs the same pipeline regardless of what triggered it:
- Clone — a shallow, single-commit checkout of exactly the commit being scanned (not the whole repository history).
- Static analysis — deterministic tools run in sequence:
- Gitleaks for exposed secrets (API keys, credentials committed by accident).
- Semgrep for known vulnerability patterns, with language-specific rule packs layered on top of a baseline OWASP/security-audit pack.
- OSV-Scanner for known-vulnerable dependencies, reading whatever lockfile the project already has (
package-lock.json,composer.lock,go.sum, etc.) — nothing extra to configure. Findings say whether the package is a development-only dependency, since that changes what the advisory means for you — see Development-only dependencies. For Go modules, findings also say whether your code actually calls the vulnerable code — see Go: called or not called. - Trivy for Infrastructure-as-Code misconfigurations — Dockerfiles, Terraform, Kubernetes manifests, CloudFormation — and for restrictive dependency licenses: only strong-copyleft licenses (GPL/AGPL and stricter) are flagged, since those can oblige you to release your own source. Permissive (MIT/Apache/BSD) and weak-copyleft (MPL/LGPL) licenses are intentionally not reported, to avoid burying the ones that actually matter.
- Hadolint for Dockerfile-specific issues — unpinned base images, running as root, unsafe
RUNshell commands (via embedded ShellCheck) — broader Dockerfile coverage than Trivy's misconfiguration checks alone. A repository with no Dockerfiles gets no findings from it. - zizmor for GitHub Actions security — workflows and composite actions under
.github/. It catches script injection through${{ ... }}interpolation intorun:blocks, dangerous triggers (pull_request_targetcombined with checking out untrusted code), actions pinned to a mutable tag instead of a commit hash, over-broadpermissions:, and credential persistence. This is your CI supply chain: a workflow is code that runs with access to your secrets, and no other tool here reads it. A repository with no workflows gets no findings from it. - A repository that doesn't contain a given category of file (no IaC, no Dockerfiles, no workflows, no restrictive-licensed dependencies) simply gets no findings from that tool; none of them ever substitute for the others.
- AI analysis — Claude reviews source files for the class of issue static analysis structurally can't catch: missing authorization checks, business-logic flaws, unsafe assumptions about caller identity. Secrets found by Gitleaks are redacted before any code reaches the model.
- Processing — findings are deduplicated against what's already open for the repository (a finding that already exists doesn't create a duplicate; one that's no longer present gets marked fixed automatically).
Language support
Gitleaks (secrets), OSV-Scanner (dependency CVEs, read from whatever lockfile is present) and zizmor (GitHub Actions workflows) run on every repository regardless of language — none of them is language-specific.
Semgrep's baseline OWASP/security-audit rules also run on every repository, with deeper, language-specific rule packs layered on top for:
JavaScript, TypeScript (plus React and Node.js framework packs), Python (plus Django and Flask), PHP, Go, Java, Ruby, C#, Rust, Kotlin, Scala, Swift, and C.
A repository whose primary language isn't in that list still gets the full baseline coverage — it just misses the extra language-specific rules.
AI analysis is narrower than the deterministic tools: Claude's project-discovery adapters currently cover JavaScript/TypeScript, PHP, Go, Python, Java, C#, and Ruby. A repository whose primary language isn't one of those (for example Rust, Kotlin, Scala, Swift, or C) skips the AI analysis phase entirely and only gets findings from the deterministic tools above.
Scan types
- Full — every eligible source file in the repository. Runs on push and on manual/scheduled/API triggers.
- Diff — only files changed in the pull/merge request. Runs on PR/MR-triggered scans, keeping AI cost proportional to the size of the change rather than the whole repository.
Software Bill of Materials (SBOM)
Every scan also generates a CycloneDX SBOM — a machine-readable inventory of every dependency detected in the repository, in the format tools like Dependency-Track and most compliance workflows expect. The latest one is always available from the Software Bill of Materials card on the repository page as a .cdx.json download.
The SBOM reflects the most recently scanned commit and is regenerated on each scan, so it never goes stale. Generating it reads only your lockfiles and manifests — no extra configuration, and a repository with no dependencies simply produces an SBOM with no components rather than an error.
Development-only dependencies
A dependency reachable only through devDependencies (npm) or require-dev (Composer) is reported as a dev dependency, and the finding says so in its title, impact and recommendation. Your lockfile is the source of that: the package is marked dev-only when no path to it runs through a production dependency group. An unfamiliar group name, or an ecosystem with no such concept at all (Go), counts as production — understating a real risk is the worse error.
This matters because it is most of what sizing a dependency advisory comes down to. A build tool's transitive dependency is not in your production attack surface; it still runs on developer machines and in CI, which is a genuine supply-chain exposure, just not the one the severity implies. The finding is still reported at the severity the advisory published — the scanner does not quietly re-rate someone else's CVSS score — but you are told where the package actually sits.
When a dev-only finding also has no published fix, the recommendation says that marking it Ignored is a defensible call rather than a gap. That combination is common: deepmerge 4.3.1, pulled in by Jest and the Nest CLI, has an open prototype-poisoning advisory and no patched release — and the versions outside the advisory's range are the ones predating its prototype-poisoning guard, so "downgrade to a version not listed as affected" would mean running strictly weaker code.
Go: called or not called
For a vulnerable Go module, the scanner also runs govulncheck's call analysis, which follows calls out of your repository's own code to see whether any of them reach the vulnerable functions the advisory names. The result is added to the finding:
- Not called — the title says
(not called), and the impact explains that the vulnerable code is installed but not reached from your code. The recommendation says the upgrade can wait for routine dependency maintenance rather than an urgent fix. - Called — the impact says the vulnerable code is reachable from your code, not just installed. This is the case to prioritise.
- No label — the advisory names no specific functions, or the analysis could not run (for example a private module the public Go proxy cannot serve, or a
go.modasking for a newer Go than the scanner has). The finding is reported exactly as it would be without call analysis.
As with development-only dependencies, the severity stays at what the advisory published: "not called" is true of the scanned commit, and a later change that calls the vulnerable function would expose it. Call analysis only runs when a scan finds a vulnerable Go module, so repositories in other languages are unaffected, and it only applies to Go — other ecosystems get no called/not-called label.
Cost control
AI analysis result are cached per file (keyed off file content + the active scan policy), so re-scanning an unchanged file — extremely common on repeated pushes to the same branch — costs nothing the second time. This is the single biggest lever on AI spend, and it's on by default.
Your organization's plan sets two independent limits: how many repositories can be actively scanned, and how many scans a single repository can run in a rolling 30-day window. Hitting either limit doesn't silently drop the scan — it still creates a visible failed scan row explaining why, since silently skipping a scan is a trust problem for a security tool, not just an ordinary usage cap.
Model choice (bring your own key)
By default, AI analysis runs on Claude Sonnet 5 using the platform's own key, at no extra cost to you. From Settings → General → AI analysis, you can supply your own Anthropic API key to use Claude Opus 5 instead — spend for those scans is billed directly to your own Anthropic account, tracked separately from platform cost on the same Settings page. Without a key on file, model choice always stays on the platform default, regardless of any prior selection — removing the key reverts immediately.
A key is verified with a real (free) call to Anthropic before it's saved, so a typo or an already-revoked key is caught immediately rather than surfacing later as a failed scan. If a saved key stops working (revoked, expired, billing issue), scans fail with a specific "AI key" error and — if Slack is connected — a notification, rather than a generic failure.
Minimum severity
Each repository has a minimum severity in its scan policy (medium by default). Findings below it are not reported — they are not stored, not counted in the repository's open total, and not shown in the findings list.
Raising the threshold also clears out findings already stored below it, on that repository's next scan. Those are removed rather than marked fixed: nobody fixed them, so counting them as fixes would be wrong. Findings you have marked Ignored or False positive are never removed this way, because that judgment is yours and outlives a policy change. Lower the threshold again and the next scan re-detects everything that is still present.
Before 28 October 2026 this only applied to AI findings
The threshold was enforced on AI analysis but not on the deterministic tools, so Semgrep, Gitleaks, OSV-Scanner, Trivy, Hadolint and zizmor reported everything they found regardless of the setting. If you set a threshold above low and wondered why lower-severity findings still appeared, this was why. It is now applied to every tool, and the next scan of each repository clears the backlog it left behind.
Commit checks
When a scan finishes, the result is published against the scanned commit in your Git provider, so you don't have to open the dashboard to learn whether a push was clean.
On GitHub this is a check run named Security scan. It shows as a ✓ or ✗ on the commit and on any pull request containing it, and each finding is annotated inline on the exact line of the diff it refers to, with its severity and recommended fix. GitHub accepts at most 50 annotations per check, so if a change introduces more than that, the 50 most severe are annotated and the summary says how many remain in the full report.
On GitLab this is a commit status of the same name. GitLab has no equivalent of inline annotations for an external app, so there the detail stays in the merge request note and the dashboard.
The check reflects what the change introduced, not everything open on the repository:
| Outcome | When |
|---|---|
| ✓ Success | The scan found no new findings at or above the repository's minimum severity |
| ✗ Failure | The scan found at least one |
| Neutral | The scan did not finish, so the commit was not assessed |
A repository carrying known findings therefore does not show red on every commit forever — only the commit that introduced something does. A failed scan is deliberately neutral rather than red: a scanner that broke is not evidence about your code, and under branch protection a red mark would block your merge for our outage.
Because there is a single threshold, the check needs no severity setting of its own. Change the repository's minimum severity and the check follows it.
Blocking merges on a failed check
The check is informational until you make it required. To block merges on it, add it to your branch protection rules in GitHub under Settings → Branches → Branch protection rules → Require status checks to pass, and select Security scan. GitLab's equivalent is a merge check on the commit status.
Granting the permission
Publishing a check needs a permission the GitHub App did not originally request, so repositories connected before this feature shipped will not show checks until an account owner approves it. GitHub emails the owner and shows a banner on the installation; until then, scans run and store findings exactly as before and only the check is missing. See Connecting repositories for what the App asks for and why.
GitLab needs nothing extra — the existing api scope already covers commit statuses.
Excluding paths
Semgrep skips anything listed in a repository's Excluded paths (repository page → scan policy), using gitignore pattern syntax — one pattern per line.
This is for third-party source committed into the repository. Vendored front-end libraries under a public/ directory are the common case, and they are expensive twice over: on one real Laravel repository, 133MB of committed libraries produced 133 of its 134 Semgrep findings and took the scan from 7 seconds to 119 — none of those findings being code anyone on the team could fix.
Only Semgrep honours these. Secret scanning still reads every file — a credential committed under public/assets is a real credential — and dependency scanning works from lockfiles, so excluding paths there would lose findings rather than noise.
Partial scans
If one deterministic tool fails, the scan finishes without it rather than failing outright, and says so: "Partial scan — semgrep did not run". The other tools' findings are real and are saved normally.
The exception is Gitleaks, which still aborts the scan. Its results drive the redaction of secrets before any code is sent for AI analysis, so continuing without it would risk leaking a secret into the model rather than merely missing a class of finding. A scan where every tool failed also fails, since "no findings" must never be shown for a repository nothing actually checked.
Turning AI analysis off
AI analysis is on by default. If you'd rather run only the deterministic tools — for a repository where you want to keep every scan entirely local to the deterministic scanners, to cut AI cost, or simply because the AI phase isn't useful for that project — turn off Include AI analysis in the repository's scan policy. Deterministic findings (Gitleaks, Semgrep, OSV-Scanner, Trivy, Hadolint, zizmor) still run exactly as before; only the AI review phase is skipped, and the scan notes that AI was skipped by configuration rather than failing.
Scan status
| Status | Meaning |
|---|---|
queued | Waiting for a worker to pick it up |
cloning → static_analysis → ai_analysis → processing | In progress |
completed | Findings are up to date as of this commit |
failed | See the scan's error message — most commonly a lost Git provider connection (a "Reconnect" link is shown directly) or a plan limit |
Scheduled scans
Scheduled scans are off by default. Turn them on per-repository from the repository's scan policy, and a repository whose last scan is more than 23 hours old is then re-scanned by a daily sweep, even with no new commits. This exists specifically to catch newly-disclosed CVEs in dependencies that haven't changed, since OSV-Scanner's database updates independently of your code.
Before turning it on, check it against your plan's scan cap: the sweep runs daily, so a scheduled repository uses about 30 scans every 30 days on its own. On the Free plan that is the entire per-repository allowance, leaving nothing for push and pull request scans.