Skip to main content

Studio & chat

The Studio is where you build your app. It has two halves:

  • Chat (left) — where you describe what you want and the AI responds.
  • Live preview (right) — your app, running and updating as changes are made.

You build by having a conversation. Each message is a request; the AI turns it into changes to your app.

The build loop​

  1. You describe a feature, page, or change in the chat.
  2. The AI plans the work — for larger requests it outlines the steps first.
  3. The AI builds it, writing real code for your app.
  4. The preview updates so you can see the result immediately.
  5. You refine with the next message.

Plans and approvals​

For anything beyond a small tweak, Berrybell first proposes a short plan — the set of steps it intends to take. This lets you see what's about to happen before any code changes.

Some steps are higher-impact than others (for example, changes that touch your data or an integration). Those can pause for your approval so nothing significant happens without your go-ahead. Click Approve to continue, or Deny (the red button, on the left) to refuse it. The AI skips that step or action and carries on with the rest where it can. Either way, you can steer the AI in a different direction with your next message.

Coding effort​

The composer has an effort dropdown with three settings:

EffortBest for
LowFast, lighter changes
Medium (the default)Balanced quality and speed
HighComplex work

Effort controls how much work the AI puts into a request — and so how much the request costs. A high-effort run thinks longer and takes more steps, so it spends more credits than a low-effort one. Reach for High when a request is genuinely hard, and leave it on Medium the rest of the time.

Why there's no model name here

Berrybell doesn't show which model sits behind each tier, on purpose. Pick the effort that matches the job rather than the machine.

The AI can ask you questions​

The conversation goes both ways.

  • Scoping questions before it builds. If your request is vague, Berrybell may come back with a short questionnaire first — one question per page, with progress dots you can click to jump between them and a counter showing how many are left. Leave any answer blank to let the AI use its judgment. When you send it, all your answers go in together and the build runs in a single pass.
  • Questions mid-run. Beyond approvals, the AI can pause partway through with a short question and suggested answers to click. Your reply goes straight back into the run that's already going — it doesn't start over. A mid-run question doesn't wait forever, so answer it while the run is going. If nobody answers, the AI stops waiting within about 10 minutes. It either carries on with a sensible default, or the step it was working on times out; a timed-out step is retried, and the run fails if it keeps timing out.

One run at a time​

A project can only have one AI run going at a time. The project's preview and its code history are shared by every chat and tool in that project, so only one thing may change it at once.

  • While your own run is streaming, the composer is disabled.
  • Send from a second browser tab, or from a second chat in the same project, and you get "Another chat in this project is still running. Please wait for it to finish before sending a new message." The message is not queued. It goes back into the composer (unless you've started typing something else), so send it again once the run ends.
  • The same lock covers server-side Git work, so a GitHub push or pull can make a chat send report busy, and a running chat can make a push report busy.

Where your changes go​

On a project with environments, every chat message goes to the environment selected in the top bar, and the composer says which — for example "Changes go to staging".

  • Production asks first. With production selected and not yet confirmed, sending asks Send this change to production? Choose Use staging (there's one such button per other environment, named after it) to switch and send the message there instead, or Send to production to go ahead; Cancel puts the message back in the composer. Once you've confirmed production, later messages go straight there until the selection changes.
  • A switch made while you typed wins. If a teammate switches the project while you're writing, the Studio usually notices first: the composer's environment changes, a notice names who switched, and your message goes to the new environment (production still asks first). If your tab hasn't caught up yet, the send is refused with "This project is now on staging. Check it and send again." Your message goes back into the composer, so nothing is lost.
  • You can't switch mid-run. The environment can't be changed while a run is streaming; wait for it to finish.
  • Production changes are approved one by one. When the AI uses its Berrybell Cloud or payments tools to change production, an approval card appears first, with its details starting "On production:" — even if its permission is Always allow (Never allow still blocks the call outright). Approving lets that one call through; the next change to production asks again. Code the AI runs inside the project, such as a seed script, isn't covered: while production is selected, it uses production's database directly.

A project with only production has no environment to choose, so none of this appears. See Production asks first for the other places production asks before a change.

Cancelling a run​

A Cancel plan link sits on the plan card while a run is going or waiting for your approval. It stops the run there.

Like a run that fails, a cancelled run isn't charged its credits; its usage is still recorded.

Two things inside a run are charged as they happen, and neither a failure nor a cancel refunds them: images the AI generated for the page, and the description of an image you attached.

What a run costs​

Whenever a plan card is on screen, a usage bar underneath it reports the run: the credits spent, tokens in and out, the number of steps, and the effort tier you chose. Before the first numbers land it simply reads "Metering this run…".

When the plan finishes — completed or failed — the card breaks the credits down further. A failed run shows its usage line with zero credits charged; generated images and attached-image descriptions are billed separately, as described above.

Two running totals sit outside any single run:

  • The composer shows the total AI credits used in this chat.
  • The History drawer shows a credit total next to each chat in the project.

See Plans & credits for what a credit is worth (one AI credit is $0.25) and how credits are bought.

Multiple conversations per project​

One project can hold many chats. Open the History drawer to:

  • Start a New chat in the same project.
  • Switch between existing chats.
  • Rename one — each is auto-titled from your first message.
  • Delete one you're finished with.

This is how you keep an experiment out of your main thread: start a second chat, try the risky idea there, and leave the first conversation's context clean.

tip

Chats share the project — including its one-run-at-a-time lock. Two chats in the same project still can't build at the same time.

Cards that appear in the chat​

The chat isn't only text. Berrybell drops interactive cards into it when a decision is yours to make:

  • A database decision card when your request needs somewhere to save data — see Databases.
  • Permission prompts when the AI wants to use a connection set to Ask each time. The card reads "Agent wants to use" followed by the service, shows the exact call, and offers Deny, Always allow and Allow once. One card shows at a time, with a line such as "2 more requests waiting after this one" when others are queued. For Berrybell Cloud, Stripe and MCP-server connections the AI stays paused on the call until you answer, for up to 30 minutes; other connections hold the request for 90 seconds, after which the AI may retry it. See Controlling what the AI can do.
  • Payments and security cards when a request touches those areas.
  • Suggestion chips above the composer, proposing sensible next prompts based on what your project currently has — a database, a Stripe connection, and so on.

Attachments​

You can attach images and documents to a message — a screenshot of a design you like, a PDF spec, a CSV of the data you want modelled — up to five files per message. An image is often the fastest way to say "make it look like this."

The AI receives the actual file, not just a description of it, so "replace the hero with this" works on the image itself. Images (JPEG, PNG, WebP, GIF) can be up to 5 MB each and documents up to 10 MB. You can also attach files on the new-project screen, together with your description of the app. See Images & attachments for the details.

Reference a site​

Paste a URL into your message and, before planning, Berrybell reads that page (the Logs tab shows Reading reference site…) and summarises it for the AI to mirror while it builds. The first two URLs in a message are summarised.

The summary is structure and styling only — the title, the navigation, the h1–h3 headings, the calls to action, the colour palette and the fonts. Body paragraphs are left out. When your request needs the page's actual wording (adapting your old site's copy, for example), the AI opens the page itself during the build and works from its text. Only reuse wording you have the right to use.

Links to localhost or private network addresses aren't summarised.

Writing good requests​

The quality of what you get back depends a lot on how you ask. A few habits that help:

  • Be specific. "Add a pricing section with three tiers: Free, Pro $19/mo, Team $49/mo" beats "add pricing."
  • Go one change at a time for anything tricky, so you can confirm each step.
  • Describe the goal, not just the styling — "a signup form that stores the email" tells the AI what the feature is for.
  • Reference what's on screen. "Make the header from the preview sticky."

The Prompting guide goes deeper with patterns and examples.

Undoing a change​

Every successful change is recorded as a version of your app, and the controls for moving between them sit in the preview toolbar: an undo button that steps back one change, and a Version history button listing earlier versions with a Restore action on each.

You can also just say it — "undo that", "go back to the header we had before" — or keep iterating forward from where you are. Either way, nothing you do in the Studio reaches the public until you publish.

Following what happened​

The Logs tab beside the preview has two views. Timeline shows each run: its steps in order, and what the AI did in each, including pages it read and images it generated. Raw is the underlying log stream, if you want the detail. A run that stalls is closed out automatically rather than left running. See The Logs tab.

What the AI can do​

Within the Studio, the AI can:

  • Create and edit pages, components, styles, and layout.
  • Add app logic and connect a database.
  • Wire up integrations like payments.
  • Fix errors — if something breaks in the preview, describe it and the AI will work on a fix.
  • Read a web page you give it — paste a link and the AI can fetch that page's text. It has no web search, so give it the link rather than asking it to look something up, and it reads text, not pictures. The Logs tab shows Reading followed by the site's name.
  • Generate real images for the page, each one billed — see The AI generates images while building, too.
  • Work from the files you attach.
  • Ask you a question, or for your approval, partway through a run — see The AI can ask you questions.

Light and dark mode​

The Studio has a light and a dark theme. Open the account menu at the bottom of the dashboard sidebar (it shows your name and email), and under Appearance choose Light, Dark or System. System is the default and follows your operating system's setting.

The choice is saved in this browser only, and it also applies to the sign-in screen. It changes the Studio, not your app.

Next steps​