# Onboarding

> The whole course setup as a terse checklist: accounts, tools, your API key, and the course skills plugin, each linking to the full how-to

Everything you need working before the first class, as a checklist. There's no
crit in week 1, but the [first crit](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/crits/01-forgotten-web/) runs in week 2
with a marked deliverable due at its cutoff, so steps 1--6 need to be working by
then; step 7 can wait for the mid-semester break, and step 8 is optional. Where
a step has a fuller page it links there --- follow those if you hit a snag, and
come back here for the fast path.

The early steps you do by hand, because installers and web sign-ups can't be
automated. Once Claude Code is running and the course plugin is installed, the
course skills can finish and check the rest for you. If you get properly stuck,
post on [Ed](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/communication/); the teaching team is watching it from the
start of week 1.

:::info[Can't finish the checklist? Come to the setup drop-in]

If you can't get through this page on your own, come along on **Friday of week
1, 3--4pm** in Seminar Room 3.03 (Level 3, Birch Building). Bring your laptop
and we'll try to help you get everything working before the first crit.

:::

## 1. Create your GitHub account

[Sign up](https://github.com/signup) --- the free tier is fine. Every submission
goes through GitHub. Account details and policy:
[software and platforms](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/software-and-platforms/).

## 2. Install the tools

Start with two you install by hand, in this order:

- **A terminal emulator** --- macOS Terminal, iTerm2, Windows Terminal, or
  whatever ships with your Linux distro; if you don't currently have a
  favourite, [Ghostty](https://ghostty.org/) is a good choice. You'll be living
  in this for the whole course
- **[mise](https://mise.jdx.dev/)** --- the tool installer the course uses. It
  needs no `sudo`, and it pins versions per project, so different prototypes can
  use different runtimes without you having to think about it. Use the
  [shell-specific installer](https://mise.jdx.dev/installing-mise.html) ---
  `curl https://mise.run/zsh | sh` for zsh (the macOS default), `bash` or `fish`
  in place of `zsh` otherwise --- because that variant also wires mise into your
  shell[^curl-pipe-sh]. Restart your terminal afterwards

Then one command installs the rest:

```sh
mise use -g node@24 pnpm gh jq
```

- **[Node](https://nodejs.org/) and [pnpm](https://pnpm.io/)** --- whatever
  stack you pick for your own prototypes, every weekly starter repo runs its dev
  server and checks on these (Node 24, pnpm 11), so `pnpm install` has to work
  before your first crit
- **[`gh`, the GitHub CLI](https://cli.github.com/)** --- authenticating,
  cloning, and working with pull requests from the terminal. Install it this way
  even if your distro packages it[^distro-gh]
- **[`jq`](https://jqlang.github.io/jq/)** --- a JSON processor for the
  terminal, which the course skills use to work out your deadlines and to show
  your budget in the status line

That `-g` makes these your defaults everywhere, which is what you want for tools
that aren't tied to a project (`gh`, `jq`) and for a working Node when you're
just experimenting. **Inside a repo, its configuration takes precedence**: mise
reads the nearest `mise.toml` first, and every course template ships one pinning
the versions that week was tested against. Running `mise install` in a fresh
clone installs exactly those versions. Do the same in your own projects.

Already have a runtime manager you like? Keep it, as long as it supplies the
Node and pnpm versions each template names ---
[going off piste](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/software-and-platforms/#going-off-piste) covers where
that leaves you.

The last four have their own installers:

- **[Git](https://git-scm.com/)** --- most Linux distros ship it; on macOS
  `xcode-select --install` is the shortest path
- **[Claude Code](https://docs.claude.com/en/docs/claude-code/overview)** ---
  the coding agent you'll work in, installed with
  `curl -fsSL https://claude.ai/install.sh | bash`[^curl-pipe-sh]. It keeps
  itself up to date from then on, so there's no version to pin. The course
  provides your Claude access, so you don't need a personal Anthropic account or
  subscription
- **[ANU VPN (GlobalProtect)](https://services.anu.edu.au/information-technology/login-access/remote-access/download-globalprotect-for-windows-or-mac)** ---
  connect it whenever you're using your course key, on campus as well as off
  (the campus wifi doesn't reach the course gateway --- only wired campus
  Ethernet works without it). Install and test it in week 1; a dropped VPN is a
  common cause of "it suddenly stopped working"
- **[Chrome](https://www.google.com/chrome/)** (version 140 or newer) --- the
  course standardises on Chrome so everyone sees the same thing in lectures and
  demos, and a recent version keeps the modern web-platform features we rely on
  available

:::warning

**On Windows?** We recommend the latest
[WSL2](https://learn.microsoft.com/en-us/windows/wsl/install), whose Linux shell
matches the course examples. Git Bash is also supported. Pick one for your
course work and use it consistently: their installed tools are separate. Install
and run GlobalProtect in Windows as normal --- WSL shares that connection.

:::

## 3. Configure and connect

Log in to GitHub from the terminal --- this opens a browser:

```sh
gh auth login
```

Choose GitHub.com, then HTTPS, then "Login with a web browser". The token this
creates carries four permissions --- `repo`, `read:org`, `gist` and
`workflow` --- and there's nothing useful to trim: the first three are the `gh`
CLI's hard floor (`gh auth refresh --remove-scopes` refuses to drop them) and
the fourth is what lets you push changes to your repo's
`.github/workflows/checks.yml`. `gh auth status` shows what you're carrying at
any time.

The course org is what bounds that token. A token can never do more than you
can, and inside `comp4020-agentic-coding-studio` you can work on your own repo
and nothing else: members can't create repositories, fork private ones, delete
anything, or even see a repo they haven't been added to.

:::tip[Prefer a token scoped to just your repo?]

You can run the course on a fine-grained personal access token instead. It needs
Contents: write, Metadata: read, Administration: write (the visibility flip at
ship time), Pages: write, Actions: read and write, and Workflows: write --- that
last one because GitHub rejects any push touching a workflow file from a token
without it. Set it as `GH_TOKEN` in your shell rather than passing it to
`gh auth login --with-token`, which handles fine-grained tokens poorly.

Two things to expect: the convenor has to approve the token before it can reach
the course org, and `/doctor` will report that it can't read your org
membership, which is a limit of the token rather than a fault in your setup. The
browser flow above is the supported path --- take this one only if you want to.

:::

Get your API key from Canvas and wire it into Claude Code, following
[your LLM access](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/llm-access/) --- that page is the single source for
the key steps: where the key comes from, the exact settings to add, why the key
must [never touch a repo](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/llm-access/#keep-your-key-out-of-your-repos),
and troubleshooting. Then check it works (VPN connected --- campus wifi doesn't
count):

```sh
claude --print "say hi"
```

## 4. Install the course skills plugin

```sh
claude plugin marketplace add comp4020-agentic-coding-studio/core
claude plugin install comp4020@comp4020
```

The skills change through the semester and the plugin does not update itself, so
come back to
[keeping it current](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/llm-access/#step-5-install-the-course-skills-plugin)
every few weeks --- it is two commands and a restart.

## 5. Let the plugin finish the setup

Everything so far has been typed at your shell. Now start Claude Code itself,
which is where the skills live:

```sh
claude
```

Inside that session you can hand the rest to the agent. Ask in plain English, or
run the skills directly:

- **`/comp4020:doctor`** --- checks the whole environment (Git, `gh` login,
  Chrome, `jq`, the proxy, your course org membership) in one pass and offers to
  fix what's missing. Start here: it tells you what, if anything, is left to do
- **`/comp4020:onboard`** --- does the fixing: your key, the org invitation,
  your crit group. Every step re-runs on its own, so you can come back later for
  just one of them

Run `/comp4020:help` for the full menu.

Prefer to do it all by hand? Go right ahead --- the skills only automate the
same steps documented on this page and on
[your LLM access](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/llm-access/), and check nothing's been missed.

## 6. Meet your first repo

You never create course repos yourself: each deliverable's repo is generated for
you from the course starter template and placed in the course GitHub org, named
for the deliverable and your handle, private until you ship it public at your
cutoff. The [assessment page](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/assessment/) covers that lifecycle; two
things on your side make it work:

- **accept the course org invitation** when it arrives on your GitHub account,
  promptly --- invitations expire after seven days and a lapsed one has to be
  re-sent
- **run `/comp4020:start`** at the start of each week: it clones the week's
  repo, carries your `CLAUDE.md` forward, and pulls the week's spec so you can
  turn it into tests. Your first run is for [C1](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/crits/01-forgotten-web/), the
  week 2 crit whose prototype you build in week 1
- **clone the lecture examples** once, alongside your own repos:
  `gh repo clone comp4020-agentic-coding-studio/lecture-demos`. Pull it at the
  start of each class if you want to run the code on screen
- **keep them in one folder** --- pick a home for the course, `~/comp4020/` say,
  and clone every repo into it; by November there are a dozen. Your `CLAUDE.md`
  belongs _inside_ each repo, because the harness is part of what's marked. Your
  key never goes in a repo at all:
  [keep it out](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/llm-access/#keep-your-key-out-of-your-repos)

## 7. Later: Fly.io, for the full-stack half

None of this is needed for the static half of the course, so leave it until the
mid-semester break --- but have it working by the
[week 7 crit](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/crits/06-a2-retro/), where your tutor opens your app's URL at the
door. It's a five-minute job, and there's no account to create:

1. Install the CLI: `mise use -g flyctl`
2. When your first full-stack repo is created (at the start of week 7, ahead of
   the [week 8 crit](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/crits/07-anu-system/)), you'll get an Ed message with a
   token; paste its block inside the repo
3. From inside the repo, deploy the untouched starter:
   `flyctl deploy --remote-only --ha=false -a <your-repo-name>`, then open
   `https://<your-repo-name>.fly.dev/`. The Ed message includes that command
   with the name filled in --- all lowercase, whatever capitals your GitHub
   username has. A live starter is the check-in

**Don't sign up for a Fly.io account or add a payment method for the course**:
every app is in the course-managed organisation, and the course covers billing.

For the token, deployment while the repo is private and the app's resource
limits, see [your hosting access](https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/hosting-access/).

## 8. Optional: your budget in the status line

Your weekly API budget, live at the bottom of every Claude Code session, green
through amber to red as you approach the cap:

```
comp4020 $41.20/$100 (41%)
```

It's a second, separate plugin, so you only run it if you want it:

```sh
claude plugin install comp4020-statusline@comp4020
```

Installing it doesn't switch the status line on by itself. Run its bundled skill
by asking it to "install the status line"; it writes the settings without
changing an existing status line. Ask the same skill to diagnose a blank or
stuck status line. It needs [`jq`](https://jqlang.github.io/jq/) (step 2) and a
Unix shell, so macOS, Linux or WSL.

The number is cached and refreshed in the background, so it lags your real spend
by up to a minute. Ask Claude "how much budget do I have left?" whenever you
want the authoritative figure. Off the VPN it shows the last figure it managed
to fetch, and `budget: ?` means it hasn't reached the proxy yet.

[^curl-pipe-sh]:
    Piping a URL straight into your shell runs whatever that server sends, with
    your privileges, sight unseen. It's a reasonable thing to do for a publisher
    you've decided to trust and a bad habit everywhere else --- so don't let
    this page teach you the reflex. To check first,
    `curl -fsSL https://mise.run/zsh -o mise-install.sh`, read it, then
    `sh mise-install.sh` --- the same two-step works for any install script on
    this page. Or skip the script entirely: mise is in Homebrew
    (`brew install mise`) and most distro archives, in which case follow
    [mise's install docs](https://mise.jdx.dev/installing-mise.html) to add the
    shell activation line yourself.

[^distro-gh]:
    Ubuntu still ships `gh` 2.45, which is too old to flip a repo public
    non-interactively. Without a current version, you discover the problem when
    you ship at a crit cutoff, the worst possible moment to debug your package
    manager. mise's build is current, and `/comp4020:doctor` checks for exactly
    this.

Source: <https://comp.anu.edu.au/courses/comp4020-agentic-coding-studio/topics/onboard/>\
Licence: [CC-BY-NC-SA-4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/)\
Cite as: Swift, B. (2026). _COMP4020/COMP8020 Agentic Coding Studio_ [Course materials]. ANU School of Computing. https://doi.org/10.5281/zenodo.21395760