Skip to main content

API Generation With AI

5 min read
BackendApi DevGeneral Swe

Backend

AI writes CRUD. You design the contract, handle errors, and think about scale.

Api Dev

Versioning, backwards compatibility, and DX need human judgment. AI drafts; you decide.

API Generation With AI

TL;DR

  • AI can scaffold REST endpoints and GraphQL schemas in seconds. It gets the syntax right; architecture is your call.
  • Your edge: API design (naming, versioning, error handling), backwards compatibility, and the experience of the developers who consume your API.
  • Use AI for implementation speed. Own the contract and the consequences.

AI has seen thousands of Express routers, FastAPI handlers, and GraphQL resolvers. It can generate working API code. What it can't do is decide whether your API should be REST or GraphQL, how to version it, or what happens when a client sends garbage. That's you.

What AI Does Well

  • CRUD endpoints. Create, read, update, delete. Predictable patterns, well-represented in training data.
  • Basic validation. Required fields, types. AI knows Pydantic, Zod, etc.
  • Boilerplate structure. Route handlers, middleware wiring, basic error responses.
  • Documentation generation. OpenAPI/Swagger from code. AI can draft it; you refine.

What AI Gets Wrong

  • API design decisions. RESTful resource naming, when to use POST vs. PUT, idempotency. AI suggests; you decide.
  • Error contracts. Status codes, error shapes, retry semantics. These are product decisions.
  • Versioning strategy. URL vs. header vs. content negotiation. AI has opinions; they might not fit your org.
  • Backwards compatibility. Breaking changes, deprecation, migration paths. Requires human judgment.
  • Rate limiting, auth, idempotency keys. AI may add them; it often does so incorrectly or incompletely.

The Workflow That Works

  1. You design the contract. Endpoints, request/response shapes, error format. On paper or in a spec.
  2. AI implements the skeleton. "Create a FastAPI endpoint for PATCH /users/:id with this schema." You get 80% of the code.
  3. You add the hard parts. Validation edge cases, auth, rate limits, idempotency.
  4. You own the docs and versioning. AI can generate OpenAPI; you ensure it's accurate and useful.

Prompting for APIs

Weak: "Make a user API."

Strong: "FastAPI: GET /users (paginated, ?page=1&limit=20), GET /users/:id (404 if missing), PATCH /users/:id (partial update, validate against User schema). Use Pydantic for validation. Return JSON with { data, error } envelope. Add OpenAPI tags."

Specificity = less rework.

AI Disruption Risk for Backend Developers

Moderate Risk

SafeCritical

AI scaffolds APIs fast. API design, versioning, error contracts, and backwards compatibility need human judgment. Moderate risk for implementers; low for those who own the contract.

Design API on paper. Type every route handler, validation, error response. Wire OpenAPI. 2-3 days for a basic CRUD API.

Click "API Development With AI" to see the difference →

# Weak prompt → generic output
"Make a user API"

# Strong prompt → production-ready scaffold
"""FastAPI: GET /users (paginated ?page=1&limit=20),
GET /users/:id (404 if missing), PATCH /users/:id 
(partial update, Pydantic validation). 
Return { data, error } envelope. OpenAPI tags."""

Quick Check

AI generated a PATCH endpoint. What's the first thing you should verify before merging?

Do This Next

  1. Generate one API endpoint with AI using a detailed spec. List every change you made. That's your "AI API review" checklist.
  2. Document your API conventions (error format, pagination, versioning). Use it as context for every AI API prompt. Consistency improves output.