Glossary

Every important term from the tutorial, in plain language. The module where a term is first explained is noted in parentheses.

Repository (repo)

A project tracked by Git: your files plus a hidden .git folder holding the entire history. (Mod 1, 3)

.git folder

The repository’s actual database — objects, refs, HEAD, index, config, hooks, logs. Delete it and the project becomes a plain folder. (Mod 4)

Commit

One saved snapshot of your project, with a unique hash, author, date, and message. The unit of history. (Mod 1, 3)

Snapshot

Git’s mental model for what a commit stores: a complete photo of the project at a moment, not a list of edits. (Mod 1)

Hash (SHA)

A 40-character fingerprint computed from content. Same content → same hash; it’s how Git addresses every object. (Mod 1, 4)

Branch

A movable pointer to a commit; physically a one-line file in .git/refs/heads/. Lets you work in isolation. (Mod 1, 5)

HEAD

“Where you are now” — a pointer (usually to a branch) for the commit your working directory reflects. (Mod 3, 4)

Parent

The commit that came before a given commit. Merge commits have two parents. (Mod 1)

Distributed (DVCS)

Every clone holds the full history, so you can work offline and each copy is a backup. (Mod 1)

Working directory

The real files you see and edit. (Mod 3)

Staging area / Index

The “loading dock” where you gather exactly what goes into the next commit; physically the .git/index file. (Mod 3, 4)

Repository (committed history)

The permanent snapshots stored in .git. (Mod 3)

Blob

Stores the raw contents of one file (no name, no path). (Mod 4)

Tree

A directory listing: names → blob/tree hashes plus permissions. Represents a folder. (Mod 4)

Commit object

Points to a root tree, parent commit(s), author info, and message. (Mod 4)

Tag object

An annotated tag pointing to a commit, with its own metadata. (Mod 4, 9)

Content-addressed

Objects are named by the hash of their content, so identical content is stored only once. (Mod 4)

Loose object

A single compressed object file in .git/objects/ab/cdef.... (Mod 4)

Packfile

Many objects bundled and compressed together by git gc into .git/objects/pack/. (Mod 4)

Garbage collection (git gc)

Periodic cleanup that packs loose objects and eventually removes unreferenced ones. (Mod 4, 8)

HEAD

Points to the current branch (or a commit, when “detached”). (Mod 4)

config

The repository’s local settings and remotes. (Mod 4)

index

The staging area, in binary form. (Mod 4)

refs/

Folder of pointer files: heads/ (branches), tags/, remotes/. (Mod 4)

logs/

Records every position HEAD has held; powers the reflog. (Mod 4, 8)

hooks/

Scripts Git runs automatically at events (pre-commit, pre-push, etc.). (Mod 4, 9)

ORIG_HEAD

A bookmark of where HEAD was before a big operation, for easy recovery. (Mod 4)

packed-refs

Many refs compressed into one file for efficiency. (Mod 4)

info/exclude

A personal, uncommitted ignore list. (Mod 4, 9)

Bare repository

A repo with only .git contents and no working files; what servers use. (Mod 4)

init

Create a new repository (.git folder). (Mod 3)

clone

Download a full copy of a remote repository once. (Mod 6)

add

Stage changes for the next commit. (Mod 3)

commit

Save staged changes as a snapshot. (Mod 3)

status / diff / log

See pending changes / line-level changes / history. (Mod 3)

branch / switch / checkout

List/create branches and move between them. (Mod 5)

merge

Combine another branch into the current one, sometimes via a merge commit. (Mod 5)

rebase

Replay your commits onto another branch for a linear history; never on shared commits. (Mod 5)

push / fetch / pull

Upload commits / download without merging / download and merge. (Mod 6)

reset

Move the branch pointer back: --soft (keep staged), --mixed (keep unstaged), --hard (discard). (Mod 8)

restore

Unstage a file or discard working-directory changes. (Mod 8)

revert

Add a new commit that undoes an earlier one; safe for shared history. (Mod 8)

reflog

Show the history of HEAD’s movements; the recovery safety net. (Mod 8)

stash

Temporarily shelve uncommitted changes. (Mod 9)

tag

Mark a commit with a permanent name (e.g. a release version). (Mod 9)

cherry-pick

Copy a single commit onto the current branch. (Mod 9)

bisect

Binary-search history to find the commit that introduced a bug. (Mod 9)

blame

Show who last changed each line and in which commit. (Mod 9)

clean

Delete untracked files (not recoverable — use -n first). (Mod 8)

Remote

Another full copy of a repo, usually on GitHub; the default is origin. (Mod 6)

origin

The conventional name for the default remote. (Mod 6)

upstream

Convention for the original repo when you’ve forked it. (Mod 7)

origin/main

Your locally cached view of the remote’s branch; updates only when you sync. (Mod 6)

Tracking branch

A local branch linked to a remote branch for easy push/pull. (Mod 6)

Fork

Your own full copy of someone else’s repo, for contributing without write access. (Mod 7)

Pull request (PR)

A GitHub proposal to review and merge a branch’s commits. (Mod 7)

Issue

A GitHub thread tracking a task, bug, or feature. (Mod 7)

Code review

Line-by-line feedback on a PR before merging. (Mod 7)

Squash / merge / rebase merge

GitHub’s three ways to merge a PR (combine into one commit / merge commit / linear replay). (Mod 7)

GitHub Actions

Automation (CI/CD) defined as YAML in .github/workflows/. (Mod 7)

Continuous Integration (CI)

Automatically testing every push/PR to catch breakage early. (Mod 7)

.gitignore

Lists files Git should not track; only affects untracked files. (Mod 3, 9)

Submodule

Another Git repo embedded at a pinned commit inside yours. (Mod 9)

Hook (Husky / pre-commit)

Scripts run at Git events; tools that share hooks across a team. (Mod 9)

SSH key / PAT

Credentials for authenticating to GitHub (key pair / personal access token). (Mod 2)

GitHub Copilot

An AI pair programmer (an LLM wired into your tools) that suggests, explains, and writes code. (Mod 10)

LLM (Large Language Model)

The AI model under the hood that generates text/code. (Mod 10)

Token

The unit of text the model processes; roughly ¾ of a word. Context size is measured in tokens. (Mod 13)

Code completions

Inline “ghost text” suggestions as you type. (Mod 10)

Chat

Conversational Q&A with Copilot about your code. (Mod 10)

Agent mode

Copilot autonomously plans and performs multi-step tasks (editing files, running commands). (Mod 10)

Copilot coding agent

A cloud agent you assign an issue; it works in the background and opens a PR. (Mod 10)

Custom instructions

Persistent files Copilot folds into requests so you don’t repeat rules. (Mod 11)

copilot-instructions.md

The repo-wide instruction file at .github/copilot-instructions.md, applied to everyone. (Mod 11)

*.instructions.md

Path-scoped instruction files using an applyTo glob to target specific files. (Mod 11)

applyTo

Frontmatter glob that limits a path-specific instruction to matching files. (Mod 11)

Prompt file (*.prompt.md)

A reusable, invokable command capturing a repeated task. (Mod 11)

AGENTS.md

A cross-tool standard file giving AI agents project guidance. (Mod 11)

Instruction layers / priority

Personal → path-scoped → repo-wide → AGENTS.md → org; all merge, higher wins on conflict. (Mod 11)

Skill

A folder of on-demand expertise centered on a SKILL.md file, loaded only when relevant. (Mod 12)

SKILL.md

A skill’s entry file: YAML frontmatter (name, description, optional fields) plus an instructions body. (Mod 12)

description (skill)

The frontmatter field Copilot matches against your request to decide whether to load the skill. (Mod 12)

Progressive disclosure

Staged loading of skills: L1 name+description (always) → L2 full body (on match) → L3 resources (on demand). (Mod 12)

Model-invoked / user-invoked

A skill chosen automatically by description match vs. called explicitly by name. (Mod 12)

allowed-tools

Frontmatter listing tools a skill may use without per-use confirmation. (Mod 12)

MCP server / tool

A connector giving Copilot capabilities to act on external systems; complements skills. (Mod 12)

Context window

Copilot’s finite short-term working memory (in tokens) for one session — prompt, code, instructions, skills, memories. (Mod 13)

Compaction

Automatic summarizing of older conversation (around 80% capacity) so long sessions can continue. (Mod 13)

Copilot Memory

A GitHub-hosted, repo-scoped long-term memory; Copilot saves, validates, refreshes, and expires facts (~28 days unused). (Mod 13)

Progressive disclosure vs. memory vs. instructions

On-demand expertise vs. auto-learned facts vs. always-on rules; all flow through the context window. (Mod 13)

Secret

Any credential that grants access (password, API key, token, private key, .env); never commit it. (Mod 15)

Secret rotation

Revoking a leaked credential and issuing a new one; always do this before scrubbing history, since a pushed secret may already be copied. (Mod 15)

git filter-repo

The recommended tool to rewrite history and purge a file (e.g. a leaked secret) from every commit; requires a force-push. (Mod 15)

Signed commit

A commit cryptographically signed (GPG/SSH) so GitHub can show a Verified badge proving authorship. (Mod 2, 15)

Two-factor authentication (2FA)

A second sign-in factor (authenticator app, passkey) beyond a password; the top account protection. (Mod 15)

Passkey

A phishing-resistant, passwordless sign-in credential. (Mod 15)

Branch protection / ruleset

Enforced rules on a branch: require PRs, approvals, passing checks, signed commits; block force-pushes and deletion. (Mod 15)

Bypass actor

A user granted a narrow exception to a ruleset. (Mod 15)

Secret scanning

GitHub feature that detects committed secrets and alerts you. (Mod 15)

Push protection

Blocks a push that contains a recognized secret before it enters history. (Mod 15)

Dependabot

GitHub feature that alerts on vulnerable dependencies and opens PRs to update them. (Mod 15)

Code scanning (CodeQL)

Static analysis that finds vulnerability patterns in your code and flags them on PRs. (Mod 15)

GitHub Advanced Security (GHAS)

The bundle of advanced security features (secret scanning, code scanning, etc.) for private/enterprise repos. (Mod 15)

Supply-chain security

Protecting against risks from third-party code and actions (e.g. pinning Actions to a commit SHA, least-privilege permissions). (Mod 15)

Insecure code generation

The risk that AI-suggested code contains vulnerabilities (injection, weak crypto, hard-coded secrets). (Mod 15)

Prompt injection

An attack where malicious instructions hidden in content the agent reads hijack its behavior; includes the “Rules File Backdoor” and RoguePilot-class attacks. (Mod 15)

Defense in depth

Layering controls (prevent → detect → block → review → recover) so no single failure is catastrophic. (Mod 15)

Back to the index.