Introduction

How apps work here

You describe, the agent builds

When you work with Emergent, you're collaborating with an AI agent that handles all the implementation details. Here's how the division of labor works:

What the agent handles:

  • Writing all code (Python backend, React frontend, database schemas)
  • Setting up project structure and dependencies
  • Following web development best practices
  • Fixing bugs and runtime errors
  • Publishing and configuring infrastructure

What you decide:

  • The app's purpose and core features
  • User experience and interface choices
  • Business logic and workflows
  • When a feature is "done"
  • Which direction to take when multiple options exist

Think of it as pair programming

You're the product owner and architect; the agent is the developer who implements your vision. The clearer your requirements, the better the result.

This model lets you focus on what you want to build rather than how to build it. The agent translates your natural-language descriptions into working code, tests it, and publishes it - often in a single conversation.

For a concrete example of this workflow in action, see Your first build (walkthrough).

What's under the hood

Emergent apps are full-stack web applications, and the technology stack varies by template. The most common stack uses:

  • Backend: FastAPI (Python) - handles API endpoints, business logic, and data operations
  • Frontend: React - renders the user interface and manages client-side state
  • Database: MongoDB - stores your application data with flexible schemas

However, the stack depends on which template you choose. For example, Next.js projects use their own API routes instead of a separate FastAPI backend; the Python-only template has no frontend or MongoDB; and Mobile App projects are built with Expo/React Native.

Why this matters

Understanding the stack helps you communicate more effectively with the agent. When you say "add a REST endpoint" or "create a new collection," the agent knows exactly what you mean in the context of your chosen template's stack.

You don't need to write any of this code yourself, but knowing the foundation helps in a few situations:

  • Debugging: When something doesn't work, you can describe the problem using technical terms the agent understands
  • Integrations: If you want to connect external services, you'll know what capabilities the stack provides
  • Migration: If you ever need to export your app, you'll have a standard codebase built on your chosen template's frameworks

All code is generated according to modern best practices for each framework. The agent handles package management, routing, state management, and publish configuration automatically.

For help troubleshooting issues, see Debugging & testing with the agent.

What the AI knows vs what you think it knows

Common source of frustration

The agent is powerful, but it cannot read your mind. It only knows what you've explicitly told it in the current conversation.

The agent remembers:

  • Everything you've said in the current chat session
  • The current state of your app's code and structure
  • General web development knowledge and best practices
  • Common patterns for similar features

The agent does NOT automatically know:

  • Your industry-specific jargon or internal terminology
  • Implicit requirements you assume are "obvious"
  • Visual design preferences unless you describe them
  • Data formats or business rules you haven't mentioned
  • Context from previous projects or other apps

Being explicit pays off

Instead of: "Add the usual authentication" Try: "Add email/password authentication with a login page and signup page. Store user sessions with JWT tokens."

Instead of: "Make it look professional" Try: "Use a clean layout with a white background, blue primary buttons, and cards with subtle shadows for each item."

Instead of: "Connect to the payment system" Try: "Integrate Stripe for payments. Users should be able to purchase credits with a card, and we need to store transaction history in a 

payments
collection."

Tip

When the agent asks clarifying questions, it's helping you be more specific. Answering these questions leads to better results faster than assuming the agent will "figure it out."

The more concrete and detailed your descriptions, the closer the first implementation will be to your vision. Vague instructions require more back-and-forth to get right.

For guidance on communicating effectively with the agent, see Best Practices and What and How.

Was this page helpful?

Related pages