Secure Code Review in CI
An audit tells you what is wrong today. A tuned static analysis pipeline tells you the next time somebody writes the same mistake. We set it up, write rules for your codebase, and get the noise low enough that your team keeps it switched on.
Semgrep rules written against your own patterns, a triaged baseline of existing findings, pull request gating that fails on what matters, plus dependency and secret scanning wired into the same pipeline.
What we cover
Tool setup
Static analysis running in your existing CI, whether that is Gitea Actions, GitHub Actions, GitLab CI or something self-hosted.
Custom rules
Rules written against the patterns in your codebase and your framework conventions, which is where the generic rule packs are weakest.
Baseline triage
The first run on a mature codebase produces hundreds of findings. We go through them, separate real from noise, and agree a baseline so only new issues block work.
Noise reduction
Tuning, suppressions and scoping until the signal is worth reading. This is the difference between a pipeline a team keeps and one it disables.
Gating policy
Which findings fail a pull request, which warn, and which are logged for later, agreed with your team rather than imposed as defaults.
Dependencies and secrets
Known vulnerabilities in Composer and npm packages, and credentials committed to history, checked in the same pipeline.
Our code audits produce a point-in-time answer. They are worth having, but a report describes the codebase on the day we read it. Six months of commits later, somebody has written the same unescaped output in a new template, because nothing in the development process was changed by the report.
Static analysis in the pipeline is how that stops happening. Instead of finding the pattern once, the pattern becomes a rule, and the rule runs on every pull request.
The problem is noise, not installation
Adding Semgrep to a pipeline takes an afternoon. Almost anybody can do it, and plenty of teams have. The reason most of those pipelines are no longer running is that the first scan of a mature codebase returns several hundred findings, a large share of them irrelevant, and a developer who has had three pull requests blocked by a false positive will quite reasonably turn it off.
So the work that matters is the unglamorous part. Establishing a baseline so historic findings do not block current work. Tuning rules until a failure means something. Deciding, with the team rather than for them, which categories are worth blocking a merge over and which belong in a report nobody is forced to read at 5pm on a Friday.
A pipeline that reports five findings a month and is right about all five changes behaviour. A pipeline that reports four hundred changes nothing.
Rules written for your code
Generic rule packs catch generic mistakes. They do not know that your application has a particular base controller every route is supposed to extend, or an internal helper that must be used for any outbound HTTP call, or a convention about where authorisation checks live.
Those project-specific invariants are exactly the things that break quietly as a team grows and nobody remembers the convention. They are also straightforward to express as rules once somebody has read enough of the codebase to know what the conventions are, which is the part we are already doing during an audit.
The rules we write are yours. They live in your repository, in plain text, and your team can read, extend and delete them without us.
Where this sits alongside our other work
This is the natural follow-on to a code audit, and the two are better together: the audit finds the patterns, the pipeline stops them coming back. It also works as standalone work on a codebase we have never audited, though the rules will be more generic to begin with.
It is also the cheapest way to keep AI features honest as they ship. Rules can flag a model response being written into a page or a query without escaping, a tool handler added without an authorisation check, and credentials pasted into a system prompt. Those are the patterns behind most of the findings in our AI and LLM application security work, and they are far cheaper to catch on the pull request that introduces them.
What you get
01
Working pipeline configuration committed to your repository
02
A custom rule set written for your codebase, yours to keep and extend
03
A triaged baseline separating real findings from noise
04
A short runbook covering how to add rules and handle findings
05
A handover session with the developers who will live with it
Other services
Every engagement starts with a conversation about scope. Tell us what you have built and what worries you about it, and we will tell you what a useful assessment looks like.