Preview 0.33

Real repository practice

Arbiter Academy Preview 0.33

Start codeArbiter practice in a real Git repository. Each lesson appears here only after its guided rewrite and acceptance evidence are complete.

Start here

Arbiter Academy is a practice course for codeArbiter. You work in a real Git repository that belongs to you, so every lesson can produce real commits and evidence without sending changes to the official Academy repository.

Before F01, you need a GitHub account, Git, Python 3.11 or newer, a supported codeArbiter host, and an internet connection. Choose and install your codeArbiter host first, then return here to create your practice fork. Choose Claude Code, Codex, or Pi (Feature Forge preview). Pi requires project trust; if direct /ca-* dispatch is unavailable, use the documented /skill:ca-* fallback. Use a Browser to create the GitHub copy. Use a Native terminal for Git and installation. The website remains the course. A narrow operations TUI for setup, Check, reset, and lesson changes will be published only after it clears its own acceptance evidence.

How to use the course

Read what a lesson is trying to teach before copying its actions. Use the card's named surface: Browser for a website, Native terminal for shell commands, and Harness for a request to your coding agent. Select your host and operating system. A native terminal command has no leading exclamation mark.

Ask yourself three questions after each lesson: What changed? What evidence supports the result? How would I use this on my own project? Academy Check validates a narrow exercise contract. It cannot decide whether you understood the lesson.

The exercises use exact paths, report formats, and sometimes exact commit counts so Check can compare attempts. Those are training constraints. Your own projects need clear outcomes and useful checks, not Academy-shaped receipts.

Complete these five setup steps before F01

Complete these steps in order before Prepare in F01:

  1. Create your practice fork.
  2. Clone it to your computer.
  3. Enter the cloned repository.
  4. Verify and install the Academy tools.
  5. Run readiness checks.

What the Academy changes

A repository is a project's files plus its Git history. The official repository belongs to arbiterForge and stays read-only for learners. A fork is your account's copy of that repository on GitHub. A clone is the working copy stored on your computer.

Git gives remote repositories short names. In this course, origin points to your fork. upstream points to arbiterForge/arbiter-academy. You push only to origin. You use upstream to compare your fork with the reviewed Academy source.

Create your practice fork

Create the GitHub copy you own

You · Browser · All operating systems

Open the Academy fork page, choose your GitHub account as the owner, keep the repository name arbiter-academy, and create the fork.

Why

Your fork gives every lesson a push destination that you control.

Reviewed resources for Create the GitHub copy you own

Expected result

GitHub opens a repository named arbiter-academy under your account and identifies it as a fork of arbiterForge/arbiter-academy.

If that does not happen

If GitHub shows the official repository or another owner, return to the fork page and choose your own account before continuing.

Evidence

The browser address contains your account name followed by arbiter-academy.

Clone it to your computer

Choose a folder where you keep projects, open a Native terminal there, and use the command for your operating system. Replace your-account with the GitHub account that owns your fork.

Clone your fork

Run the variant for your operating system in a Native terminal after replacing <your-account> with the owner of your fork.

Why

Cloning your fork makes origin point to a repository you own.

You · Native terminal · Windows

git clone https://github.com/<your-account>/arbiter-academy.git

You · Native terminal · macOS

git clone https://github.com/<your-account>/arbiter-academy.git

You · Native terminal · Linux

git clone https://github.com/<your-account>/arbiter-academy.git

Expected result

Git creates an arbiter-academy folder and reports that the clone completed.

If that does not happen

If GitHub asks for access or Git says the repository was not found, confirm the account name and that the fork exists before retrying.

Evidence

The new clone records your fork as origin.

The clone command creates a new arbiter-academy folder but leaves the Native terminal in its current folder. Enter the clone before running any Academy command.

Enter the cloned repository

Enter the cloned repository

Run the variant for your operating system in the same Native terminal that created the clone.

Why

Every later command must target the practice repository rather than its parent folder.

You · Native terminal · Windows

Set-Location -LiteralPath .\arbiter-academy

You · Native terminal · macOS

cd -- ./arbiter-academy

You · Native terminal · Linux

cd -- ./arbiter-academy

Expected result

The Native terminal prompt is inside the cloned arbiter-academy repository.

If that does not happen

If the folder is not found, list the current folder and confirm where Git created arbiter-academy before trying again.

Evidence

The terminal's current directory ends with arbiter-academy.

Verify and install the Academy tools

Change the Native terminal's current directory to the clone before installing. The verified installer stores the reviewed Academy tools outside the learner repository. The clone remains lesson input rather than part of the verifier.

Verify and install the Academy tools

In a Native terminal whose current directory is the clone, run the command for your operating system. It fetches the canonical release tag with Git, extracts the installer locally, verifies its reviewed SHA-256 digest, then executes that local file.

Why

The pinned installer digest keeps a moved or replaced release tag from changing the code you execute, without piping a remote script into a shell. The verified installer then checks the downloaded Academy bundle before it installs the local tool.

You · Native terminal · Windows

$releaseTag = "preview-0.33"
$expectedInstallerSha256 = "5a5ced80ee775480ad4e38f5ad6666b38ae73a39e0089b316c18e668833b8708"
$source = Join-Path ([IO.Path]::GetTempPath()) ("arbiter-academy-" + [guid]::NewGuid())
$installer = Join-Path $source "install.ps1"
New-Item -ItemType Directory -Path $source | Out-Null
git -C $source init --quiet
git -C $source remote add origin https://github.com/arbiterForge/arbiter-academy.git
git -C $source fetch --depth 1 origin "refs/tags/$releaseTag"
$git = (Get-Command git -ErrorAction Stop).Source
$command = "`"$git`" -C `"$source`" show `"FETCH_HEAD:install/install.ps1`" > `"$installer`""
& $env:ComSpec /d /s /c $command
if ($LASTEXITCODE -ne 0) { throw "could not extract the tagged installer" }
$actualInstallerSha256 = (Get-FileHash -LiteralPath $installer -Algorithm SHA256).Hash.ToLowerInvariant()
if ($actualInstallerSha256 -cne $expectedInstallerSha256) { throw "installer digest did not match Preview 0.33" }
& $installer

You · Native terminal · macOS

set -eu
release_tag='preview-0.33'
expected_installer_sha256='71926136841b5a3b1af065600516f88798a0e25f46dc3a33ff495f7d902fa77d'
workdir=$(mktemp -d)
git -C "$workdir" init --quiet
git -C "$workdir" remote add origin https://github.com/arbiterForge/arbiter-academy.git
git -C "$workdir" fetch --depth 1 origin "refs/tags/$release_tag"
git -C "$workdir" show FETCH_HEAD:install/install.sh > "$workdir/install.sh"
actual_installer_sha256=$(python3 -c 'import hashlib, pathlib, sys; print(hashlib.sha256(pathlib.Path(sys.argv[1]).read_bytes()).hexdigest())' "$workdir/install.sh")
[ "$actual_installer_sha256" = "$expected_installer_sha256" ] || { printf '%s\n' 'installer digest did not match Preview 0.33' >&2; exit 1; }
sh "$workdir/install.sh"

You · Native terminal · Linux

set -eu
release_tag='preview-0.33'
expected_installer_sha256='71926136841b5a3b1af065600516f88798a0e25f46dc3a33ff495f7d902fa77d'
workdir=$(mktemp -d)
git -C "$workdir" init --quiet
git -C "$workdir" remote add origin https://github.com/arbiterForge/arbiter-academy.git
git -C "$workdir" fetch --depth 1 origin "refs/tags/$release_tag"
git -C "$workdir" show FETCH_HEAD:install/install.sh > "$workdir/install.sh"
actual_installer_sha256=$(python3 -c 'import hashlib, pathlib, sys; print(hashlib.sha256(pathlib.Path(sys.argv[1]).read_bytes()).hexdigest())' "$workdir/install.sh")
[ "$actual_installer_sha256" = "$expected_installer_sha256" ] || { printf '%s\n' 'installer digest did not match Preview 0.33' >&2; exit 1; }
sh "$workdir/install.sh"

Expected result

The installer reports the installed Academy preview and the path of the installed arbiter-academy executable.

If that does not happen

If the tag fetch, extraction, or installation stops, do not substitute a branch or a different remote URL. Preserve the complete message and the temporary source folder, compare the linked immutable source, and ask in Academy Discussions before retrying.

Evidence

The reviewed installer digest, release tag, and installed tool path all identify the same versioned Academy release outside the learner repository.

Run readiness checks

Run the installed Academy Doctor command once to inspect this checkout. It reports the Python and Git versions, repository root, clean or detached Git state, remotes, effective push remote, upstream push protection, and whether codeArbiter is activated and initialized. It cannot verify GitHub fork lineage offline.

Record the first readiness baseline

Run the installed Academy Doctor command from the clone, read every reported boundary, and continue to F01 when any failures are limited to the expected fresh-clone remote findings.

Why

Doctor records a baseline; F01 owns the first lesson's remote repair and readiness proof.

Reviewed resources for Record the first readiness baseline

You · Native terminal · Windows

$academy = "$env:LOCALAPPDATA\ArbiterAcademy\preview-0.33\Scripts\arbiter-academy.exe"
& $academy --repository (Get-Location).Path doctor

You · Native terminal · macOS

academy="${XDG_DATA_HOME:-$HOME/.local/share}/arbiter-academy/preview-0.33/bin/arbiter-academy"
"$academy" --repository "$PWD" doctor

You · Native terminal · Linux

academy="${XDG_DATA_HOME:-$HOME/.local/share}/arbiter-academy/preview-0.33/bin/arbiter-academy"
"$academy" --repository "$PWD" doctor

Expected result

Doctor reports Python and Git versions, the repository root, worktree and branch state, remotes and effective push routing, upstream push protection, and codeArbiter activation and initialization without changing the repository.

If that does not happen

If Doctor reports only missing upstream or related fresh-clone remote evidence, continue to F01. If origin is not your fork, main is dirty, or another prerequisite is unavailable, stop and correct only that setup boundary before Prepare.

Evidence

The Doctor report is a baseline. A later passing report is readiness evidence, not lesson completion evidence.

Choose your first lesson

Doctor does not need to pass before F01 when its only failures are the expected fresh-clone remote findings. A new fork clone may report a missing upstream; F01 teaches the remote repair. Before Prepare, you do need clean main, an origin whose fetch and push target your non-official arbiter-academy repository, and effective push routing to origin.

Start with F01, Fork, clone, and Doctor. Read the complete F01 page in the Browser and follow its ordered actions. Do not repair the remaining F01 evidence steps from this page. Keep the website open as the lesson surface and run its copyable installed Academy commands in the Native terminal.

Course status

Current release inventory. The runnable lesson catalog below is generated from the exact public release manifest. Every listed lesson has an explicit actor, surface, expected result, recovery path, and evidence boundary.

Course boundary. U01-U07 are published in this release. Graduation is available after all 19 Academy Checks pass in the same repository.

To graduate, ask your agent: "Run the installed Academy graduation check for this repository. Supply --plugin-root from your loaded external Arbiter installation, as in P01 and U01, and show the result." Graduation rechecks the course evidence; it needs the same reviewed native reader used for those HTML plans.

Get help

Stop when the observed result differs from the lesson. Recovery guidance helps you preserve the attempt and choose a safe next action. Questions and course feedback belong in Academy GitHub Discussions.

Build your first project with codeArbiter

Pick one small tool you would actually use: a reading list, local inventory, or personal activity log. Keep the first version small enough to demonstrate.

  1. Create a separate Git repository and open that folder in your coding host. Keep Academy attempts in their existing clone.
  2. For a new project, ask: "Initialize this new project with codeArbiter's greenfield workflow. Help me define the user, first useful outcome, exclusions, and checks." For existing code, request the brownfield workflow so context comes from source.
  3. Give a concrete feature request: "Add a reading-list filter by status. A user can select unread or completed books; an empty result has a clear message. Keep storage local and do not add accounts or external services."
  4. Read the criteria and proposed behavior. Answer genuinely missing product choices. Ask for a pause before implementation if you want one. Otherwise the original request permits ordinary work and in-scope plan maintenance.
  5. Inspect the diff and actual check results. Ask for the governed commit when ready, then a PR to your own repository. Inspect its base and head, hosted checks, and review findings before separately deciding to merge or release.

Use feature for a new capability, fix for a known bug, debug for an unknown cause, refactor when behavior must stay the same, and chore for documentation or other non-behavioral work. Plain-language requests route to those owners; memorizing every command is not a prerequisite.

New full feature and sprint artifacts use the installed native writer. Review their rendered pages and ask Arbiter to maintain them. A failed artifact operation needs diagnosis; it is not a reason to invent another pair or an approval receipt.

You are ready to continue when you can explain the outcome, review the proposed scope, distinguish an actual test result from a claim, and decide what happens next. Passing all Academy Checks is a course milestone, not a substitute for those skills.

Runnable lesson catalog

Integration compatibility

Evidence level: release-and-command-contract. This is not end-to-end host certification.

ComponentVersionRelease tag
codeArbiter3.8.3v3.8.3
Codex0.26.3ca-codex-v0.26.3
Pi0.27.3ca-pi-v0.27.3

Course links

Open Recovery guidance when the observed result differs from the lesson.

Use the codeArbiter reference documentation for governance concepts.

Questions and Preview feedback belong in Academy GitHub Discussions.

Graduation is available after all 19 Academy Checks pass in the same repository. The receipt requires the complete 19-lab course through U07 and is not issued for a partial course.