Preview 0.30

Real repository practice

Arbiter Academy Preview 0.30

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.

Complete these five setup steps before F01

Complete these steps in order before Prepare in F01:

Create your practice fork.
Clone it to your computer.
Enter the cloned repository.
Verify and install the Academy tools.
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

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.

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

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.

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

Why

The immutable release tag binds the installer you run to the reviewed release source without piping a remote script into a shell. The installer then verifies the downloaded Academy bundle before it installs the local tool.

Reviewed resources for Verify and install the Academy tools

You · Native terminal · Windows

$releaseTag = "preview-0.30"
$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" }
& $installer

You · Native terminal · macOS

set -eu
release_tag='preview-0.30'
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"
sh "$workdir/install.sh"

You · Native terminal · Linux

set -eu
release_tag='preview-0.30'
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"
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 immutable tag and the installed tool path both 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.

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

Ask a course question in Academy Discussions

You · Native terminal · Windows

$academy = "$env:LOCALAPPDATA\ArbiterAcademy\preview-0.30\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.30/bin/arbiter-academy"
"$academy" --repository "$PWD" doctor

You · Native terminal · Linux

academy="${XDG_DATA_HOME:-$HOME/.local/share}/arbiter-academy/preview-0.30/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.

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.

Runnable lesson catalog

F01 — Fork, clone, and Doctor safety
Prove origin is your fork, upstream is the official Academy, and push routing cannot target upstream.
F02 — Orient to live governance state
Bind a compact orientation record to the exact current context bytes and project stage.
F03: Start a task with its work
Start the prepared docs task and co-locate its in-progress board transition with the bounded documentation correction.
F04 — Fix with evidence
Preserve a failing claimant-label regression in Git before a later minimal production repair.
P01 - Feature through a user-approved spec and derived plan
Deliver unresolved-ticket summary behavior through an approved spec, coverage-valid derived plan, sanctioned task transition, and test-before-code workflow.
P02: Review, commit, push, and record an offline-local receipt
Create a reviewed local work range, push it only to the prepared learner origin, and preserve an offline-local receipt in a separate commit.
P03 - Record an accepted ADR
Choose and record the Workshop Queue summary-format boundary in accepted ADR-0004 and its matching append-only decision-log entry.
P04 - Review a dependency without installing it
Review python-dateutil 2.9.0.post0 against frozen evidence, select the bounded standard-library alternative for finite legacy date formats, and preserve a no-install rejection record.
P05 - Remediate a checkpoint finding
Reproduce a genuine blocked-ticket summary defect and prove it with ordered test-only RED and code-only GREEN commits.
P06 - Recover context drift without losing unrelated work
Repair one source-contradicted context claim through re-scout while preserving the prepared unrelated note byte-for-byte.
P07 - Threat-model the path-handling boundary
Produce one committed, target-bound STRIDE report for archive-import containment without changing the reviewed code.
P08: Classify repository hygiene without destructive cleanup
Commit a complete live branch and worktree classification bound to prepared external identities without deleting or pruning anything.
U01: Govern an autonomous sprint without outsourcing approval
Complete a bounded documentation sprint, preserve its durable decision evidence, and distinguish a human approval gate from the repository facts that Check can verify.
U02: Observe an audit-log guard without changing the audit trail
Observe one H-05 refusal, preserve the protected audit log, and commit a limited local observation note without claiming that the refusal chronology is proven.
U03: Refactor, chore, and local release evidence
Complete a behavior-preserving refactor, a docs-only chore, and a local annotated release without claiming a remote publication.
U04: Initialize a greenfield and a brownfield project
Compare the sanctioned project routes, commit each child through CodeArbiter, and bind both committed repositories with a canonical report.
U05: Debug, spike, and conflict without inventing evidence
Preserve a real debug no-action close and a findings-only spike transfer, while stopping for a human conflict decision.
U06: Preview a bounded change without turning advice into authority
Produce a two-commit, read-only documentation preview packet and recognize when advanced CodeArbiter surfaces do not belong in a training exercise.
U07: Complete a bounded feature capstone
Use the real CodeArbiter feature lane to repair one known defect, preserve its local evidence, and open the resulting feature branch as a hosted pull request.

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.