security-devsecops — Claude Code skill: what it does, how to install
security-devsecops — a skill for Claude Code and Codex guides DevSecOps and AppSec practices across projects. Activates when handling credentials, user input, auth, or configuring CI/CD pipelines.
Apache-2.0 117 installs ★ 312 updated 2026-10-08
npx skills add Mindrally/skills --skill security-devsecops -a claude-codeWhat security-devsecops does
The skill enforces a seven-step secure development workflow covering boundary identification, sanitization, secret hygiene, and automated delivery gates. It guides how code accepts external input, processes database queries, and reports security-relevant architecture changes in pull requests.
It explicitly prohibits hardcoded credentials, directing sensitive values to environment variables or dedicated secret stores like Doppler and AWS Secrets Manager. Database operations require parameterized queries or ORMs rather than string concatenation. Authentication and access control rules mandate server-side authorization checks on every request, rejecting custom cryptographic schemes in favor of audited libraries.
Failures emitted by CI scanning tools are treated as hard deployment blockers, barring suppressions without recorded audit notes.
What it helps with
- configure SAST, SCA, and IaC scanning checks inside CI/CD gates
- prevent credentials and session tokens from leaking into commits or logs
- replace dynamic SQL string interpolation with parameterized queries
- enforce server-side resource ownership validation on API routes
Example prompts for the agent
- Review this API route for missing authorization checks and validate input
- Add dependency vulnerability scanning with pip-audit to our CI pipeline
- Refactor this database query to use parameterization instead of string formatting
How to install security-devsecops
1Skills CLI (Vercel)
npx skills add Mindrally/skills --skill security-devsecops -a claude-code2Manually: put the files in place
~/.claude/skills/security-devsecops/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/security-devsecops/
1Skills CLI (Vercel)
npx skills add Mindrally/skills --skill security-devsecops -a codex2Manually: put the files in place
.agents/skills/security-devsecops/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Mindrally/skills --skill security-devsecops -a cursor2Manually: put the files in place
.cursor/skills/security-devsecops/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Mindrally/skills security-devsecops2Manually: put the files in place
.github/skills/security-devsecops/SKILL.md1Skills CLI (Vercel)
npx skills add Mindrally/skills --skill security-devsecops -a gemini-cli2Platform CLI
gemini skills install https://github.com/Mindrally/skills --path security-devsecopsManually: put the files in place
.devin/skills/security-devsecops/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add Mindrally/skills --skill security-devsecops -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about security-devsecops
How to install security-devsecops in Claude Code?
Run npx skills add Mindrally/skills --skill security-devsecops -a claude-code or place the file directly at ~/.claude/skills/security-devsecops/SKILL.md.
What does security-devsecops do?
It provides guidelines for secure coding, credential handling, dependency vetting, and integrating automated scanners into the development workflow.
Which security utilities does this skill cover?
It incorporates scanners such as gitleaks, trufflehog, semgrep, npm audit, pip-audit, trivy, checkov, and tfsec.
Source text
SKILL.md · Apache-2.0
---
name: security-devsecops
description: "DevSecOps, secure software development lifecycle (SSDLC), and application security (AppSec) practices covering secret handling, input validation, dependency hygiene, authentication/authorization, and CI/CD security tooling (SAST, SCA, DAST, secret scanning, IaC scanning). Use when writing code that handles credentials, user input, database queries, or authentication, when setting up a CI/CD pipeline, or when reviewing code or infrastructure for security issues."
metadata:
maintainer: Mindrally
source: https://github.com/Mindrally/skills
---
# Security / DevSecOps
This skill covers secure coding practices, dependency and secret hygiene, authentication and authorization, and the security tooling that belongs in a secure software development lifecycle (SSDLC) — from local coding habits through CI/CD gates to production monitoring.
## Workflow for Adding a New Feature Securely
1. **Identify trust boundaries** — Note every place the new code accepts input from a user, another service, or a file, and every place it emits output (HTML, logs, another service).
2. **Validate and sanitize at the boundary** — Validate all untrusted input on entry; escape output for its destination context (HTML, JS, SQL, shell).
3. **Use existing security primitives** — Reach for the project's established auth framework, ORM, and secret-management approach rather than writing new ones.
4. **Keep secrets out of code and logs** — Read credentials from environment variables or a secrets vault; confirm nothing sensitive reaches logs or error messages.
5. **Run local security checks before pushing** — Lint, SAST, and secret-scanning tools where available (`gitleaks`, `semgrep`, `npm audit`, `pip-audit`, etc.).
6. **Let CI gates run** — SAST, SCA, secret scanning, and IaC scanning should run on every PR; treat a failure as a blocker, not a suggestion to suppress.
7. **Document the security-relevant decision** — Note in the PR description any auth/authz change, new dependency, or deviation from a default-secure pattern, so it's auditable later.
## General Security Principles
- Never hardcode secrets, credentials, or API keys in source code. Use environment variables or a secure vault (e.g. AWS Secrets Manager, HashiCorp Vault, Doppler) for sensitive data.
- Never commit `.env` files, secret config files, or unrecognized tokens to source control. Add them to `.gitignore` before they're ever staged.
- Never log sensitive data, secrets, or session tokens in application logs — redact or omit them at the point of logging, not after the fact.
- Validate and sanitize all user input at the point it enters the system. Escape output appropriately for its context: HTML-encode for HTML, JS-encode for inline scripts, parameterize for SQL.
- Avoid unsafe dynamic-execution functions such as `exec`, `eval`, `Function()`, `pickle.loads` on untrusted data, or shell interpolation of user input.
```python
# Unsafe — string interpolation into a query
query = f"SELECT * FROM users WHERE email = '{email}'"
cursor.execute(query)
# Safe — parameterized query
cursor.execute("SELECT * FROM users WHERE email = %s", (email,))
```
## Secret Handling
- Load secrets from environment variables (`process.env.API_KEY`, `os.environ["API_KEY"]`) or a vault client, never as literals.
- Rotate any credential that was ever committed to version control, even if the commit was later removed — history retains it.
- Scan for accidentally committed secrets before merge, using tools like `gitleaks`, `trufflehog`, or the CI provider's built-in secret scanning.
- Scope credentials narrowly: a CI deploy key should be able to deploy, not administer the whole cloud account.
## Database Security
- Use parameterized queries or an ORM for all database access. Never build queries via string concatenation or f-strings with user input.
- Ensure database users have the least privilege required for their role (a reporting service should not have `DROP TABLE` rights).
- Regularly review and update database access policies as team membership and service responsibilities change.
## Dependency Management
- Only add packages from verified, reputable sources — check download counts, maintenance activity, and known-CVE history before adding a new dependency.
- Do not add new dependencies without explicit approval and a brief security review, especially for packages that will run with elevated privileges or process untrusted input.
- Regularly update dependencies and scan for known vulnerabilities using Software Composition Analysis (SCA) tools such as `npm audit`, `pip-audit`, `Dependabot`, `Snyk`, or `Trivy`.
```bash
# Node.js
npm audit --audit-level=high
# Python
pip-audit
# Container image
trivy image myapp:latest
```
## Authentication & Authorization
- Use established, audited authentication frameworks (e.g. Auth0, Passport, Devise, ASP.NET Identity) — never implement custom cryptographic authentication from scratch.
- Store passwords using strong, salted, adaptive hashes: Argon2id or bcrypt, never MD5, SHA1, or unsalted SHA256.
- Implement Role-Based Access Control (RBAC) — or attribute-based access control for finer granularity — for sensitive operations.
- Enforce the principle of least privilege for both API endpoints and UI actions: check authorization on every request server-side, never trust a hidden UI element as an access control.
- Re-check authorization on every request, even for actions previously permitted — session state and roles can change mid-session.
```js
// Missing authorization check — any authenticated user can access any order
app.get("/orders/:id", requireAuth, async (req, res) => {
const order = await Order.findById(req.params.id);
res.json(order);
});
// Correct — verify the resource belongs to the requester
app.get("/orders/:id", requireAuth, async (req, res) => {
const order = await Order.findById(req.params.id);
if (!order || order.userId !== req.user.id) {
return res.status(404).end();
}
res.json(order);
});
```
## Secure SDLC Practices
Integrate these into the CI/CD pipeline, not as a manual pre-release checklist:
- **SAST** (Static Application Security Testing) — scan source code for known-bad patterns on every PR (e.g. Semgrep, CodeQL, SonarQube).
- **SCA** (Software Composition Analysis) — scan dependencies for known vulnerabilities and license issues (e.g. Snyk, Dependabot, OWASP Dependency-Check).
- **Secret scanning** — scan every commit and PR diff for accidentally committed credentials before merge (e.g. Gitleaks, GitHub secret scanning, TruffleHog).
- **IaC scanning** — scan Terraform/CloudFormation/Kubernetes manifests for misconfigurations before apply (e.g. Checkov, tfsec, Trivy config scan).
- **DAST** (Dynamic Application Security Testing) — scan a running instance of the deployed application for exploitable behavior in the CD pipeline (e.g. OWASP ZAP, Burp Suite).
- **Policy as Code (PaC)** — encode security and compliance policies as version-controlled, automatically enforced rules (e.g. OPA/Rego, Sentinel) rather than a document nobody rereads.
## Monitoring & Feedback
- Enable continuous vulnerability monitoring and alerting on both dependencies and running infrastructure.
- Integrate Runtime Application Self-Protection (RASP) and a Web Application Firewall (WAF) where the deployment target and traffic profile warrant it.
- Schedule regular vulnerability assessments and penetration tests, not just point-in-time audits before a big release.
- Maintain a feedback loop: recurring vulnerability classes found in production or pentests should update linting rules, SAST policies, and code review checklists — not just get patched once.
## Compliance & Documentation
- Align controls with recognized industry standards: OWASP Top 10, OWASP ASVS, NIST SSDF, ISO 27001, as relevant to the project's regulatory context.
- Document security controls and decisions as they're made (threat model notes, why an exception was granted, what compensating control offsets a known risk) so the reasoning is auditable later, not reconstructed from memory during an audit.
## Common Vulnerability Classes to Watch For
| Class | Watch for |
|---|---|
| Injection (SQL/NoSQL/command) | String-built queries or shell commands with user input |
| Broken access control | Missing per-request authorization checks, IDOR via predictable IDs |
| Cryptographic failures | Weak hashes, hardcoded keys, missing TLS, custom crypto |
| Insecure deserialization | `pickle`, unchecked `JSON.parse` into executable contexts, unsafe YAML loaders |
| Security misconfiguration | Default credentials, verbose error pages in production, permissive CORS |
| Vulnerable dependencies | Outdated packages with known CVEs, unpinned versions |
| Insufficient logging | No audit trail for auth events, sensitive data logged in plaintext |
© Mindrally · Apache-2.0 · Mindrally/skills