Base44, GitHub and Claude: How to Work With All Three

You built an app in Base44, connected it to GitHub, and now you want to work on it with Claude too. Great. Except your app now lives in three places at once, and the entire game is keeping them in sync. Nothing here is scary: five minutes of reading and you are set.

Base44 ⇄ GitHub ⇄ your computer

GitHub in Five Minutes (Only What You Must Know)

GitHub is a cloud backup of your app's code that remembers every version that ever existed. Think Google Drive, but for code, with an undo button for any moment in history. These are the only six words you actually need:

• main - the real, live version of your app. What your users see. You never touch it directly.
• branch - a safe side copy for trying out changes. Worked? Keep it. Didn't? Throw it away, and main stays clean. Always safe to experiment.
• commit - a save point, with a short sentence explaining what you changed. Like "save", with a sticky note attached.
• Pull Request (PR) - a proposal: "here is what I changed on the branch, approve it into main". This is your checkpoint, and the only moment you are asked for a decision.
• merge - you approved the PR, so the changes enter main. From now on they are real.
• pull / push - pull means downloading the version from GitHub to your computer. Push means uploading from your computer to GitHub.

If you are comfortable with Google Docs, you already understand all of it: main is the official document, a branch is "make a copy" to play with, and a PR is "suggested edits" waiting for your yes.

The Three Copies (This Is the Whole Game)

Your app lives in three places at the same time. Working correctly just means keeping all three telling the same story.

• Base44 - where you build with AI.
• GitHub - the safe backup in the middle. Its main is everyone's meeting point.
• Your computer - Claude Desktop, where Claude touches the code.

How they actually stay in sync:

• Base44 ⇄ GitHub - automatic, in both directions.
• GitHub ⇄ your computer - manual. You are the one pulling and pushing.

This is the single most important point in the guide, so stop on it for a second. Base44 and GitHub sync themselves. Every change you make in Base44 goes up to GitHub automatically; you do nothing. Your computer never syncs itself. It has no idea you changed something in Base44 until you pull it manually. That one seam is the only thing you manage. Remember it and the confusion is gone.

There is also a quiet, bigger win hiding in this setup: your code and your data live in a backup that belongs to you, not only inside one vendor's platform. That kind of ownership is a large part of why custom systems beat off-the-shelf tools as a business grows.

A Clean Working Cycle With Claude

You never type a command. You write to Claude in plain language and it does all of the mechanics. Here is what a healthy work cycle looks like, from start to live:

1. Pull before you start. Since last time, you have probably touched things in Base44, and your computer does not know about it yet. Tell Claude: "switch to main and pull the latest version from GitHub". Now you are starting from the right place.
2. Open the task with the branch checkbox ticked. Claude works on a side copy, and your main is never at risk while the work happens.
3. Let it work, then review the PR. The PR shows you exactly what changed, before and after. Happy? Approve the merge into main.
4. Push back to GitHub. Tell Claude: "push the changes to GitHub". GitHub is now current, and Base44 picks it up on its own.
5. Press Publish in Base44. This is what takes the new version live for your users. Until you press Publish, the change exists but is not yet live for clients.

The Golden Rule, and the Mistake Everyone Makes

The golden rule: pull before you start, push when you finish. One direction at a time.

The most common mistake: editing in Base44 and on your computer at the same time without syncing. The two sides drift apart, and when you try to push you hit a conflict that has to be untangled by hand. The fix is simple discipline: either finish on the computer and push, or work in Base44 and pull before returning to the computer. Never both in parallel.

Main is sacred: never work on it directly, always on a branch. If something goes wrong, you throw the branch away and main never even knew anything happened.

Quick Checklist

Before you start working on the computer

• Switch to main and pull from GitHub

When opening a task

• Tick the branch checkbox

When you finish

• Review the PR and merge
• Push to GitHub
• Press Publish in Base44 so it goes live

Who this is for: this guide assumes a Base44 app connected to GitHub (Builder plan and up). If your app is not connected to GitHub, you do not have this confusion at all: everything lives in Base44, and you just build and press Publish.

One last thing: shipping the app is only half the story. Once it is live, getting it found by Google and cited by AI engines is a separate game with its own rules, and that is exactly what the SEO and GEO playbook covers.

If a question comes up mid-work, ask Claude "which branch am I on?" or "show me what is about to change" at any moment, and it will show you before anything touches main.