GitHub sync
Berrybell builds your app as real code, and that code is yours. Connect a GitHub repository to export it, review changes, and keep developing in your own tools.
Connecting a repository, and every push, pull and branch action, needs a paid plan on the workspace.
Why sync to GitHub
- Own your code. Your app isn't locked in — it's a normal codebase in your repository.
- Review changes. See exactly what changed as you build.
- Bring in developers. Your team can work on the same code with the tools they already use.
- Keep a backup. Your repository is an independent copy of your app.
Connecting a repository
It's two steps: install the app once for the workspace, then link a repository per project.
1. Install the Berrybell GitHub App. Go to Workspace settings → GitHub and install it on your personal account or on an organisation, choosing which repositories it may reach. Only a workspace owner or admin on a paid plan can install it: editors and viewers see the page without a connect button, and the installation is refused if the role changed while you were on GitHub. Installing into a GitHub organisation may also need that organisation's owner to approve it, which is GitHub's own step rather than a Berrybell one. Removing an installation later is admin-only too.
2. Link a repository to the project. Once the app is installed, any editor (or above) on the paid workspace can open the GitHub menu in the project and search the repositories the app can reach, then link one. To start a new repository, create an empty one on GitHub first, then link it. One repository per project.
You can unlink at any time: your project's local history is kept and only the remote link is dropped.
Pushing and pulling
Sync is manual and two-way, so nothing moves without you asking:
- Push commits your project and pushes it to GitHub.
- Pull merges GitHub's commits back and refreshes the files you see in the editor.
The toolbar shows the current branch and how far ahead or behind the remote you are.
What isn't pushed
A push commits every file in your project and sends the branch's full history
with it, so the project's .gitignore is what decides what reaches GitHub.
Current templates and new blank projects come with a .gitignore that Berrybell
sets up, which keeps out:
- Secrets files:
.env,.env.*,.dev.varsand anything ending in.local. - Installed packages, build output and caches, such as
node_modules/,dist/and.wrangler/. .attachments/, where the files you attach in chat are kept. A copy placed in your site, such as an image in the public folder, is part of your code and is pushed..reference/, the summaries Berrybell makes of sites you reference in a message..berrybell/, Berrybell's own bookkeeping, including the history notes the AI writes for each change. The one exception is.berrybell/schedules.json, which the AI may write when you ask for something on a timer. It's committed with the rest of your code. Its schedules run on the hosted service on a Pro or Business plan, and don't run on the free plan (see the FAQ).
The file's header calls it Berrybell-managed, but you can edit it: open
.gitignore in the Code tab, and
Berrybell keeps what you save.
Git ignores a .gitignore line for any file it already tracks, and Berrybell
commits your project every time the AI changes it, not only when you push. A
line you add later therefore doesn't stop a file that's already in a saved
version from being committed, and because a push sends every earlier commit,
that file reaches GitHub even on your first push. Deleting it from the
repository on GitHub stops later commits, but your next pull deletes the
project's copy as well, so keep a copy first. If the file held keys or
passwords, treat them as exposed and replace them: they stay in the repository's
history.
Berrybell never updates a .gitignore that already exists, and the list above
has grown since the file first appeared. An older project may have only
node_modules/, dist/ and .vite/, or an earlier Berrybell-managed version
without the .attachments/ and .reference/ lines, even though its header
looks the same. Compare yours with the list above before your first push, and
bear in mind that on an older project, files such as the history notes may
already be in earlier versions, and a push sends those versions whatever your
.gitignore says now.
Branches and pull requests
From the same menu you can list branches, switch between them, and create a new one. To open a pull request, set a base branch and a title.
It stops and asks rather than overwriting
This is the part worth trusting the feature on: Berrybell will not overwrite your repository.
- If GitHub has commits your project doesn't, a push writes nothing. In the Studio the button reports "Remote has newer commits — Pull first, then Push."
- A merge conflict aborts cleanly and names the files it happened in, so you can resolve and retry.
- There is deliberately no "force overwrite GitHub" option anywhere in the Studio.
Ask the AI to push instead and you get a fuller version of the same refusal: it comes back and asks you what you want to do, naming the upstream commits it found and who wrote them.
Ask the AI to do it
With a repository linked you can simply say "push this to GitHub" or "open a PR" in the chat, and the assistant runs the same operations.
Two things that trip people up
The preview has to be running. Git runs inside your project's preview environment, so the project must be open with its preview started before push, pull, branch or pull-request actions will work.
One git operation at a time. Git takes a per-project lock, so trying to push or pull during an AI run comes back with "The project is busy (an AI run or another git operation is in progress). Try again in a moment." Wait for the run to finish, then retry.
The connection looks after itself
Opening the GitHub menu re-checks the state against GitHub, so you don't have to maintain it:
- If the app's access was revoked, the menu says so and asks you to reconnect — do that from Workspace settings → GitHub.
- A repository you renamed on GitHub is followed automatically.
- A repository you deleted is reported as gone.
That re-check runs in the background and is throttled, so a change you have just made on GitHub may only show up the next time you open the menu.
Working with the code
Because it's a standard codebase, developers can:
- Run it locally and make changes in their own editor.
- Add tooling, tests, and CI as they would for any project.
- Continue building beyond what the Studio covers.
Next steps
- Take your app live: Publishing your app
- Add backend functionality: Databases