Stop vibe-coding backends. Just declare them.

Why do vibe-coded backends break?

The problem isn't that AI writes bad code — it's that the backend it writes fails in ways you don't see until production: a missing access check, a dropped constraint, a webhook with no trace. Here's where it shows up first.

This isn't a prompting problem. It's what happens when AI regenerates a backend — the same CRUD, auth, and schema plumbing every app needs. Kirak's answer: that layer isn't generated, it's the runtime. The model files in models/ hold the schema and access rules; the agent appends to a declaration instead of rewriting code. What's left is a few hundred lines of hooks — small enough to read.

One declaration in. A running API out.

You write a few JSON files and, when something is genuinely custom, a hook. Kirak — the runtime — does everything from there: serves it, secures it, and shows you how it's running in production.

{
  "schema": { "vehicle_id": {"type":"uuid"}, "starts_at": {"type":"datetime"}, "ends_at": {"type":"datetime"} },
  "access": {
    "fetch":   [{"role":"admin"}, {"role":"user","condition":"renter_id = {user_id}"}],
    "destroy": [{"role":"admin"}]
  }
}

# sync hooks are a blocking pipeline: each takes the request, changes it,
# and hands it to the next hook or the operation -- or stops it by raising
@kirak.on("booking").hook("before_create")
def check_and_price(payload):
    data = payload["data"]
    if data["ends_at"] <= data["starts_at"]:
        raise ValidationError("ends_at must be after starts_at")  # 400
    data["deposit_cents"] = data["total_cents"] * 20 // 100
    return payload

# async hooks are non-blocking: a failure or timeout is logged, never fails the request
@kirak.on("booking").hook("after_create")
async def notify_owner(result):
    await kirak.notifications.send_email({"to": OWNER, "template_name": "new_booking"})
    return result

POST /booking                        142ms · 201

  auth.verify              ▓ 8ms
  hook: check_availability ░▓▓▓▓▓ 41ms
  └ db.overlaps (booking)  ░▓▓▓▓ 28ms
  db.insert (booking)      ░░░░░░▓▓▓ 19ms
  stripe.charge            ░░░░░░░░░▓▓▓▓▓▓▓▓ 61ms

Why Kirak instead of Supabase?

Supabase is built for JavaScript and database-level logic — SQL policies, Edge Functions on Deno. Kirak brings that same declare-and-go speed natively to Python: your JSON model files directly serve the API with full row- and column-level security, your custom logic is FastAPI you own, and there's no separate runtime or generated clutter to maintain.

Kirak Studio is a few weeks out.

Describe what you're building, and the AI agent writes your models, kirak.json, hooks, and endpoints, builds the codebase, and deploys it to a VPS in one click. Same runtime underneath — Studio is the managed way to run it, and a Studio project always checks out to your own GitHub. It's in final development now; join the waitlist and we'll email you the day it opens.

Everything a production backend needs. Already running.

Kirak isn't a starter kit you fill in. It reads your model files and kirak.json and serves the whole backend — the same implementation behind every project.

Authentication

JWT sessions with MFA, passwordless SMS one-time codes, API keys for server-to-server calls, and email verification, built into Kirak Auth. Social login through Social Core.

GoogleGitHubAppleMicrosoftLinkedInDiscord+ 200 more

Payments

Checkout, subscriptions, refunds, saved cards and off-session charges, disputes, and marketplace payouts — with webhook verification & reconciliation, in any currency, served by the runtime, not a hook you maintain. Run several gateways side by side.

StripePayPalPaddleRazorpaySquare+ 7 more

Storage

File and image upload with automatic compression and thumbnails, on local disk or any of nine object stores.

LocalS3Cloudflare R2Google Cloud StorageAzure Blob+ 5 more

Notifications

Email, SMS, push, instant messages, outgoing webhooks, and an in-app inbox.

SESSendGridSMTPTwilioFirebaseSlack+ 6 more

Scheduler

Background jobs, retries, and cron — in code or as schedules managed over HTTP — with zero extra infrastructure by default; run several queue backends at once to scale:

RedisRabbitMQ

AI

Declarative agents in agents/*.json that use your API's operations — and MCP servers — as tools, running as the caller under your access rules. Human approval before sensitive tools, cost caps, conversations, streaming, structured output, and full run history. Bring your own key; built on pydantic-ai, so any model it supports works.

OpenAIAnthropicGeminiOpenRouter+ any pydantic-ai model

Vector

Vector stores and embeddings for RAG — create indexes, upsert, and search from your hooks and routes. Agents retrieve through it as a tool, so the agent decides when to look something up; there's no fixed pipeline to maintain.

PineconeS3 VectorsEmbeddings:OpenAIGeminiOllama

Caching

Native Redis caching, declared per model.

Redis

Monitoring

Performance data, structured logs, error tracking, request tracing, AI run costs, MCP tool calls, audit records, and alert checks — built into the runtime, not bolted on.

MCP

Declare MCP servers in mcp/*.json — one per audience, each choosing the operations it offers as tools, who may connect, and a rate limit. Any MCP client can connect, and every tool call runs as the caller, under your access rules. Nothing is exposed until you declare it.

Coding agents

kirak new writes an AGENTS.md and JSON Schemas for every file; kirak validate checks each edit before the app starts; kirak catalog --json answers facts instead of guessing; kirak dev mcp is a dev MCP server for your coding agent; and GET /docs describes the running API in Markdown.

Claude CodeCursorCodex

Free forever. Studio when it's ready.

Kirak is open source and always free. Kirak Studio, the managed build-and-deploy service, is in final development — join the waitlist to get notified the day it opens.