Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Mindrally/skills --skill security-devsecops -a claude-code
Open on GitHub

What 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-code

2Manually: put the files in place

~/.claude/skills/security-devsecops/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/security-devsecops/

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

Similar skills

All skills for Security →
sast-sca-security-analyzer official github sast-sca-security-analyzer is a GitHub Copilot subagent that scans code and third-party dependencies for security issues. It runs for SAST, SCA, and policy compliance checks. CX Codex +1 ★ 41,430repo stars building-devsecops-pipeline-with-gitlab-ci mahipal building-devsecops-pipeline-with-gitlab-ci is a Claude Code skill that adds security checks for code, dependencies, containers, and secrets to GitLab CI/CD. Checks run before deployment. CX Codex +1 243installs agentic-security Clear-Capabilities agentic-security — a Claude plugin that hunts for vulnerabilities, tests whether each finding is actually exploitable, and repairs it through a verification gate. Useful when a model wrote the code and you need to know what is unsafe. ★ 121repo stars appsec-expert martinholovsky The appsec-expert skill supports application security work, from threat modeling and testing to vulnerability fixes. Use it when security checks must enter the development workflow. CX Codex +1 243installs devsecops-expert martinholovsky devsecops-expert is a Claude Code skill for adding security checks to CI/CD pipelines and protecting containers and infrastructure. It engages on tasks involving secrets management or software supply chain security. CX Codex +1 366installs application-security-testing usestrix The application-security-testing skill selects tests for source code, a live web app, APIs, and CI, then turns confirmed findings into a ranked remediation plan. Use it for an AppSec review. CX Codex +1 17,000installs

From the same set247

The whole set →
clean-code The clean-code Claude Code skill guides code writing and review, with an emphasis on clarity and restrained abstractions. It applies to new code, refactors, and quality checks. CX Codex +1 182installs embedded-stm32 embedded-stm32 — a skill for Claude Code and Codex providing engineering rules for embedded C/C++ firmware on STM32 using the HAL. Triggers when writing peripheral drivers, handling interrupts, or setting up DMA. CX Codex +1 132installs network-troubleshooting The network-troubleshooting Claude Code skill diagnoses network failures in commands and services. It activates for DNS, TLS, proxy, connection, and package registry timeout errors. CX Codex +1 131installs readme-best-practices The readme-best-practices Claude Code skill guides README writing and review. It activates for a new project README, a rewrite, or a repository documentation check. CX Codex +1 121installs ros2-robotics The ros2-robotics Claude Code skill guides ROS 2 package and node development. It activates for work on topics, QoS, tf2, launch files, or colcon workspace tests. CX Codex +1 111installs blender-python-addon blender-python-addon — a skill for Claude Code that establishes best practices for Blender add-on development via the bpy API. Triggers when writing operators, UI panels, or bmesh routines. CX Codex +1 111installs automl-hyperparameter-optimization The automl-hyperparameter-optimization Claude Code skill guides AutoML setup and hyperparameter searches. It covers validation design, distributed trials, and checks for judging whether a leaderboard result is production-ready. CX Codex +1 110installs gamemaker-gml gamemaker-gml — a skill for Claude Code that guides GameMaker Language (GML) development. Triggers when writing object event logic, scripts, room transitions, and state machines in GameMaker Studio. CX Codex +1 109installs

Project sponsors

Companies that keep this analytics open