Security reviews for agencies shipping client apps
Define authorization, scope, evidence ownership, remediation, retesting, and handoff before an agency calls a client app ready to release.
Builder workflows
Vibe-Coding Security
Practical security habits for builders shipping apps written largely by AI coding tools.
92published articles
Keep AI Agents Away From Production Deletes
Block standing production delete authority with separate identities, permission ceilings, exact approvals, short-lived access, and audit records.
Protect AGENTS.md and Rules Files From Poisoning
Prevent prompt injection in AGENTS.md and coding-tool rules with provenance, code ownership, protected review, scoped rules, and conflict tests.
AI App Pre-Launch Security Checklist
Run an evidence-based pre-launch review across authorization, secrets, inputs, dependencies, deployment, agents, monitoring, recovery, and retests.
Privacy checklist for AI-built apps
Map personal data, purposes, retention, processors, user rights, deletion, and incident handling before an AI-built app reaches real users.
What not to share with AI coding assistants
Do not share live credentials, customer data, regulated records, unreleased business information, or code outside your authorized policy.
Audit AI-Suggested Dependencies for Vulnerabilities
Verify package identity, lock resolved versions, inspect the dependency graph, and interpret advisory matches without treating a clean scan as proof.
Is AI-generated code safe for production?
Not by default. Generated code needs requirements, human review, independent tests, constrained deployment, monitoring, and recovery evidence.
Why AI-Generated Tests Are Not Security Proof
Use AI-generated tests as regression checks, then add independent invariants, negative cases, mutation checks, and scoped retest evidence.
Secure an AI SaaS With Stripe
Secure Stripe billing with server-owned entitlements, raw-body webhook verification, idempotent processing, constrained keys, and failure-path tests.
A Security Review Prompt That Does Not Replace Testing
Use a bounded AI security review prompt to produce traceable candidate findings, safe test ideas, and explicit uncertainty without mistaking output for proof.
Stop Exposing API Keys in Frontend Code
Identify secrets shipped in browser bundles, move privileged calls behind a server boundary, and rotate exposed credentials safely.
What an app security score can and cannot mean
Read an app security score as a versioned summary of scoped evidence, not a breach prediction, universal benchmark, or guarantee of safety.
Test Backup Restore Before Agents Touch Production
Prove backup recoverability in an isolated restore drill before a coding agent receives destructive production access.
Secure a Base44 App Before Launch
Separate Base44 app visibility from data permissions, review table access and backend secrets, then verify the deployed app with distinct accounts.
Secure a Bolt App Before Launch
Identify the Bolt backend, protect server functions and webhooks, test database policy, and verify the published deployment.
Stop Brute Force and Account Enumeration
Make authentication responses uniform, throttle online guessing by account and network signals, and test recovery flows safely.
Prevent CI/CD Agents From Becoming a Confused Deputy
Keep untrusted pull requests outside privileged CI jobs with narrow tokens, protected deployments, bound OIDC claims, and verified artifacts.
Secure a Claude Code Project
Constrain Claude Code permissions, sandbox access, MCP tools, and release actions while keeping the coding workflow useful.
Create a Security Report for a Client Handoff
Build a client security handoff with executive context, technical evidence, coverage limits, finding states, retests, owners, and secure delivery.
Why Client-Side Auth Is Not Access Control
Understand why route guards and hidden controls cannot enforce access, then place authorization at the server operation that needs it.
Secure Cloudflare Workers Built With AI
Treat Worker bindings as capabilities, keep secrets encrypted, constrain outbound fetch and caching, and verify routes with production-shaped Wrangler config.
Secure an OpenAI Codex Project
Set Codex sandbox, approval, network, environment, and MCP boundaries, then verify code changes before any release action.
Sandbox Coding Agents and Control Egress
Isolate coding agents with disposable workspaces, minimal mounts, non-root execution, resource limits, and explicit outbound network policy.
Command Injection in Agentic App Workflows
Remove unsafe shell boundaries from agent tools, constrain process arguments, and isolate the external commands that remain necessary.
CORS for Vibe-Coded Apps
Replace wildcard or reflected origins with a minimal browser-sharing policy, correct credential handling, and cache-safe headers.
What to do with a critical security finding
Treat critical severity as a triage input: confirm scope and exposure, contain credible risk, preserve evidence, fix, and run a fresh retest.
CSRF Protection for Cookie-Based AI Apps
Protect cookie-authenticated state changes with framework controls or verified tokens, plus SameSite and Fetch Metadata layers.
Secure a Cursor-Built App Before Launch
Review Cursor data handling, project rules, dependencies, app controls, agent permissions, and independent evidence before launch.
Remove Debug Routes and Verbose Errors
Stop production errors from exposing stack traces, paths, queries, and framework internals while preserving useful, access-controlled diagnostics.
How to rotate and recover from an exposed API key
Respond to an exposed API key: contain access, rotate safely, verify rejection, investigate misuse, clean reachable copies, and document recovery.
Secure FastAPI Code Generated by AI
Separate Pydantic request validation from object authorization, then configure CORS, hosts, proxy trust, TLS, errors, and API documentation.
Secure GitHub Actions Used by Coding Agents
Harden coding-agent workflows with untrusted-input separation, minimal token permissions, pinned actions, constrained OIDC, and approval gates.
Hallucinated Packages and Slopsquatting
Check generated package names against official registries, repositories, releases, and owners before any installation runs.
Human Review and Threat Modeling for Vibe Coding
Run a lightweight threat-model review for an AI-built app by mapping real data flows, assigning owners, and turning decisions into testable release checks.
Idempotency and Replay Protection for SaaS
Make retries and duplicate webhooks safe with durable operation keys, canonical request binding, atomic state changes, and stored results.
How to Find IDOR in an AI-Built App
Use a safe two-account test to find object authorization flaws, then fix the resource lookup instead of hiding identifiers.
Indirect Prompt Injection in Coding Agents
Contain indirect prompt injection by separating untrusted content from instructions, limiting tools, and testing with harmless canary actions.
Input Validation for AI-Generated APIs
Define strict server-side request schemas, reject unknown and oversized data, and enforce business invariants before processing.
Secure npm Install Scripts and Transitive Dependencies
Inspect dependency scripts before they execute, install without production credentials, and allow only reviewed lifecycle code in npm.
JWT Validation Mistakes AI Tools Generate
Validate JWT signatures, algorithms, issuers, audiences, time claims, and token types with a deployment-specific trust policy.
Design Least-Privilege MCP Tools
Narrow MCP tools by verb, resource, schema, token audience, and approval so model-controlled calls cannot inherit broad authority.
Secure a Lovable App Before Launch
Review a Lovable app across its public frontend, Edge Functions, database RLS, authentication, scans, and publish settings.
Prevent Mass Assignment in CRUD APIs
Stop request bodies from changing roles, owners, prices, and workflow state with operation-specific schemas and explicit data writes.
Stop Prompt Injection From Spreading Across Agents
Contain multi-agent prompt injection with preserved provenance, structured handoffs, separated capabilities, intent checks, and safe canary tests.
Prevent Cross-Tenant Data Leaks
Carry a server-owned tenant context through APIs, jobs, caches, storage, and database queries, then verify it with two tenants.
Secure a Next.js App Generated by AI
Treat every callable Next.js server entry as an API, centralize authorization in a server-only data layer, and minimize data sent to the browser.
Secure Node and Express APIs Generated by AI
Build an ordered Express request contract, authorize resources at every route, and verify proxy, session, limit, error, and dependency settings.
Secure OAuth Redirects and Callbacks
Secure OAuth redirects with exact registration, transaction-bound callback state, PKCE, issuer checks, and a strict code exchange.
Dependency Scanning With OSV and Lockfiles
Scan resolved dependencies with OSV Scanner v2, interpret advisory matches, manage exceptions, update safely, and verify the result.
Password Hashing for Vibe Coders
Store passwords with maintained memory-hard hashing, deployment-tested work factors, safe migration, and rehashing on login.
Secure Password Reset and Email Verification
Design reset and verification flows with uniform responses, single-use tokens, trusted links, and explicit session decisions.
Prevent Path Traversal in Generated File Code
Keep file reads, exports, and archive extraction inside a trusted directory with canonical containment checks and safer identifiers.
Keep Pricing and Entitlements Off the Client
Authorize paid features from server-owned entitlement state, reconcile provider updates, and handle stale access without trusting client claims.
Find Placeholder Logic and Silent Failures
Find generated code that reports success without completing the promised work, then verify durable state, failure behavior, and a fresh retest.
When a vibe-coded prototype becomes production
A prototype becomes production when failure or misuse can affect real people, data, money, access, obligations, or business operations.
Public-by-Default Deployments and Storage
Find exposed previews, app origins, database APIs, and storage before launch, then prove each access boundary with logged-out and second-account tests.
Rate Limiting for AI Apps
Design endpoint-specific rate, concurrency, payload, queue, and cost limits for AI APIs without trusting a single weak identifier.
Secure React Frontends Without Trusting the Browser
Use React's rendering protections correctly while keeping authorization, secrets, sensitive data, and side effects behind verified server boundaries.
Secure a Replit App Before Launch
Separate Replit Preview from production, choose the right deployment, protect secrets and APIs, and inspect live response headers.
SARIF for AI Coding Workflows
Structure security results as SARIF 2.1.0 with stable rules, locations, fingerprints, redaction, validation, and honest evidence limits.
SAST vs DAST vs SCA for AI-Built Apps
Compare the evidence, timing, targets, and blind spots of SAST, DAST, and SCA, then combine them into a practical release workflow.
Secret Scanning Before Every Commit
Catch secrets in staged changes, enforce scanning on the remote, govern bypasses, keep fixtures inert, and rotate real exposures before cleanup.
What Never to Paste Into an AI Coding Tool
Keep live credentials out of AI tools, and use customer or regulated data only through an approved, minimized workflow with verified controls.
Secure Admin Routes in AI-Built Apps
Inventory privileged actions, enforce one server-side policy across every method, and test admin routes with ordinary accounts.
Secure File Uploads in AI-Built Apps
Build a staged upload pipeline with early size limits, server-generated names, content checks, quarantine, and private delivery.
Build a Secure MCP Server
Secure an MCP server with deliberate transport choices, audience-bound tokens, per-tool authorization, session isolation, and execution-time approval.
Secure Session Cookies
Configure host-scoped session cookies, choose SameSite deliberately, rotate identifiers, and test server-side expiry and revocation.
Audit Logs for Security-Sensitive Actions
Design scoped audit events that reconstruct sensitive actions, resist silent changes, protect private data, and survive collection failures.
Add a Security Diff Gate to Pull Requests
Build a pull-request security gate around immutable commits, explicit coverage, scanner failures, reviewable results, and one required decision.
Why Every Security Fix Needs a Retest
Retest a security fix against a fresh build, preserve equivalent coverage, check adjacent paths, and record confirmed or inconclusive outcomes.
Security Headers Every AI-Built App Needs
Build browser security headers from application behavior, stage CSP safely, and verify policies by route instead of chasing a score.
Build a Go / No-Go Security Launch Gate
Turn scoped security evidence into an accountable go, conditional, no-go, or not-evaluated decision with owners and rollback readiness.
Security Monitoring and Alerts Before Launch
Define security events, route actionable alerts to an owner, and test the complete monitoring path before an AI-built app launches.
Keep PII and Secrets Out of Logs
Prevent PII, tokens, prompts, and request data from entering logs through source minimization, field allowlists, tested redaction, and retention controls.
Server-Side Authorization for AI-Generated APIs
Create one deny-by-default authorization seam for API actions, resources, and tenants, then test every sensitive path.
How to share a security report without leaking details
Share security reports safely with audience-specific copies, data minimization, verified redaction, controlled delivery, expiry, and revocation.
Security for solo founders who vibe code
A founder-sized security sequence for accounts, authorization, secrets, dependencies, recovery, monitoring, and release decisions.
Stop Shipping Source Maps and Private Build Artifacts
Inspect source maps, bundles, package tarballs, and CI artifacts before release so private source and files do not reach public storage.
SQL Injection in AI-Generated Code
Replace interpolated SQL values with bound parameters, map dynamic identifiers from allowlists, and test query builders safely.
SSRF Protection That Resolves DNS
Bind URL validation to DNS resolution and the connection, recheck redirects, block private destinations, and restrict egress.
Verify Stripe Webhook Signatures
Verify Stripe against the exact raw request body and the correct endpoint secret before parsing events or changing application state.
Supabase RLS for Vibe-Coded Apps
Build and test Supabase row-level security with precise grants, command policies, and two-account checks before release.
Threat Modeling for Non-Security Founders
Build a lightweight startup threat model from assets, trust boundaries, misuse cases, mitigations, owners, tests, and review triggers.
TLS and Mobile Transport Security
Remove cleartext exceptions from mobile releases, test the real networking stack, and verify certificates, redirects, and backend TLS.
The Two-Account Test for Data Isolation
Use two owned accounts and synthetic records to test object-level authorization across reads, writes, deletes, exports, files, and nested resources.
Secure a v0-Generated App
Trace a v0 app from generated code through Next.js server boundaries, Vercel previews, environment variables, and the deployed site.
How to Verify a Security Finding
Verify a vulnerability finding by checking scope, code paths, prerequisites, safe reproduction, impact, and independent evidence.
Vibe Coding Security: The Complete Guide
A six-layer guide to testing AI-built apps, preserving evidence, retesting fixes, and making an honest release decision.
How to schedule weekly security checks
Combine event-triggered checks with a weekly default-branch scan, named ownership, response deadlines, and recorded retests.
Secure a Windsurf Project
Control Cascade terminal actions, MCP tools, credentials, shared rules, and branch review as Windsurf moves into Devin Desktop.
XSS in AI Apps That Render Markdown or Model Output
Trace untrusted Markdown and model output through parsing, sanitization, DOM insertion, CSP, and safe local verification.