Most DevSecOps checklists were written for a world where people wrote the code, picked the dependencies and pressed the merge button. In 2027, that is no longer true. AI assistants write a growing share of every pull request, coding agents install packages on their own, and attackers publish malware that has no CVE and no signature on the day it lands.
The basics still matter: scan your code, protect your secrets, harden your pipelines. But the order of priorities has changed, and some checks that used to be optional are now the ones that stop real incidents. This DevSecOps checklist is built for that reality: 40 checks across ten areas, written so you can copy them into your own backlog and start in January.
TL; DR
The DevSecOps checklist for 2027: 40 checks for teams where AI writes the code
The basics still matter, but the priorities have changed. A DevSecOps checklist for 2027 has to cover AI-written code, agents that act on their own, malware without a CVE and regulation with real deadlines.
- AI changed the threat model: assistants write code faster than anyone can review it, and coding agents install dependencies with your permissions. Checks must run where the code is written, not only in CI.
- Signatures are too slow: the 2026 supply chain campaigns spread through malicious packages long before any CVE existed. Malware detection and a minimum package age are now baseline controls.
- Regulation got dates: CRA reporting duties have applied since 11 September 2026, EU AI Act high-risk obligations start on 2 December 2027, and the full CRA applies from 11 December 2027.
- Kontrol-zerrenda: 40 checks across ten areas: plan, code, dependencies, secrets, CI/CD and build, IaC and cloud, runtime and APIs, AI assets and agents, developer endpoints, and governance.
- The rollout: close the doors attackers use today in the first 30 days, move security into the IDE and agents by day 60, and prove it for audits by day 90.
Lehen urratsa: tick the checks you already pass, start with secrets detection, malware detection for dependencies and pinned CI actions, and turn the rest into your 2027 backlog.
What changed in DevSecOps for 2027
Four shifts explain why last year’s DevOps security checklist is no longer enough.
1. AI writes the code, and agents act on it. Copilot, Cursor, Claude Code, and similar tools now generate a large share of new code, and in agent mode they run commands, edit configuration, and add dependencies. Every check that relies on a person noticing a problem in review is weaker when the volume of changes doubles. We covered the agent side in detail in our posts on AI agent security and GitHub Copilot security.
2. Malware arrives before the CVE. Self-propagating worms such as Shai-Hulud and compromised releases like LiteLLM 1.107.0 reached developers through trusted registries and pipelines. Some even carried valid provenance. Controls that only ask “is this package known to be bad?” answer no, and let it through.
3. Attackers move at machine speed. In July 2026, an autonomous AI agent breached Hugging Face’s infrastructure and executed more than 17,000 actions over a weekend. Periodic reviews and weekly scans cannot keep up with that pace. Read the full story in our breakdown of the Aurpegi Besarkatuaren Segurtasun Gertakaria.
4. Regulation now has deadlines:
The regulatory deadlines behind your DevSecOps checklist
What already applies, and what lands in 2027.
NIS2 and DORA
Supply chain risk management and evidence for regulated sectors such as finance and critical infrastructure.
EU Cyber Resilience Act (CRA): reporting
Manufacturers must report actively exploited vulnerabilities and severe incidents: early warning within 24 hours, notification within 72 hours.
EU AI Act, high-risk systems (Annex III)
Postponed from August 2026 by the Digital Omnibus. Requires an inventory and risk classification of the AI you build and deploy.
EU Cyber Resilience Act (CRA): full application
Secure-by-design requirements, vulnerability handling and documentation for products with digital elements.
Sources: CMS on the CRA reporting regime, Orrick on the AI Act Digital Omnibus.
Watch on demand: 24 Hours to Report: Surviving the Cyber Resilience Act (CRA) Notification Clock, with Jesús Cuadrado (Xygeni) and Nariman Aga-Tagiyev (SecureHabits): what starts the 24-hour clock, and how to go from SBOM to a report your team can file in time.
The DevSecOps checklist: 40 checks for 2027
Use this DevSecOps security checklist as a self-assessment: tick what you already do, and the unticked items become your 2027 backlog.
1. Plan and design
- Every new service or feature gets a lightweight threat model before work starts.
- Security requirements (authentication, data handling, logging) are part of the definition of done.
- Each application has a named owner for security findings.
- You keep an up-to-date inventory of applications, repositories, and the teams behind them.
2. Code, including AI-written code
- SAST runs in the IDE and on every pull request, not only in a nightly job.
- AI-generated code goes through the same scans and policies as human-written code, before it is commitTed
- AI coding agents can call your security tools inside their own loop (for example through MCP), so they fix issues while they work.
- Findings are triaged by exploitability and reachability, so developers see the few that matter, not hundreds of alerts.
3. Open-source dependencies
- SCA guztietan exekutatzen da pull request and blocks new Critical vulnerabilities with an available fix.
- Malicious packages are detected before a CVE or signature exists, not only through known advisories.
- New package versions must reach a minimum age (for example, five days) before they can be installed.
- Lockfiles are committed and reviewed, and CI installs with
npm ci --ignore-scriptsor the equivalent for your ecosystem.
4. Secrets
- Secrets detection runs in the IDE, in pre-commit hooks, and in CI, including the full Git history.
- Push protection blocks commits that contain credentials.
- Credentials live in a secrets manager and are short-lived and narrowly scoped.
- Every leaked secret is revoked and rotated, not only removed from the code.
5. CI/CD eta eraiki
- Pipeline configurations are scanned for risky patterns such as untrusted input in scripts and over-privileged tokens.
- Third-party actions and plugins are pinned to a commit hash, not a mutable tag.
- Builds produce an SBOM and provenance attestations (for example, SLSA), and you verify them before release.
- Release gates fail on High and Critical issues, not only on Critical.
6. Infrastructure as code and cloud
- IaC templates (Terraform, Kubernetes, CloudFormation) are scanned before they are applied.
- Container images are minimal, run as non-root, and are rebuilt when the base image is patched.
- Workloads use least-privilege identities with short-lived credentials, not long-lived service account keys.
- Drift between IaC and the running environment is detected and reviewed.
7. Runtime and APIs
- DAST runs against staging on every release, and incrementally on high-risk changes.
- You keep an API inventory built from the code, not only from the OpenAPI spec, to catch shadow and orphan endpoints.
- Authorization checks (ownership, roles) are tested for every exposed API operation.
- Before major releases, exploitability is validated with pentesting, manual or AI-driven.
8. AI assets and AI agents
- You keep an inventory of the models, datasets, agents, MCP servers, and prompts in your repositories, exportable as an AI-BOM.
- AI code is scanned for risks such as prompt injection, unsafe model loading, and model output reaching dangerous sinks, mapped to the OWASP Top 10 for LLM Applications.
- Agent skills and instruction files (
SKILL.md,AGENTS.md) are reviewed before anyone installs them. - Agents and MCP servers run with the smallest set of tools, credentials, and network access their task needs.
9. Developer endpoints
- Package installs on developer machines are checked against malware verdicts and minimum-age rules, whoever runs them, a person or an agent.
- IDE extensions and plugins are restricted to an approved list.
- Coding agents run in a sandbox, away from host credentials.
- A compromised developer machine can be isolated quickly.
10. Governance and compliance
- All findings flow into one prioritized view, whichever scanner produced them, instead of one console per tool.
- You can produce vulnerability and incident reports within the CRA’s 24-hour and 72-hour windows.
- Findings are mapped to the frameworks your auditors use (OWASP, NIST, PCI DSS, NIS2, DORA).
- Security metrics such as mean time to remediate and open Critical findings are reviewed every month.
How to roll out this DevSecOps checklist in 90 days
Forty checks at once will stall any team. Roll them out in three stages, starting with the controls that stop real attacks.
- Days 1 to 30: close the doors attackers use today. Turn on secrets detection and push protection, add malware detection and a minimum package age for dependencies, pin your CI actions, and rotate any credential you find in code. Run every new check in non-blocking mode first, so you see the baseline without breaking builds.
- Days 31 to 60: move security to where code is written. Gehitu SAST SCA to the IDE and to every pull request, connect your AI coding agents to your security tools, and start gating merges on Critical findings with an available fix. Build the inventory of your applications, APIs, and AI assets.
- Days 61 to 90: prove it and prepare for audits. Sortzen SBOMs and provenance for every release, add DAST on staging, bring all findings into one prioritized view, and rehearse a CRA-style report within 24 and 72 hours. Then raise the release gate to High and Critical.
After 90 days, review the checklist again. The unticked items are your plan for the rest of 2027.
One checklist, one platform
A DevSecOps checklist only works if the checks run every day without slowing developers down. Ten areas usually mean ten tools, ten consoles, and ten queues, and that is where good intentions die.
Xygeni covers this checklist in one platform. AI SAST, SCA, Secrets Security, IaC Security, CI/CD Security, and DAST run with native engines, and Malwarearen aurkako babesa flags malicious packages before a signature exists. The IDE plugins and the Xygeni MCP zerbitzaria bring the same checks to developers and to AI coding agents before the commit. AI Segurtasuna inventories the models, agents, and MCP servers in your code, Shield enforces package rules on developer machines, and ASPM puts every finding in one prioritized view, including the ones from the scanners you already run.
Want to see how many of the 40 checks you can tick in your first week? Hasi doan, ez da kreditu txartelik behar, edo erreserbatu demo bat gure taldearekin.
DevSecOps checklist FAQs
What is a DevSecOps checklist?
A DevSecOps checklist is a list of security practices built into each stage of software delivery, from planning and coding to dependencies, pipelines, infrastructure, and runtime. It helps teams check what they already cover and decide what to add next.
What is the difference between a DevOps security checklist and a DevSecOps checklist?
In practice, they cover the same ground. “DevOps security checklist” usually refers to securing pipelines and infrastructure, while “DevSecOps checklist” stresses that security checks run inside the development workflow itself, owned by developers as well as security teams.
What should a DevSecOps checklist include in 2027?
Beyond SAST, SCA, and secrets, a 2027 checklist should cover AI-written code, AI agents and MCP servers, malware detection that works before a CVE exists, developer endpoint protection, SBOMs and provenance, and evidence for regulations such as the CRA, NIS2, DORA, and the EU AI Act.
How do I start with DevSecOps?
Start with the controls that stop real attacks fastest: secrets detection, malware detection for dependencies, and pinned CI actions. Run new checks in non-blocking mode, then gate on Critical findings once teams have cleaned up the baseline.
How does AI change DevSecOps?
AI increases the volume of code and lets agents act with developer permissions. Security checks have to run where code is written, in the IDE and inside the agent’s loop, and the AI assets in your applications need their own inventory and risk scanning.







