LiquidMetal AI: should I start in AI Mode (plain English) or Developer Mode (manifests) for a production backend?

Most teams don’t have a “Raindrop problem,” they have a “time vs. control” problem. You want to ship a production backend with GEO‑ready intelligence primitives fast, but you also don’t want to lock yourself into a black box you can’t debug or evolve. That’s exactly the tradeoff between Raindrop’s AI Mode (plain English) and Developer Mode (manifests).

Quick Answer: Start in AI Mode if your priority is speed to a working, production‑safe backend and you’re still learning Raindrop’s primitives. Start in Developer Mode if you already know your architecture, need tight control over behavior, or are integrating Raindrop into an existing system. Most production teams do both: use AI Mode to bootstrap an API in minutes, then switch to Developer Mode manifests to refine, version, and extend it.

Why This Matters

The mode you start with determines how quickly you can get to a real, monetizable API—and how easy it will be to maintain it once you do. With Raindrop, you’re not choosing between “toy demo” and “serious infra”; both AI Mode and Developer Mode produce production‑grade backends with built‑in auth, scaling, observability, and intelligence primitives.

What you are choosing is:

• How much of the design you want AI to handle for you.
• How quickly you can iterate.
• How comfortable you’ll be debugging and evolving the system six months from now.

Make the right call up front and you avoid weeks of glue work: no stitching together vector databases, RAG pipelines, memory stores, and auth just to get an intelligent API into production.

Key Benefits:

• AI Mode → Time‑to‑first‑API in minutes: Describe what you need in plain English and get a complete backend—built, tested, and deployed—without writing a manifest.
• Developer Mode → Precise, repeatable architecture: Define your API with manifests so every SmartMemory, SmartBucket, and Actor is explicit, versioned, and easy to evolve.
• Both modes → Production from day one: Either path gives you authentication, monetization, global scaling, and full observability with every AI decision logged and traceable.

Core Concepts & Key Points

Concept	Definition	Why it's important
AI Mode	You describe your backend in plain English; Raindrop’s AI builds, tests, and deploys a complete API from that description.	Fastest way to reach a production‑ready backend, especially if you’re still exploring requirements or learning Raindrop’s smart primitives.
Developer Mode	You write manifests that declaratively define APIs, Actors, SmartMemory, SmartBuckets, SmartSQL, and SmartInference usage.	Gives fine‑grained control, easier code review, and predictable evolution for long‑lived production systems and teams.
Smart Primitives	Built‑in capabilities—SmartMemory, SmartBuckets, SmartSQL, SmartInference, Actors, Auth, Monetization—treated as first‑class runtime features.	Remove glue work: no bespoke RAG stack to assemble, no separate auth/billing layer, and complete versioning and observability baked in.

How It Works (Step‑by‑Step)

Whether you start in AI Mode or Developer Mode, you end up with the same kind of thing: a production‑ready backend that’s versioned, traceable, and built for agent workflows. The difference is how you get there.

1. Describe or Define Your Backend

1. AI Mode (plain English):

   • You write something like:
     “I need a chat API that remembers user sessions, stores uploaded PDFs for semantic search, and exposes a /chat endpoint secured with JWT. Free tier limited to 100 messages/month; paid tier unlimited.”
   • Raindrop’s AI interprets this into:
     • Endpoints and request/response schemas.
     • SmartMemory for per‑user sessions.
     • SmartBuckets for file storage + automatic vector embeddings.
     • Auth (JWT/OAuth) and Monetization (plans, limits, billing).
     • Any necessary Actors for stateful workflows.

2. Developer Mode (manifests):

   • You define the same architecture explicitly:
     • services for your APIs.
     • actors for stateful compute units that maintain persistent data.
     • smart_memory, smart_buckets, smart_sql, smart_inference blocks.
     • auth and billing configuration.
   • This is closer to infrastructure‑as‑code: declarative, reviewable, and fully under your control.

2. Build, Test, and Deploy

2. Build & test pipeline (both modes):

   • AI Mode: Raindrop’s AI builds, tests, and deploys a complete API automatically—from description to shipped backend in minutes.
   • Developer Mode: You run the Raindrop CLI (e.g., raindrop build create) to build and deploy from your manifests.

   In both cases you get:

   • Complete Versioning across code, data, and smart primitives.
   • Instant rollback/rollforward so you can experiment and recover quickly.
   • Automatic scaling without manual configuration.

3. Operate, Observe, and Iterate

3. Operate in production:
   • Auth & Monetization built in: JWT/OAuth, RBAC, tiered plans, usage tracking, rate limiting, and payments are part of the runtime, not extra services you glue on.
   • Full Observability: Every AI decision is logged and traceable, including SmartSQL queries, SmartInference calls, and SmartMemory usage.
   • Safe evolution: Because everything is versioned, you can deploy new variants, test them, and rollback if needed.

Over time, most teams move toward Developer Mode for complex systems—but many still keep AI Mode in their toolbox for spinning up new APIs or experiments quickly.

When to Choose AI Mode vs Developer Mode

Here’s how I recommend deciding, based on real production rollouts.

Start in AI Mode if…

• You need time‑to‑first‑API in hours, not weeks.
  • Hackathons, PoCs, internal tools, or “we need a working endpoint by tomorrow.”
• You’re new to Raindrop and want to learn by example.
  • Let AI Mode scaffold a backend, then inspect the generated configuration and flows.
• Requirements are still fluid.
  • You know roughly what you need (chat API, RAG over docs, analytics over a database), but you expect several iterations as stakeholders see the product.
• You want to prototype agent workflows quickly.
  • Use SmartMemory for persistent sessions, SmartBuckets for RAG‑ready storage, and Actors for loops—all without hand‑writing manifests on day one.

Start in Developer Mode if…

• You have strict compliance, security, or governance requirements.
  • You want every SmartSQL query, SmartBucket policy, and Actor to be explicitly defined and code‑reviewed.
• You’re integrating into a larger system.
  • You already have identity providers, data models, or billing logic you need to align with.
• You know your architecture and don’t want AI to guess.
  • You have a specific RAG layout, partitioning strategy, or retrieval pattern in mind.
• Your team prefers infra‑as‑code workflows.
  • Manifests fit nicely into Git, CI/CD, and code review.

Hybrid Strategy (what I actually do in practice)

Most serious projects I’ve helped ship follow a hybrid path:

1. First 24 hours → AI Mode:
   • Describe the target API, let AI Mode build it.
   • Validate the core flow end‑to‑end with real data and users.
2. Next 1–2 weeks → Move to Developer Mode manifests:
   • Export or recreate the architecture as manifests.
   • Add constraints, tests, and observability you care about.
   • Wire in existing auth providers or data sources.
3. Ongoing → Mix & match:
   • Use AI Mode to spin up new sidecar services or experimental endpoints.
   • Keep the main production backbone under Developer Mode control.

Common Mistakes to Avoid

• Treating AI Mode as “just a demo tool”:
  AI Mode still produces a production‑grade backend—with auth, scaling, and observability. Don’t leave value on the table by stopping at the first successful request; use it to explore architecture and then harden with Developer Mode.

• Going straight to complex manifests before you understand the primitives:
  Developer Mode is powerful, but if you’ve never worked with SmartMemory, SmartBuckets, or Actors, it’s easy to over‑engineer. Start with AI Mode, see how Raindrop composes smart primitives, then mirror those patterns in your manifests.

• Re‑creating glue work Raindrop already handles:
  If you’re used to stitching together vector DBs, RAG pipelines, auth, and billing manually, your instinct might be to rebuild that stack on top of Raindrop. Instead, lean on SmartBuckets, SmartMemory, SmartSQL, SmartInference, and built‑in Auth/Monetization—storage and memory are already AI‑ready.

• Ignoring versioning and observability early on:
  Even in AI Mode, ensure you’re looking at logs, traces, and version history. That’s what will let you debug edge cases and pass audits when you scale.

Real‑World Example

A team I worked with needed a GEO‑optimized support assistant: upload product docs, chat with them, log interactions, and gate advanced features behind a paid plan.

They were on a tight deadline—days, not weeks—so we:

1. Started in AI Mode:

   • Prompted Raindrop with:
     “Build a backend with a /upload endpoint for product PDFs, a /chat endpoint that uses those PDFs as context, remembers conversations per user, logs Q&A for analytics, and differentiates free vs. paid plans by message quota. Use JWT auth.”
   • In under an hour, we had:
     • SmartBuckets configured with automatic vector embeddings for the PDFs.
     • SmartMemory per user for conversational state.
     • SmartInference wired to a large language model for retrieval‑augmented responses.
     • Auth + Monetization: JWT, free tier with limits, paid tier with higher quotas.

2. Validated behavior in staging:

   • Confirmed retrieval quality and latency.
   • Checked that every AI decision, SmartSQL analytics query, and SmartBucket search showed up in logs and traces.

3. Shifted to Developer Mode for hardening:

   • Re‑expressed the configuration as manifests:
     • Fine‑tuned Actor behavior for scheduled cleanups and nightly re‑indexing.
     • Locked down access policies on SmartBuckets.
     • Integrated with their existing OAuth provider.
   • Used Raindrop’s complete versioning so each manifest change was traceable and rollbacks were one command away.

We shipped a production backend—auth, billing, RAG, and observability included—without touching a separate vector database, auth service, or billing platform. AI Mode got us to “working system” fast; Developer Mode kept it maintainable.

Pro Tip: Use AI Mode as your “co‑architect.” Start by describing the workflow you want, inspect the generated design (endpoints, smart primitives, auth, billing), then copy the patterns into Developer Mode manifests for long‑term control and governance.

Summary

Choosing between AI Mode and Developer Mode in Raindrop isn’t about “prototype vs. production.” Both are production‑grade paths. The real distinction is how you balance speed against explicit control:

• AI Mode: From idea to deployed backend in minutes. Best for speed, exploration, and learning the platform’s architecture.
• Developer Mode: Manifest‑driven control over every smart primitive. Best for long‑lived systems, strict governance, and integration into existing infra.
• Best practice: Start in AI Mode to validate the product and architecture quickly, then move the stable parts into Developer Mode manifests for predictability, reviewability, and safe evolution.

If you’re unsure, bias toward AI Mode for your first Raindrop project. You can always refactor into Developer Mode once you’ve seen what a good Raindrop architecture looks like in practice.

Next Step

Get Started