Security
Threat modelling, secure review, hardening and supply-chain safety.
Download all 99
Start here 1
The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.
- Check an app for security problems
Runs a first security pass over an app, mapping what is exposed and checking the flaws that most often get apps breached, then ranks the fixes. Use to find out if your app is reasonably safe.
Specific 60
One situation, audience, tool or format inside the category. Example: Plan a road trip with children.
- Respond to a leaked secret
Produces an ordered response plan for an exposed key, token or password - revoke and rotate, audit use, clean up copies, notify and prevent. Use right after a secret is committed, logged or shared.
- Threat model a feature
Builds a threat model for one feature or change, mapping data flows and trust boundaries to ranked threats and mitigations. Use during design, before the code is written or merged.
- Triage dependency vulnerabilities
Triages dependency scan findings by reachability and exploitability, gives the upgrade path, and justifies anything safe to defer. Use when a scanner reports more than the team can fix at once.
- Dependency hygiene rules
Standing rules for adding or upgrading dependencies, so each one is justified, verified to exist, maintained, pinned through the lockfile and checked for licence and advisories.
- Plan secrets management
Plans secrets management for a stack, covering inventory, storage, runtime injection, rotation, access control and leak detection. Use when secrets live in env files, CI variables and chat.
- Secure coding rules
Makes the assistant write code that validates untrusted input, avoids injection, protects secrets and checks authorization by default. Use as always-on rules in any codebase.
- Security auditor
Reviews code for exploitable weaknesses and reports only issues with a concrete attack path. Use as a reviewer persona or subagent for security-sensitive changes.
- Vet a dependency before adding it
Checks a third-party package for supply-chain risk, maintenance health, license fit and real need before it is added or upgraded. Use when a PR adds a new dependency or bumps one.
- Harden web app headers and cookies
Produces hardened HTTP security headers, a Content Security Policy, CORS and cookie settings for a web app, rolled out first in report-only mode. Use before launch or after a security scan.
- Review a pull request for security
Reviews a diff for exploitable vulnerabilities and reports only findings with a concrete attack path. Use before merging changes to input handling, auth, data access or dependencies.
- Add CSRF protection
Adds cross-site request forgery protection to a cookie-authenticated app with SameSite cookies, framework tokens or origin checks, covering forms, fetch calls and exempt webhooks.
- Fix mass assignment
Replaces blind binding of request bodies to models with allowlisted fields per role (strong params, serializers, DTOs) so users cannot set roles, prices, owner ids or flags.
- Fix open redirects
Fixes return-URL and redirect parameters so they only lead to allowlisted relative paths or hosts, covering login, logout, OAuth callbacks and link tracking.
- Harden database access
Locks down who and what can reach a database, with least-privilege roles per app, separate migration credentials, network restrictions, enforced TLS, audit logging and a safe cutover.
- Harden a WordPress site
Hardens a live WordPress site with a plugin and theme audit, update policy, admin access, file editing, XML-RPC, least-privilege users, tested backups and a web application firewall.
- Write a security policy and disclosure process
Writes a SECURITY.md and the disclosure process behind it, with supported versions, how to report, response times and safe harbour. Use when a project has no clear way to report vulnerabilities.
- Fix OS command injection
Replaces shell commands built from user input with argument arrays or library calls, validates the values that must remain, and tests each fix with hostile inputs.
- Fix password reset vulnerabilities
Fixes the common password reset flaws, such as guessable or reusable tokens, host header poisoning, account enumeration and sessions left alive, with a test for each.
- Fix server-side template injection
Finds where user input is compiled as a template in Jinja, Twig, Freemarker, Velocity, Handlebars, ERB or similar engines, fixes it by passing data as variables or sandboxing, and adds tests.
- Harden a Linux server
Hardens a Linux server in a safe order (SSH, users, firewall, updates, unused services, logging, mandatory access control) with a check and rollback per step. Use on new or inherited servers.
- Fix SQL injection
Finds every SQL query built from strings, including ORM raw and extra calls, and rewrites each with bound parameters or allowlisted identifiers, with a regression test per fix.
- Add security scanning to CI
Adds dependency, secret, static analysis, IaC and container scanning to a CI pipeline with gates that block only new, real risk, a baseline for existing findings and a triage routine.
- Audit a codebase's compliance controls
Checks a codebase against the technical controls behind SOC 2, GDPR or HIPAA, like encryption, audit logging, access control, retention and deletion, and marks each pass, partial or fail with a fix.
- Audit the licences of every dependency
Inventories the licences of all direct and transitive dependencies, flags conflicts with the project's licence or policy, and lists packages for legal review. Use before a release or due diligence.
- Block fake and bot sign-ups
Stops bot and abusive sign-ups with layered checks such as rate limits, disposable email signals, risk-based challenges and verification gates, while keeping real sign-up quick.
- Fix IDOR and missing object-level authorization
Adds object-level authorization to every handler that loads a record by id, scoping queries to the caller's user or tenant and adding a cross-account test per endpoint.
- Fix path traversal and zip slip
Fixes file read, download, write and archive extraction code against path traversal and zip slip, using canonical path checks or opaque file ids, with a test per fix.
- Implement sign-out everywhere and session revocation
Implements a device and session list, sign out of one or all devices, and automatic revocation on password, email, MFA or role changes, for cookie sessions or tokens.
- Rotate a credential without downtime
Rotates a database password, API key or signing key with a dual-credential overlap so no request fails, with a check and a rollback at every step.
- Secure a WebSocket or SSE endpoint
Secures a WebSocket or server-sent events endpoint with auth at the upgrade, Origin checks, per-message authorization and validation, token expiry handling and connection limits.
- Triage static analysis security findings
Triages a backlog of static analysis security findings by grouping by root cause, tracing data flow from source to sink, and marking each true or false positive with a fix or suppression.
- Write a customer-facing security overview
Writes a security overview or whitepaper explaining how a SaaS product protects customer data, accurate to the controls that really exist, with no overclaiming.
- Write a custom Semgrep rule
Writes a custom Semgrep static analysis rule for a risky code pattern in your codebase, with pattern logic, message, fix suggestion and passing and failing test snippets.
- Audit Firebase security rules
Audits existing Firestore, Realtime Database and Cloud Storage security rules for open reads and writes, missing ownership checks and client-trusted fields, with emulator-tested fixes.
- Harden a Laravel application
Hardens a Laravel app for production, covering debug mode and APP_KEY, mass assignment, Blade escaping, policies, signed URLs, rate limiting and exposed tooling routes.
- Harden a Rails application
Hardens a Ruby on Rails app by triaging Brakeman output and fixing strong params, raw SQL, html_safe, CSRF, session, credentials and production config settings.
- Fix cross-site scripting (XSS)
Fixes reflected, stored and DOM XSS with output encoding for each context, an allowlist sanitizer for rich text and safe use of escape hatches like dangerouslySetInnerHTML or v-html.
- Generate SBOMs in CI
Generates CycloneDX or SPDX SBOMs for an app and its container images in CI, checks they are complete, publishes them with each release and uses them to answer "are we affected" questions.
- Harden a Django project's security settings
Reviews and fixes a Django project's production security settings (DEBUG, ALLOWED_HOSTS, SECRET_KEY, cookies, HTTPS, CSRF) and risky ORM and template uses, verified with check --deploy.
- Secure ML model and dataset loading
Removes code-execution risk from loading models and datasets (pickle, torch.load, joblib, trust_remote_code) using safetensors, pinned revisions, scanning and isolated conversion.
- Audit how an app handles untrusted input
Inventories every place untrusted input enters a codebase and follows each to its sinks, checking for injection, XSS, path traversal and type confusion, with a fix per input vector.
- Choose where a web or mobile app stores auth tokens
Decides where a single-page or mobile app keeps its auth tokens (HttpOnly cookies, memory, a backend-for-frontend, secure storage) for its threat model, then implements the choice.
- Find secrets shipped to browsers and apps
Finds keys and secrets shipped to browsers or mobile apps through public env prefixes, bundles, source maps and app packages, separates truly public keys, and moves secrets server side.
- Put an internal tool behind company SSO
Puts an internal tool or admin panel behind company single sign-on with an identity-aware proxy or OIDC middleware, group-based access and no public login page.
- Audit cloud storage buckets for exposure
Finds publicly readable or writable S3, Google Cloud Storage or Azure Blob containers, risky presigned URL use and missing encryption, with fixes that keep the app working.
- Fix XML external entity (XXE) vulnerabilities
Finds XML parsers that resolve external entities or DTDs on untrusted input, including SVG, DOCX and SAML handling, and configures them safely with a test per parser.
- Prepare for a penetration test
Prepares a team for an external penetration test with scope, test type, rules of engagement, written authorisation, test accounts, pre-test fixes, vendor questions and a plan for findings and retest.
- Review a diff for personal data
Reviews a code change for new personal data flows (fields collected, PII in logs and analytics, retention, third parties, consent) and lists data map updates and questions for privacy or legal.
- Secure third-party scripts on a website
Inventories third-party scripts on a site, removes or self-hosts what it can, adds Subresource Integrity, CSP and iframe limits, and plans for a compromised script provider.
- Secure Next.js server actions and route handlers
Audits Next.js App Router server actions, route handlers and middleware for missing auth checks, secrets reaching client components and unvalidated input, then fixes them.
Showing 50 of 60. See them all in search
Advanced 38
Expert or deep work that assumes the user can judge expert output. Example: Plan croissant lamination.
- Triage a vulnerability report
Triages an external vulnerability or bug bounty report by checking the claim, rating severity with CVSS, deciding valid, duplicate or out of scope, and drafting the reply. Use for security inboxes.
- Review an authentication flow
Reviews an authentication or session design (OAuth or OIDC, tokens, cookies, MFA, password reset) for known flaws, with attack paths and fixes. Use before building or shipping login and session code.
- Review a cloud IAM policy
Reviews AWS, GCP or Azure IAM policies for over-broad permissions, privilege-escalation paths, wildcard resources and missing conditions, and proposes least-privilege versions.
- Review an API against the OWASP API Top 10
Reviews an API design or implementation against the OWASP API Security Top 10, from object-level authorization and mass assignment to rate limits and SSRF, with attack paths and fixes.
- Audit tenant isolation
Audits a multi-tenant codebase for paths where one customer can see or change another's data, across queries, jobs, caches, search, file storage, exports and support tools, with a cross-tenant test.
- Data privacy engineer
Acts as a privacy engineer who designs minimisation, retention, consent and deletion into systems, keeps the data map current, reviews features for personal data risk and knows when to ask legal.
- Fix insecure deserialization
Finds deserialization of untrusted data with pickle, Java ObjectInputStream, unsafe YAML loaders, PHP unserialize or BinaryFormatter, and replaces it with safe formats or loaders.
- Harden JWT verification
Audits and fixes how a service verifies JWTs, pinning algorithms and checking issuer, audience, expiry and key source, so forged, expired or misdirected tokens are rejected.
- Implement field-level encryption
Implements application-level encryption of sensitive columns with envelope keys from a KMS, an AEAD cipher library, blind indexes for exact lookups, key rotation and a safe migration of existing rows.
- Fix exploitable race conditions
Finds check-then-act races attackers exploit with parallel requests (coupon reuse, double withdrawals, token reuse), fixes them with atomic updates, constraints or locks, and adds concurrent tests.
- Harden IoT device firmware
Plans prioritised hardening for a connected device with unique credentials, secure boot, signed updates, debug lockdown, secret storage, TLS and a disclosure path, sized for a small team.
- Adopt a strict Content Security Policy
Moves a web app to a nonce- or hash-based strict Content Security Policy by refactoring inline scripts, event handlers and eval, then enforcing after a report-only period.
- Audit a web application's security
Audits a whole web application codebase against the OWASP Top 10, tracing each finding from an entry point to the flaw with a reproducible proof and a fix. Use before launch or an external pentest.
- Defend a login against credential stuffing
Protects a live login from automated password attacks with per-account and per-IP throttling, breached-password checks, bot challenges, MFA prompts and attack monitoring.
- Harden a small Windows domain
Plans hardening for a small Windows Active Directory domain in priority order - admin tiering, passwords and MFA, legacy protocols, logging and backup protection - with a check and rollback per step.
- Plan a security incident response
Plans the response to a suspected security incident with triage, evidence preservation, containment options, communication, eradication and recovery. Use in the first hours of a breach or compromise.
- Review an LLM app for security
Reviews an LLM app for prompt injection, data exfiltration through tools, excessive agency and unsafe output handling, mapped to the OWASP LLM Top 10. Use before shipping an agent or RAG feature.
- Review a mobile app's security
Reviews an iOS or Android app against OWASP MASVS areas (storage, crypto, auth, network, platform, code, resilience, privacy) and returns ranked findings with fixes. Use before release or an audit.
- Set up mutual TLS between services
Plans and implements mutual TLS between internal services with a private CA, automated certificate issuance and rotation, identity-based authorization and a staged permissive-to-strict rollout.
- Sign release artifacts and publish provenance
Plans signing for releases (binaries, packages, container images) with build provenance, an SBOM, key custody or keyless signing, and verification steps users and deploy systems will run.
- Harden an Electron app
Hardens an Electron desktop app with context isolation, sandboxed renderers, no Node integration, validated IPC, a strict CSP, safe navigation and signed auto-updates.
- Harden a Kubernetes workload
Hardens existing Kubernetes workloads with restricted security contexts, non-root and read-only filesystems, network policies, minimal RBAC and service account tokens, and safer secret handling.
- Secure a GraphQL API
Secures a GraphQL API against abuse with depth and cost limits, field-level authorization, introspection policy, batching and alias limits, persisted queries and safe errors.
- Add passkey sign-in (WebAuthn)
Adds passkey registration and sign-in next to existing login, with server-side challenge checks, credential storage, autofill UI, multiple passkeys per account and safe recovery.
- Harden a Spring Security configuration
Reviews and rewrites a Spring Security filter chain for correct matcher order, deny by default, method security, CSRF, CORS, session policy and Actuator exposure, with tests.
- Migrate stored passwords to a stronger hash
Moves stored password hashes from MD5, SHA or weak bcrypt to Argon2id or stronger bcrypt by wrapping old hashes at once and rehashing on login, with no forced reset.
- Fix server-side request forgery (SSRF)
Hardens features that fetch user-supplied URLs, such as webhooks, link previews and image import, with allowlists, resolved-IP checks, blocked metadata ranges and redirect limits.
- Plan data encryption for a system
Plans which data to encrypt where (in transit, at rest, field level), with envelope encryption, key management and rotation, and the attacker each layer stops, plus search and deletion trade-offs.
- Review cryptography usage in code
Reviews how code uses cryptography, catching misuse like ECB mode, reused nonces, unauthenticated encryption, fast password hashes, weak randomness, disabled TLS checks and hard-coded keys.
- Design a sandbox for user-submitted code
Designs how a product safely runs user-submitted code, scripts or plugins, choosing an isolation layer and setting resource limits, egress control, secrets separation and escape monitoring.
- Audit unsafe Rust for soundness
Audits unsafe blocks and FFI in a Rust crate for soundness, writes SAFETY comments stating each invariant, replaces avoidable unsafe with safe code and runs Miri on the tests.
- Fix prototype pollution in JavaScript
Fixes prototype pollution in deep merges, path setters, query parsers and config loaders with safe merge helpers, null-prototype objects or Maps, and tests using __proto__ payloads.
- Review a CI/CD pipeline for security
Reviews CI/CD workflow files for supply-chain attack paths, such as untrusted triggers with secrets, script injection, broad tokens, unpinned actions, cache poisoning and over-trusting cloud roles.
- Fix regular expression denial of service (ReDoS)
Finds regular expressions that backtrack catastrophically on user input, rewrites them or moves them to a linear-time engine, and adds length limits and timing tests.
- Implement a personal data export for users
Implements a user data export for access and portability requests that gathers every store, formats it readably, verifies identity and delivers it securely.
- Reduce PCI DSS scope in a payment integration
Reviews how an app takes card payments and changes it (hosted fields, redirects, tokens, isolated payment pages) so card data never touches its servers, then lists remaining controls.
- Decide on and implement certificate pinning in a mobile app
Decides whether a mobile app should pin TLS certificates and, if so, implements public key pinning with backup pins, safe rotation, expiry and a way to recover without bricking old versions.
- Review C or C++ code for memory safety
Reviews C or C++ code for buffer overflows, use-after-free, integer overflow, uninitialised reads and format string bugs, with fixes and sanitizer and compiler settings that catch more.
Wins every tie inside software-engineering. Not: legal compliance drafting (compliance).