Loading...

70 AI Guardrails: Prevention Patterns for Production Safety | Engify.ai

Prompts Patterns Workflows Tools Learn MCP Built in Public

Sign in Get Started

Home WorkflowsGuardrails

AI Guardrails: Prevention Patterns for Production Safety

Automated quality gates that enforce workflow checklists automatically. Transform manual processes into always-on automation that prevents pain points before code reaches production.

Back to Workflows View Pain Points

70

Total Guardrails

7

Categories

32

Critical Severity

Category

Showing 70 guardrails

All (70)

Availability (10)

Data Integrity (10)

Financial (8)

Integration (10)

Performance (10)

Security (12)

Show 1 More

Severity

Sort:

All Severities

Critical (32)

High (29)

Medium (9)

Guardrail

Prevent Breaking Api Changes

AI-generated code, when asked to "refactor" or "add a field," may rename or remove existing API fields, or change a field's type, breaking all existing clients that rely on the old contract.

Engineers

Manual Checklist

Primary Fix: Follow the API Evolution principle: never change or delete existing fields. Only add new, optional fields
Any breaking change (e.g., deleting a field, changing a type) must be released as a new, major semantic version (e.g., /v2/endpoint)
Ground the AI with the `ai-behavior/capability-grounding-manifest` workflow, which includes the existing API contract
+2 more steps inside

Guardrail

Prevent Buffer Overflow In Data Processing

AI-generated code in memory-unsafe languages (like C/C++) may use unsafe functions (e.g., strcpy, memcpy) without proper bounds checking, leading to buffer overflows, data corruption, or security exploits.

Engineers

Platform

Manual Checklist

Primary Fix: Avoid unsafe C-style functions. Use modern, memory-safe C++ containers (std::vector, std::string)
In Java/C#, the JVM/CLR prevent this by throwing ArrayIndexOutOfBoundsException, but ensure this exception is caught and handled
If C-style functions are required, use "safe" bounded versions (e.g., strncpy(), memcpy_s()) and always validate the buffer length
+2 more steps inside

Guardrail

Prevent Cascading Failure From Dependency

AI-generated microservices will naively and repeatedly call a failing or slow downstream dependency, exhausting their own resources (threads, sockets) and creating a "cascading failure" that brings down the entire system.

Engineers

Platform

Manual Checklist

Primary Fix: Implement the Circuit Breaker pattern (e.g., using libraries like Resilience4j, Polly)
Track failures: after a set threshold (e.g., 50% errors in 10s), "trip" or "open" the circuit and fail-fast without calling the dependency
While the circuit is open, provide a fallback response (e.g., stale cached data or a default value) to maintain partial availability
+2 more steps inside

Guardrail

Prevent Csrf Vulnerability

AI-generated code for web endpoints (especially form handling) may not include anti-CSRF tokens, allowing attackers to trick an authenticated user's browser into submitting unwanted requests (e.g., "change password," "delete account").

Engineers

Security

Manual Checklist

Primary Fix: Use the Synchronizer Token Pattern. Embed a unique, secret anti-CSRF token in all state-changing forms (POST, PUT, DELETE) and validate it on the server
Use a web framework that provides built-in CSRF protection and ensure it is enabled
Defense-in-Depth: Set all session cookies with the SameSite=Strict or SameSite=Lax attribute to prevent them from being sent on cross-site requests
+2 more steps inside

Guardrail

Prevent Currency Conversion Error

AI-generated code for currency conversion may use a hardcoded conversion rate or fail to account for the high volatility and precision requirements of foreign exchange (FX) rates.

Engineers

Product Managers

Manual Checklist

Primary Fix: Never hardcode an FX rate. Rates must be fetched in real-time (or near-real-time) from a trusted FX rate provider API
Store all monetary values with their currency code (e.g., USD, EUR) using an integer (cents) + currency string
Use high-precision Decimal libraries for all conversion calculations to avoid rounding errors (see Guardrail 43)
+2 more steps inside

Guardrail

Prevent Data Corruption In Ai Generated Migrations

AI-generated migration scripts often hallucinate schema details or miss implicit data dependencies, leading to silent data corruption or data loss upon deployment.

Engineers

Platform

Manual Checklist

Mandate that every AI-generated DDL migration script is accompanied by a fully-tested rollback script
Use the `ai-behavior/stop-schema-guessing` workflow to ground the AI with the complete database schema
Test the migration on a staging environment using a recent, anonymized clone of the production database
+2 more steps inside

Guardrail

Prevent Data Loss From Incomplete Transactions

AI-generated code for multi-step operations (e.g., "create user and user's profile") may omit database transactions, leading to partial data writes and an inconsistent state if one step fails.

Engineers

Platform

Manual Checklist

Wrap all multi-step database operations (e.g., INSERT-UPDATE, multi-INSERT) in an atomic database transaction
Ensure the transaction logic includes robust error handling that triggers a ROLLBACK on any failure
Use the cognitive-verifier pattern: prompt the AI to "analyze this code for atomicity" or "rewrite this to use a transaction"
+2 more steps inside

Guardrail

Prevent Data Type Mismatch In Api Integration

When generating client code, the AI may hallucinate or misinterpret an external API's contract (e.g., expecting an integer when the API returns a string), causing (de)serialization failures and data corruption.

Engineers

Platform

Manual Checklist

Use the `ai-behavior/capability-grounding-manifest` workflow, providing the AI with the exact OpenAPI or JSON Schema for the external API
Use code-generation tools (e.g., openapi-generator) to create typed client libraries from the schema, instead of asking the AI to write the client
Implement robust data validation (e.g., using Pydantic, Zod) on the API response to ensure it matches the expected contract
+2 more steps inside

Guardrail

Prevent Deadlock In Concurrent Code

AI-generated concurrent code (e.g., multithreading) may acquire multiple locks in an inconsistent order, leading to a "deadlock" where Thread A holds Lock 1 (waiting for 2) and Thread B holds Lock 2 (waiting for 1), freezing both threads.

Engineers

Platform

Manual Checklist

Primary Fix: Enforce a global, "lock ordering" policy. All threads must acquire locks in the same, predefined order (e.g., always Lock A, then Lock B)
Avoid nested locks where possible
Use tryLock() with a timeout instead of a blocking lock. If the timeout expires, the thread should release all its other locks and retry
+2 more steps inside

Guardrail

Prevent Double Charging Customers

AI-generated payment endpoints are often not "idempotent." If a client retries a request due to a network error, the AI-generated code will process the charge again, leading to a double-charge.

Engineers

Product Managers

Manual Checklist

Primary Fix: Implement Idempotency. (See Guardrail 48 for the full technical solution)
Require a unique, client-generated Idempotency-Key (e.g., a UUID) in the header of all POST payment requests
On the server, save the result of the first successful request tied to that key
+2 more steps inside

Guardrail

Prevent Duplicate Data From Missing Unique Constraints

AI-generated schema code (DDL) often defines tables without the necessary UNIQUE constraints (e.g., on email, username), allowing duplicate records to be created, which breaks business logic.

Engineers

Platform

Manual Checklist

Enforce UNIQUE constraints at the database level for all business keys (e.g., email, order_id, username)
Ground the AI with a schema (using `ai-behavior/stop-schema-guessing`) and explicitly prompt for constraints: "Generate a users table where email must be unique"
Use a structured-output pattern to force the AI to list all constraints it is applying
+2 more steps inside

Guardrail

Prevent Exposed Sensitive Data In Logs

AI-generated logging code, especially debug-level code, often logs entire objects or request bodies, inadvertently writing PII, passwords, session tokens, and API keys to plain-text logs.

Engineers

Security

Manual Checklist

Primary Fix: Never log sensitive data. This includes: passwords, API keys, session tokens, PII (health/gov IDs), and full credit card numbers
Implement automated "log masking" or data scrubbing libraries that automatically redact sensitive patterns before they are written
Use "allow-listing" for logging: instead of logging an entire object, log only the specific, safe fields (e.g., log.info("User {user_id} logged in"))
+2 more steps inside

Guardrail

Prevent Flaky Tests From Timing Issues

AI-generated asynchronous or UI tests often use hardcoded, arbitrary sleep() or setTimeout() commands. These create "flaky" tests that fail intermittently in CI due to timing or load variations.

Engineers

QA

Manual Checklist

Primary Fix: NEVER use hardcoded sleep() or fixed timeouts in tests to wait for something to happen
Use explicit, condition-based waits. Wait for a specific condition to be true (e.g., "element is visible," "API response is received," "text appears")
Use modern test frameworks (e.g., Playwright, Cypress) that have "auto-waiting" assertions built-in (e.g., expect(..).toBeVisible())
+2 more steps inside

Guardrail

Prevent Hardcoded Secrets In Generated Code

AI coding tools are trained on public code and frequently include placeholder or real secrets (API keys, passwords, tokens) directly in their suggestions, which developers may accidentally commit.

Engineers

Security

Manual Checklist

Use .gitignore to prevent untracked credential files (e.g., .env, secrets.yml) from ever being staged
Use pre-commit hooks (e.g., gitleaks, detect-secrets) to scan staged files and automatically block commits containing secrets
Enable CI/CD secret scanning (e.g., GitHub Advanced Security, GitGuardian) to catch leaks that bypass pre-commit hooks
+2 more steps inside

Guardrail

Prevent Idor Vulnerability

AI-generated code often writes naive data-access logic (e.g., ...WHERE id = [user_input]) without checking who is making the request, allowing attackers to access other users' data.

Engineers

Security

Manual Checklist

Primary Fix: Never rely solely on the ID from the user. Scope all queries to the authenticated user's session (e.g., user.projects.find(params[:id]), not Project.find(params[:id]))
Enforce "deny by default" access control middleware that checks permissions on every request
Use non-enumerable, random identifiers (e.g., UUIDs) instead of sequential integers (like 1, 2, 3) to make enumeration difficult
+2 more steps inside

Guardrail

Prevent Improper Error Handling

AI-generated code often has empty catch blocks ("exception swallowing") or fails to catch errors at all, leading to unhandled exceptions that crash the entire process, making the service unavailable.

Engineers

Platform

Manual Checklist

Primary Fix: Never use an empty catch (Exception e) {} block. At a minimum, log the error with its full context
Catch specific exceptions (e.g., catch (PaymentFailedException e)) at the level where you can actually handle them (e.g., return a 402 status)
Let unexpected exceptions (e.g., NullPointerException) propagate up to a global, centralized exception handler
+2 more steps inside

Guardrail

Prevent Improper Shutdown Handling

AI-generated services do not handle OS-level shutdown signals (like SIGTERM from Kubernetes). When a deploy happens, the orchestrator kills the process (SIGKILL), abruptly dropping all in-flight requests.

Engineers

Platform

Manual Checklist

Primary Fix: Implement a "graceful shutdown" handler in your application that listens for the SIGTERM signal
On receiving SIGTERM, the handler must: Stop the web server from accepting new requests, finish processing all in-flight requests, close database and network connections, exit the process cleanly (e.g., exit(0))
In Kubernetes, configure a preStop hook to trigger your graceful shutdown endpoint
+1 more steps inside

Guardrail

Prevent Incorrect Api Error Handling

AI-generated error handlers are often inconsistent. They may return plain text, an HTML stack trace, or a simple string, making it impossible for client applications to programmatically parse the error or show a useful message.

Engineers

Manual Checklist

Primary Fix: Standardize all error responses on RFC 7807 (Problem Details for HTTP APIs)
The JSON error response must include: type (a URI to error docs), title (short summary), status (HTTP code), and detail (specifics)
Implement a global exception handler (middleware) that catches all unhandled exceptions and formats them as RFC 7807 JSON
+2 more steps inside

Guardrail

Prevent Incorrect Content Type Headers

AI-generated client code may forget to set the Content-Type: application/json header on POST requests, causing the server to reject the request (415 Unsupported Media Type) or misinterpret the body.

Engineers

Manual Checklist

Primary Fix: Use an HTTP client library (e.g., Axios, Requests) that automatically sets Content-Type: application/json when you send a JSON object
If sending data manually, always set the Content-Type header to match the body format (e.g., application/json, application/x-www-form-urlencoded)
Always set the Accept: application/json header to tell the server what format you expect in the response
+2 more steps inside

Guardrail

Prevent Incorrect Discount Application

AI-generated e-commerce logic may miscalculate discounts (e.g., "stacking" multiple promos) or fail to check expiration/usage-limits, leading to revenue loss.

Engineers

Product Managers

Manual Checklist

Primary Fix: Centralize all discount logic in a single "promotion engine" or microservice, rather than scattering it in the application
The engine must process rules in a specific order (e.g., 1. Item-level, 2. Order-level, 3. Shipping)
For each promotion, validate all conditions: is it expired? Is the usage_limit reached? Does the cart meet the criteria?
+2 more steps inside

Guardrail

Prevent Incorrect Financial Calculation

AI-generated code will default to using standard float or double types for currency, which are binary floating-point types that cannot accurately represent decimal values, leading to silent rounding errors (e.g., 0.1 + 0.2 != 0.3).

Engineers

Product Managers

Manual Checklist

Primary Fix: NEVER use binary floating-point types (float, double) for monetary values
Use a dedicated, high-precision Decimal library (e.g., Java's BigDecimal, Python's Decimal) for all calculations
Alternative: Store all currency values as integers representing the smallest unit (e.g., cents, 1000 = $10.00)
+2 more steps inside

Guardrail

Prevent Incorrect Tax Calculation

AI-generated code cannot possibly know the 11,000+ constantly-changing sales tax jurisdictions. It will hardcode a rate or use a simple, incorrect formula, leading to massive compliance and liability issues.

Engineers

Product Managers

Manual Checklist

Primary Fix: NEVER write or generate your own tax calculation logic
Integrate a dedicated, third-party tax compliance service (e.g., Avalara, TaxJar, Stripe Tax) via their API
Ensure you pass the full, validated address (not just ZIP code) to the tax API for "rooftop-level" accuracy
+2 more steps inside

Guardrail

Prevent Incorrect Test Assertions

AI-generated tests can be tautological or incorrect. They may test the wrong thing (e.g., assert(true)), have logical errors, or accidentally repeat the same logic from the function, thus failing to catch bugs.

Engineers

QA

Manual Checklist

Primary Fix: Never repeat the implementation logic in the assertion. Use static, "known-good" values
(Bad: assert(add(2, 2) == 2 + 2). Good: assert(add(2, 2) == 4))
Use the Arrange-Act-Assert (AAA) pattern to structure tests clearly and keep assertions separate from logic
+3 more steps inside

Guardrail

Prevent Incorrect Timeout Values

AI-generated client code may set a timeout value that is too short (e.g., 500ms), causing it to fail on valid requests, or too long (e.g., 5 minutes), causing it to hang and exhaust resources.

Engineers

Manual Checklist

Primary Fix: Set reasonable timeouts. A good default is a 1-2 second connection timeout and a 5-10 second read timeout
Do not guess. Set timeouts based on the downstream service's actual p99 latency SLO
The client's timeout must always be longer than the server's advertised p99 latency
+2 more steps inside

Guardrail

Prevent Incorrect Timezone Handling

AI-generated code often defaults to using server-local time or "naive" datetimes (without timezone info), leading to critical data inconsistencies, incorrect timestamps, and scheduling failures.

Engineers

Platform

Manual Checklist

Server Standard: Standardize all server-side logic, application logs, and database storage to use Coordinated Universal Time (UTC)
Database Type: Use timezone-aware database types (e.g., PostgreSQL's TIMESTAMPTZ)
Storage: Always convert user-submitted datetimes to UTC at the application boundary before storing them
+2 more steps inside

Guardrail

Prevent Inefficient Caching Strategy

AI-generated code may implement no caching, or a naive caching strategy (e.g., no eviction policy), leading to unnecessary database load or serving stale data.

Engineers

Platform

Manual Checklist

Implement a Cache-Aside (Lazy Loading) pattern: the application checks the cache first; if "miss," it queries the DB, then populates the cache
Use an in-memory, distributed cache (e.g., Redis, Memcached) for data that is shared across multiple servers
Always set an eviction policy (e.g., LRU - Least Recently Used) and a reasonable TTL (Time-to-Live) on all cache keys
+2 more steps inside

Guardrail

Prevent Inefficient Data Structure

AI-generated code may default to a "one-size-fits-all" data structure (like using a List/Array for everything) when a more efficient one (like a HashMap/Dictionary or Set) is required, leading to poor algorithmic performance (e.g., O(n) instead of O(1)).

Engineers

Platform

Manual Checklist

Analyze the main operations: for frequent lookups, use a HashMap or Set; for frequent insertions/removals, consider a LinkedList
Prompt the AI to "analyze the time complexity of this function" and "suggest a more performant data structure"
Use a cognitive-verifier pattern: prompt a separate AI to find performance flaws in the first AI's code
+2 more steps inside

Guardrail

Prevent Inefficient Pagination

AI-generated API code often defaults to "offset-based" pagination (e.g., LIMIT 20 OFFSET 100000), which becomes extremely slow on large datasets because the database must scan all 100,000+ rows.

Engineers

Platform

Manual Checklist

For large, dynamic datasets (e.g., feeds, timelines), do not use offset-based pagination
Primary Fix: Implement Keyset (Cursor-Based) Pagination. This uses a WHERE clause based on the last-seen value (e.g., WHERE created_at > [last_timestamp] LIMIT 20)
Ensure the "cursor" column (created_at, id) is indexed
+2 more steps inside

Guardrail

Prevent Infinite Loop From Logic Error

AI-generated code, especially for complex loops (while) or recursion, may contain logic errors in the termination condition (e.g., an off-by-one error, while(flag) where flag is never set to false), causing a process to spin at 100% CPU and become unresponsive.

Engineers

Platform

Manual Checklist

In while loops, ensure the condition variable is always modified inside the loop
For recursive functions, ensure there is a "base case" that terminates the recursion
Always set a statement_timeout at the database level to kill long-running (potentially looping) queries
+2 more steps inside

Guardrail

Prevent Insecure File Upload

AI-generated code for file uploads often only checks the file extension (e.g., .jpg), allowing attackers to upload malicious files (e.g., a web shell) with a fake extension, leading to remote code execution.

Engineers

Security

Manual Checklist

Validate the file type by checking its "magic bytes" (file signature), not just the Content-Type header or file extension
Primary Fix: Change the filename to a randomly generated string (e.g., a UUID) and append a safe, "allow-listed" extension
Store uploaded files in a separate, non-executable, sandboxed location (e.g., an S3 bucket), not in the web root
+2 more steps inside

Guardrail

Prevent Insecure Session Management

AI-generated authentication code often manages sessions insecurely, for example by creating non-expiring tokens, failing to invalidate them, or making them accessible to client-side scripts.

Engineers

Security

Manual Checklist

Primary Fix: Set session cookies with security attributes: HttpOnly (prevents XSS access), Secure (HTTPS only), and SameSite=Strict (prevents CSRF)
Generate a new, high-entropy session ID upon any privilege change, especially login and password reset
Implement a short, idle-session timeout (e.g., 15 minutes) and a longer, absolute-session timeout (e.g., 8 hours)
+2 more steps inside

Guardrail

Prevent Insufficient Test Coverage

AI-generated tests may only cover one path through a complex function, leaving other logical branches (e.g., else blocks, catch blocks) untested and unverified.

Engineers

QA

Manual Checklist

Primary Fix: Configure a test coverage tool (e.g., JaCoCo, Istanbul, pytest-cov) to run in your CI pipeline
Set a "quality gate" that fails the build if coverage decreases or drops below a set threshold (e.g., 80%)
Measure decision or branch coverage, not just line coverage. 100% line coverage is a vanity metric; 100% branch coverage is robust
+2 more steps inside

Guardrail

Prevent Memory Leak In Event Handlers

AI-generated JavaScript code, especially for UI components, often adds event listeners (e.g., addEventListener) but fails to remove them when the component is destroyed, creating memory leaks as the listeners hold references.

Engineers

Platform

Manual Checklist

Primary Fix: Always explicitly call removeEventListener with a named function reference when the component or element is unmounted
In frameworks (React, Vue), use the built-in lifecycle methods to clean up listeners (e.g., the return function in a React useEffect hook)
Use WeakMap or WeakSet for caching or storing object references, as they do not prevent garbage collection
+2 more steps inside

Guardrail

Prevent Missing Api Versioning

AI-generated code will create API endpoints without a versioning strategy (e.g., /users instead of /v1/users), making it impossible to introduce breaking changes in the future without breaking existing clients (see Guardrail 51).

Engineers

Manual Checklist

Primary Fix: Version your API from day one. The most common and explicit method is URI path versioning (e.g., /api/v1/resource)
Other (less common) methods include header-based (e.g., Accept: application/vnd.api.v1+json) or query-param-based versioning
Follow Semantic Versioning (SemVer): v1 (major, breaking), v1.1 (minor, new features), v1.1.2 (patch, bug fixes)
+2 more steps inside

Guardrail

Prevent Missing Authentication Headers

AI-generated client code for a protected API may forget to attach the Authorization header (e.g., Bearer [token]), causing all requests to fail with 401 Unauthorized.

Engineers

Manual Checklist

Primary Fix: Use a persistent HTTP client middleware (or "interceptor") to automatically attach the Authorization header to every outgoing request
Do not manually add the header in every function; centralize it in one place
Securely fetch and refresh the token (e.g., OAuth2 refresh flow) and update the middleware with the new token
+2 more steps inside

Guardrail

Prevent Missing Connection Pooling

AI-generated database code may naively open a new database connection for every single query and then close it, which is extremely slow and will quickly exhaust database resources.

Engineers

Platform

Manual Checklist

Primary Fix: Always use a database connection pooler (e.g., PgBouncer, HikariCP, or built-in ORM pooling)
Configure the pool's max_connections to a reasonable number based on database capacity (e.g., 20-100), not thousands
Use Transaction Pooling mode (pool_mode = transaction) in PgBouncer for the best performance in serverless or short-lived functions
+2 more steps inside

Guardrail

Prevent Missing Database Indexes

AI-generated queries are functionally correct but often lack awareness of performance, resulting in WHERE or JOIN clauses on un-indexed columns that cause slow, full table scans.

Engineers

Platform

Manual Checklist

Run EXPLAIN or query plan analysis on all new, non-trivial AI-generated queries to identify bottlenecks (e.g., "Full Table Scan")
Add composite indexes on columns frequently used together in WHERE, JOIN, and ORDER BY clauses
Ground the AI with the schema (using `ai-behavior/stop-schema-guessing`) and prompt it to "suggest optimal indexes for this query"
+2 more steps inside

Guardrail

Prevent Missing Edge Case Testing

AI-generated tests are excellent at covering the "happy path" (e.g., valid input) but consistently fail to test edge cases (e.g., null, 0, -1, empty string, max length), leading to a false sense of security.

Engineers

QA

Manual Checklist

Use Boundary Value Analysis (BVA): for a range [1, 100], test 0, 1, 100, and 101
Use Equivalence Partitioning (EP): divide inputs into classes (e.g., valid, invalid, null) and test one from each class
Use the `code-quality/tdd-with-ai-pair` workflow to first write failing tests for these edge cases
+2 more steps inside

Guardrail

Prevent Missing Health Checks

AI-generated services often lack /health or /ready endpoints, so container orchestrators (like Kubernetes) have no way to know if the application is running, deadlocked, or ready to serve traffic.

Engineers

Platform

Manual Checklist

Implement a Liveness Probe (e.g., /healthz). This is a shallow check: "Is the process running?" If it fails, Kubernetes will restart the container
Implement a Readiness Probe (e.g., /readyz). This is a deep check: "Is the app ready to serve traffic?" (e.g., DB connected, cache warm). If it fails, Kubernetes stops sending traffic
Implement a Startup Probe for slow-starting applications (e.g., Java) to prevent the Liveness/Readiness probes from failing before the app is initialized
+1 more steps inside

Guardrail

Prevent Missing Https Enforcement

AI-generated server configurations or application code may bind to HTTP without automatically redirecting to HTTPS, exposing users to man-in-the-middle (MITM) attacks, session hijacking, and credential theft.

Engineers

Security

Manual Checklist

Configure the web server or load balancer (e.g., Nginx, ELB) to perform a server-side, permanent (301) redirect from HTTP to HTTPS
Implement the HTTP Strict-Transport-Security (HSTS) header to force browsers to only communicate via HTTPS
Set the Secure attribute on all sensitive cookies (especially session cookies) to prevent them from being sent over HTTP
+2 more steps inside

Guardrail

Prevent Missing Idempotency Check

AI-generated POST/PUT endpoints are not "idempotent" by default. If a client retries a request due to a network error, the server will process the same operation multiple times, creating duplicate data or charges.

Engineers

Product Managers

Manual Checklist

Primary Fix: Require a unique, client-generated Idempotency-Key (e.g., a UUID) in the HTTP header for all state-changing (POST, PUT, PATCH) requests
On the server, check if this key has been seen before within a recent time window (e.g., 24 hours)
If key is new: Process the request, then store the HTTP result (e.g., 201 Created, the JSON body) in a cache (like Redis) with the key
+2 more steps inside

Guardrail

Prevent Missing Integration Tests

AI is good at generating "unit tests" that test functions in isolation. It fails to generate "integration tests" that verify that multiple services (e.g., your app, a database, and an external API) work together correctly.

Engineers

QA

Manual Checklist

Primary Fix: Implement a "Test Pyramid" strategy: have many unit tests, some integration tests, and few end-to-end tests
Write integration tests that check the full flow of a feature (e.g., "API endpoint -> Database" or "API -> External API")
Use test containers (e.g., Testcontainers) to spin up real, ephemeral dependencies (like a real PostgreSQL or Redis container) for your tests
+2 more steps inside

Guardrail

Prevent Missing Load Testing

AI-generated code works perfectly for a single user, but teams trust it and deploy it without load testing, where it fails under concurrent load due to issues like race conditions, N+1 queries, or missing pools.

Engineers

Platform

Manual Checklist

Integrate load testing into the `process/release-readiness-runbook` workflow before every production release
Define clear Service Level Objectives (SLOs) (e.g., "p99 latency < 500ms") and fail the test if they are breached
Use load testing tools (e.g., k6, Artillery, JMeter) to simulate realistic user traffic, not just "ping" the endpoint
+2 more steps inside

Guardrail

Prevent Missing Negative Test Cases

AI-generated tests excel at the "happy path" (e.g., "test valid login") but almost never generate "negative tests" (e.g., "test invalid login," "test empty password," "test locked-out user").

Engineers

QA

Manual Checklist

Primary Fix: For every "happy path" test, write at least one "unhappy path" (negative) test
Test for invalid inputs (e.g., bad format, out of range), as defined by your BVA and EP (Guardrail 61)
Test for invalid states (e.g., "try to charge an unpaid invoice" or "log in with a suspended account")
+2 more steps inside

Guardrail

Prevent Missing Pagination In Api Client

AI-generated client code for a paginated API (e.g., GET /items) may forget to handle pagination, only requesting the first page of data (e.g., the first 25 items) and silently ignoring the rest.

Engineers

Manual Checklist

Primary Fix: When calling a list endpoint, check the response body for pagination metadata (e.g., next_page_token, has_more, total_pages)
If pagination metadata exists, implement a loop (while (next_page_token)) to "follow the pages" and aggregate all results
Always set a sane maximum number of pages to fetch to prevent accidental infinite loops or resource exhaustion
+2 more steps inside

Guardrail

Prevent Missing Performance Tests

AI-generated code works for one user, but teams deploy it without performance testing. The code is inefficient and fails under real-world load (e.g., N+1 queries, slow algorithms). This is a duplicate of Guardrail 32.

Engineers

QA

Manual Checklist

Integrate performance testing into the `process/release-readiness-runbook` workflow before every production release
Define clear Service Level Objectives (SLOs) (e.g., "p99 latency < 500ms," "error rate < 0.1%") and fail the test if they are breached
Use load testing tools (e.g., k6, Artillery, JMeter) to simulate realistic, concurrent user traffic
+2 more steps inside

Guardrail

Prevent Missing Price Validation

AI-generated checkout code may trust a price or subtotal field submitted from the client (e.g., the browser), allowing an attacker to modify the request and buy items for $1.

Engineers

Product Managers

Manual Checklist

Primary Fix: NEVER trust a price field from a client (browser, mobile app)
Always re-calculate the total price on the server-side by fetching the item's price directly from the database based on the SKU or product_id
The only fields the server should accept from the client are product_id and quantity
+2 more steps inside

Guardrail

Prevent Missing Rate Limiting

AI-generated API endpoints often lack any rate limiting, making them vulnerable to Denial of Service (DoS) attacks, brute-force login attempts, and resource exhaustion.

Engineers

Security

Manual Checklist

Implement rate limiting on all public-facing API endpoints, especially compute-heavy or sensitive ones (e.g., /login, /search, /payment)
Configure limits based on multiple factors (e.g., per IP, per user ID, per API key)
Use a "sliding window" or "token bucket" algorithm for more effective limiting than a simple "fixed window"
+2 more steps inside

Guardrail

Prevent Missing Request Validation

AI-generated API endpoints often "trust" incoming data, failing to validate the request.body for required fields, correct types, or valid ranges, leading to NullPointerExceptions, security flaws, and data corruption.

Engineers

Manual Checklist

Primary Fix: Define a strict JSON Schema or use a data-validation library (e.g., Pydantic, Zod, Spring Validation) for every endpoint
Validate everything: check for required fields, data types (string, int), formats (e.g., email, uuid), and ranges (min, max)
Use your OpenAPI/Swagger specification as the source of truth and automatically generate validation rules from it
+2 more steps inside

Guardrail

Prevent Missing Retry Logic

AI-generated client code often fails permanently on transient, temporary network errors (e.g., 503 Service Unavailable, 429 Rate Limit), when a simple retry would have succeeded, leading to brittle services and user-facing errors.

Engineers

Platform

Manual Checklist

Primary Fix: Implement retry logic only for transient, idempotent-safe errors (e.g., 503, 429, timeout)
Crucial: Never retry on 4xx client errors (e.g., 400, 401, 404), as these will never succeed
Use Exponential Backoff: increase the wait time between retries (e.g., 1s, 2s, 4s) to give the downstream service time to recover
+2 more steps inside

Guardrail

Prevent Missing Retry Logic For Api Calls

AI-generated API client code will often fail permanently on transient network errors (e.g., 503, timeout), when a simple retry would have succeeded. This is identical to Guardrail 41, focused on the client integration.

Engineers

Manual Checklist

Primary Fix: Implement retry logic only for transient, idempotent-safe errors (e.g., 503, 504, 429, ConnectionTimeout)
Crucial: Never retry on 4xx client errors (e.g., 400, 401, 404), as these will never succeed
Use Exponential Backoff: increase the wait time between retries (e.g., 1s, 2s, 4s) to give the downstream service time to recover
+2 more steps inside

Guardrail

Prevent Missing Security Tests

AI-generated code is highly prone to security vulnerabilities, but AI-generated tests almost never include security assertions, focusing only on "happy path" functionality.

Engineers

QA

Manual Checklist

Primary Fix: Integrate automated security testing tools directly into the CI/CD pipeline (this is DevSecOps)
SAST (Static Analysis): Run tools (e.g., Snyk, Semgrep) that scan the source code for vulnerabilities (e.g., SQLi, hardcoded secrets)
DAST (Dynamic Analysis): Run tools (e.g., OWASP ZAP) that "attack" the running application in a test environment
+2 more steps inside

Guardrail

Prevent Missing Timeout Configuration

AI-generated HTTP or database clients often omit timeout configurations, causing the application to hang indefinitely while waiting for a slow or unresponsive dependency, leading to resource exhaustion (sockets, threads).

Engineers

Platform

Manual Checklist

Primary Fix: Always set an aggressive, short timeout (e.g., 2-5 seconds) on all network calls (HTTP, DB, gRPC)
Configure different types of timeouts: connection timeout (how long to connect) and read timeout (how long to wait for data)
Use dynamic timeouts that adjust based on real-time service latency (e.g., p99 latency)
+2 more steps inside

Guardrail

Prevent Missing Validation For Business Rules

AI-generated code may handle technical logic (e.g., "charge card") but fail to encode complex business logic (e.g., "but only if user is in-region and not on a 'freemium' plan").

Engineers

Product Managers

Manual Checklist

Primary Fix: Externalize complex business rules from application code into a separate Business Rules Engine (BRE) like Drools
Ground the AI with the business context: "Generate code to charge a user, but first, validate these rules: [list of rules]"
Use a cognitive-verifier pattern: prompt a separate AI to "find any business rules this code forgot to check"
+2 more steps inside

Guardrail

Prevent N Plus One Query Problem

AI-generated code for fetching data often retrieves a list of "parent" items (1 query), then loops through the list and executes a new query for each item's "children," resulting in N+1 database queries.

Engineers

Platform

Manual Checklist

Use eager loading in your ORM to fetch the children in the initial query using a JOIN (e.g., JPA/Hibernate: JOIN FETCH, Django: select_related)
For many-to-many relationships, use batch fetching to load all children in a second, batched query (e.g., Hibernate: @BatchSize, Django: prefetch_related)
Use a DataLoader pattern, common in GraphQL, to automatically batch child-object requests
+1 more steps inside

Guardrail

Prevent Orphaned Records From Cascading Delete

AI-generated schema changes or DML scripts may lack proper foreign key constraints, or may implement a DELETE without accounting for related records, leading to orphaned data and broken referential integrity.

Engineers

Platform

Manual Checklist

Enforce declarative foreign key constraints (e.g., ON DELETE RESTRICT or ON DELETE SET NULL) at the database level
Never rely on the application to manage cascades. Use database-level ON DELETE CASCADE only when the business logic is truly appropriate
Ground the AI with the full relational schema using `ai-behavior/stop-schema-guessing`
+2 more steps inside

Guardrail

Prevent Path Traversal Vulnerability

AI-generated code that accesses files (e.g., for downloads or previews) may insecurely concatenate user input (like a filename) into a file path, allowing attackers to use ../ sequences to read sensitive files (e.g., /etc/passwd).

Engineers

Security

Manual Checklist

Primary Fix: Validate that the user-supplied filename contains only permitted characters (e.g., alphanumeric, dot, underscore)
After validation, append the user input to a pre-defined, absolute base directory
Crucial: Use a platform API to canonicalize the final path (e.g., resolve ../) and then verify that the canonical path still starts with the base directory
+2 more steps inside

Guardrail

Prevent Race Conditions In Concurrent Updates

AI-generated code often implements naive "read-modify-write" logic (e.g., SELECT, modify value in code, then UPDATE), which creates race conditions that cause "lost updates" and data corruption under concurrent load.

Engineers

Platform

Manual Checklist

Use atomic database operations where possible (e.g., UPDATE counters SET value = value + 1 WHERE id =?)
For complex logic, wrap the read-modify-write in a transaction and use pessimistic locking (SELECT... FOR UPDATE) to block other transactions
Alternatively, use optimistic locking by adding a version column, reading it, and validating it during the UPDATE
+2 more steps inside

Guardrail

Prevent Rate Limit Exceeded

When AI generates an API client, it often fails to respect the rate limits of the server it's calling. The client hammers the server, gets a 429 Too Many Requests error, and fails.

Engineers

Manual Checklist

Primary Fix: Implement retry logic (Guardrail 41) that specifically handles 429 status codes
When a 429 is received, honor the Retry-After header if it's provided by the server
If Retry-After is not provided, use Exponential Backoff with Jitter to slow down
+2 more steps inside

Guardrail

Prevent Resource Exhaustion From Memory Leak

AI-generated code (e.g., in Node.js, Python, Java) can introduce slow memory leaks (e.g., un-removed event listeners, static collections, unclosed resources) that gradually consume all available heap memory, causing the application to crash (OOM).

Engineers

Platform

Manual Checklist

In event-driven code (JS), always remove listeners when objects are destroyed (See Guardrail 26)
Never store large, per-request data in static or global variables
Use WeakMap or WeakSet for caches that should not prevent garbage collection
+2 more steps inside

Guardrail

Prevent Silent Data Truncation

AI-generated code (e.g., for migrations or ETL jobs) may miscalculate field lengths or types, causing data to be silently truncated (e.g., VARCHAR(255) to VARCHAR(50)) without raising an error.

Engineers

Platform

Manual Checklist

Use the `ai-behavior/stop-schema-guessing` workflow to ensure the AI has the exact target schema
Before migration, run a "dry run" validation query to find all data that would be truncated (e.g., SELECT * FROM table WHERE LENGTH(column) > 50)
In data processing, validate data length before inserting and explicitly log or reject oversized data
+2 more steps inside

Guardrail

Prevent Single Point Of Failure

AI-generated deployment configurations (e.g., Kubernetes manifests, Terraform) may default to deploying a single instance (N=1) of a service, creating a Single Point of Failure (SPOF) that causes a total outage if it fails.

Engineers

Platform

Manual Checklist

Primary Fix: Run at least N+1 (e.g., 3) instances (replicas) of every critical, stateless service
Distribute replicas across multiple physical failure domains (e.g., different nodes, racks, or cloud Availability Zones)
Use a load balancer to distribute traffic across all healthy replicas
+2 more steps inside

Guardrail

Prevent Sql Injection Vulnerability

AI-generated code is highly prone to writing insecure, string-concatenated SQL queries, as this pattern is common in its training data. This is a classic injection vulnerability.

Engineers

Security

Manual Checklist

Primary Fix: Exclusively use parameterized queries (prepared statements). This separates the query logic from the data
Use a modern ORM (Object-Relational Mapper) which typically parameterizes queries by default
Sanitize all user input using an "allow-list" approach, rejecting any input that does not match the expected format
+2 more steps inside

Guardrail

Prevent Synchronous Blocking Operations

AI-generated Node.js code often defaults to using synchronous I/O methods (e.g., fs.readFileSync()) because they are simpler to write, but this blocks the main event loop, killing performance for all other users.

Engineers

Platform

Manual Checklist

Primary Fix: Never use synchronous (...Sync) versions of I/O (file, network) or child_process methods in a server context
Always use the asynchronous, non-blocking versions (e.g., fs.readFile()) with Promises (async/await) or callbacks
For CPU-intensive tasks (e.g., image processing, crypto), move them off the main thread using Worker Threads
+2 more steps inside

Guardrail

Prevent Test Data Pollution

AI-generated tests may not clean up after themselves, leaving "polluted" data (e.g., test_user_123) in the test database. This causes other tests to fail intermittently when they collide with this data.

Engineers

QA

Manual Checklist

Primary Fix: Ensure every test is idempotent and isolated. Each test must create its own required data and destroy it afterward
Use a setup() and teardown() function (e.g., beforeEach/afterEach) to create and delete test-specific data for every single test
Better yet, wrap every test in a database transaction, and execute a ROLLBACK in the teardown() step. This is faster and cleaner
+2 more steps inside

Guardrail

Prevent Test Environment Mismatch

AI-generated tests pass in a "mock" or local environment, but the code fails in production because the test environment did not match production (e.g., different dependency versions, missing service, different data).

Engineers

QA

Manual Checklist

Primary Fix: Use Infrastructure as Code (IaC) (e.g., Terraform, Docker Compose) to define all environments (local, CI, staging, prod) from the same source files
Use Docker containers to ensure all developers and the CI pipeline run the code with the exact same OS and dependency versions
Use tools like LocalStack to simulate cloud (AWS) services locally
+2 more steps inside

Guardrail

Prevent Type Coercion Errors In Batch Processing

AI-generated code in dynamically-typed languages (like JavaScript) often uses implicit type coercion (e.g., 1 + "2" = "12"), which causes silent data corruption in batch processing jobs.

Engineers

Platform

Manual Checklist

Use static typing (e.g., TypeScript, Python type hints) to enforce data contracts and catch type mismatches at compile time
Enforce strict equality (===) and inequality (!==) operators to prevent implicit type coercion during comparisons
Explicitly parse and validate all incoming data types (e.g., using parseInt(), Number()) at the start of the batch job
+2 more steps inside

Guardrail

Prevent Unbounded Result Sets

AI-generated data queries often forget to add a LIMIT clause, resulting in unbounded queries (e.g., SELECT * FROM users) that can crash the application by exhausting memory or DDoSing the database.

Engineers

Platform

Manual Checklist

Primary Fix: Never run a query without a LIMIT clause in an application context
Enforce a mandatory, default pagination limit (e.g., 25) on all API endpoints that return a list
Enforce a server-side maximum limit (e.g., 100) that a user cannot override, even if they request ?limit=1000
+2 more steps inside

Guardrail

Prevent Weak Password Validation

AI-generated code often suggests outdated password policies (e.g., "must have 1 number, 1 capital, 1 symbol") that encourage weak, predictable passwords, rather than modern, evidence-based standards.

Engineers

Security

Manual Checklist

Primary Fix: Follow NIST 800-63B guidelines
Enforce a long minimum length (e.g., 15 characters) and allow a very long maximum length (e.g., 64+ characters)
Crucial: Remove all character-complexity requirements (e.g., "must have a number"). Complexity rules do not add strength and frustrate users
+2 more steps inside

Guardrail

Prevent Xss Vulnerability

AI-generated code that renders data in a UI often fails to sanitize or encode it, injecting raw user input directly into HTML and exposing the application to XSS attacks.

Engineers

Security

Manual Checklist

Primary Fix: Use modern UI frameworks (e.g., React, Vue) that encode data by default, rather than using dangerouslySetInnerHTML or .innerHTML
Implement strict, context-aware output encoding. Encode data differently for HTML bodies, HTML attributes, JavaScript strings, and CSS values
Implement a Content Security Policy (CSP) header to create a defense-in-depth layer that blocks inline scripts and untrusted domains
+2 more steps inside

Operationalize AI guardrails with Engify workflows, automation, and institutional memory.

Product

Prompts
Patterns
Workflows
Tools
Learn
MCP Server

Company

About
Built in Public
Contact
LinkedIn

Resources

Documentation
Pattern Reference
Prompt Playbook

Social

GitHub
LinkedIn
Hire Me

Legal

Privacy
Terms

© 2025 Engify.ai. All rights reserved.

Built by Donnie Laur · donlaur@engify.ai