5 Security Risks of AI-Generated Code (and How to Fix Them)

When AI assistants build features that call other AI APIs, they often pass user input directly into prompts without sanitization. This is prompt injection — the #1 risk in the OWASP Top 10 for LLM Applications.

// AI-generated code — looks fine, is vulnerable
app.post("/chat", async (req, res) => {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      { role: "system", content: SYSTEM_PROMPT },
      { role: "user", content: req.body.message }, // injection!
    ],
  });
});

The fix: Validate and sanitize user input before passing it to LLM APIs. Set input length limits. Use prompt boundary tokens. ShipSafe has 7 dedicated prompt injection rules that catch this pattern automatically.

This is the most common vulnerability in AI-generated code. AI assistants often use API keys they find in the project context, or generate placeholder keys that look real. Developers then commit the code without noticing.

// AI helpfully adds your Stripe key directly
const stripe = require("stripe")("sk_live_4eC39HqLyjWDarjtT1zdp7dc");

// AI copies the database URL from your .env into code
const db = new Pool({
  connectionString: "postgresql://admin:secret@db.example.com/prod"
});

The fix: Always use environment variables for secrets. Install ShipSafe git hooks to block commits containing any of the 174 detected secret patterns.

AI assistants sometimes generate raw SQL queries with string interpolation instead of parameterized queries. This is especially common when the AI is not sure which ORM you use, or when generating complex queries that do not fit the ORM API.

// AI generates a search endpoint with raw SQL
export async function searchProducts(query: string) {
  const results = await db.execute(
    `SELECT * FROM products WHERE name LIKE '%${query}%'`
  );
  return results;
}

The fix: Always use parameterized queries. With Prisma, use the tagged template syntax. ShipSafe has 127 SQL injection rules including Prisma and Next.js-specific awareness.

When AI generates API endpoints, it often focuses on functionality and skips authentication. This is especially dangerous for admin routes, delete operations, and data modification endpoints. The AI gets the business logic right but forgets the security layer.

// AI generates working CRUD — but no auth
app.delete("/api/users/:id", async (req, res) => {
  await db.query("DELETE FROM users WHERE id = $1", [req.params.id]);
  res.json({ deleted: true });
});

// Anyone can delete any user!

The fix: Always add authentication middleware to sensitive routes. ShipSafe detects 98 authentication vulnerability patterns including missing auth middleware, weak password hashing, and insecure session management.

This risk is unique to applications that handle user-uploaded images. Every photo taken with a smartphone contains EXIF metadata including GPS coordinates, camera model, timestamp, and sometimes even the photographer’s name. When your app serves these images without stripping metadata, you are leaking user location data.

AI assistants almost never think about image metadata. They build the upload, processing, and serving pipeline — but leave EXIF data intact.

The fix: ShipSafe’s MetaStrip integration (added in v1.0.6) automatically detects and strips image metadata from committed images. The git hook catches images with GPS data before they reach your repository.

AI Speed Requires AI Security

The productivity gains from AI coding are too large to ignore. But shipping code at AI speed without security scanning is like driving 200 mph without a seatbelt. ShipSafe is the seatbelt. It runs at machine speed, catches machine-generated vulnerabilities, and integrates directly with your AI workflow through MCP.

Security should not slow you down. With ShipSafe, it does not.