Learn Git branching with BaseHalf and AI

Open a local BaseHalf canvas as your Git study map (commits, branches, merge and rebase notes plus exercises as cards) while Claude Code or Codex explain and quiz from the files you connect.

We wanted a short path into Git branching that did not start in a chat paste or a random tutorial tab. The goal was narrow: create commits on a branch, switch branches cleanly, and merge (or understand rebase enough to avoid rewriting shared history blindly). Not “become a Git maintainer”.

BaseHalf already gives us the pieces. An ordinary folder opens as a canvas. Cards are files. Connections write plain-text upstream lists into those files. Claude Code and Codex sit in the Agent Area on the right and read what we point them at. We used that as a study map for Git branching, not as a new “learning mode”.

A project folder open as a BaseHalf canvas of connected notes, with Claude Code in the Agent Area.

A folder that is the syllabus

Create a folder, open it in BaseHalf, and keep the structure boring on purpose:

git-branching/
  00-goal.md
  concepts/
    commits-and-pointers.md
    create-and-switch.md
    merge-fast-forward.md
    rebase-vs-merge.md
  practice-repo/
    README.md
  exercises/
    01-branch-and-commit.md
    02-switch-cleanly.md
    03-merge-or-rebase.md
  sources.md

00-goal.md states the boundary in one paragraph: what “done” looks like after this path. sources.md holds links you will verify against, starting with Pro Git, especially Branches in a Nutshell, Basic Branching and Merging, and Rebasing. Keep the command pages handy too: git branch, git switch, git merge, and git rebase. Treat Pro Git / git-scm.com as the source of truth for this folder.

On the canvas, draw upstream lines so each exercise depends on the concept notes and sources.md. Git sees those lists. The next agent session sees them too.

Ask the agent from the connected files

Select a concept card or an exercise, glance at the status bar so “this” is right, and ask in the Agent Area. Keep prompts tied to files, not to a vague “teach me Git”:

“From the upstream notes on this exercise, explain what a branch pointer is versus HEAD. Give one wrong git branch / git switch sequence and one correct one against practice-repo/.”
“Quiz me on fast-forward vs a three-way merge using only merge-fast-forward.md and the Basic Branching and Merging chapter linked in sources.md. Wait for my answer before revealing yours.”
“I wrote my steps in exercises/03-merge-or-rebase.md. Check them against the rebase vs merge rules in the upstream concept note. Flag any advice that would rewrite commits already on a shared remote.”

Agents are better at reading the files you connected than at remembering what you typed three messages ago. If the relationship is in the file, the next session starts with it already there.

Practice with an acceptance check

Exercise	You should be able to	Acceptance check
Branch and commit	Create a topic branch, commit on it, leave `main`/`master` unchanged	`git log --oneline --decorate --graph --all` shows the new tip only on the topic branch
Switch cleanly	Move between branches with a clean working tree (or a clear stash plan)	`git status` is clean before switch; files match the branch tip after `git switch`
Merge or rebase	Merge a topic branch, or rebase only local unpublished commits	Merge produces the expected tip; rebase never rewrites commits others may already have

Run each exercise in a throwaway clone under practice-repo/ (or a sibling folder you init for drills). Paste the command output back into the exercise note. Ask the agent to compare your result to the acceptance line, not to invent flags mid-flight.

Where AI usually slips

Treat model output as a draft. Common misses we keep seeing:

Pushing a rebase of commits that already exist on a shared remote (Pro Git’s rule: do not rebase public history)
Confusing merge with rebase, or treating them as interchangeable without saying what history you want
Inventing flags (git branch --magic, non-existent switch options) instead of reading the docs linked in sources.md
Suggesting git checkout / git switch while the working tree is dirty, then hand-waving the conflict

When the agent disagrees with the Pro Git chapters above, the docs win. Update the concept note, not the other way around.

What this is not

This path is not a Visual Thinking essay, and BaseHalf is not building an automatic knowledge graph for you. You are arranging ordinary Markdown files on a canvas, connecting them so upstream lists survive git, and letting Claude Code or Codex explain and quiz from those files. Same desktop product: folder as canvas, connections in files, agents on the right.

A quick start lowers friction; it does not promise mastery in minutes. When 00-goal.md and the three exercises pass their acceptance checks without leaning on the agent for the final answer, you are done with this path. Open the next domain the same way: another folder, another map, the same agents reading what you connected.