Build one course environment, not a collection of every developer tool you may use in college. Start with current course instructions, verify the Apple developer base, configure Git identity deliberately, add SSH only when the remote service or course requires it, and isolate project dependencies through the course’s documented method.
Keep passwords, private SSH keys, access tokens, recovery codes, and private repository addresses out of setup notes and screenshots.
If Apple’s developer base has not been inspected, first install or verify Xcode Command Line Tools. Do not let an automatic developer-tools prompt become an unexplained side effect of the Git setup.
Turn course evidence into three lists
Collect the current syllabus, setup guide, starter-project README, assignment instructions, and institutional support page. Create:
| List | Meaning |
|---|---|
| Required now | Needed for the first graded or practice workflow |
| Provided by the project | Dependencies and scripts declared by the starter project |
| Not now | Interesting, newer, global, or unsupported tools |
For each item in Required now, record:
Requirement:
Course source and date checked:
Required version or allowed range:
Installation owner:
Project location or scope:
Verification command or workflow:
Do not replace an unspecified version with “latest.” Ask the instructor when a version or supported installation method affects grading.
Verify the Mac base
The previous article established Apple’s developer tools. Confirm the current state in a new Terminal window:
xcode-select --print-path
git --version
ssh -V
Record the output. The ssh -V version message may be written to standard
error; that does not by itself indicate failure.
Do not install another Git or SSH implementation merely because Homebrew offers one. Add or replace a base tool only when the course documents a need and you can explain which executable should win command resolution.
Configure Git identity as published metadata
Git author name and email become part of commits. They are not login credentials, but they can become public when a repository is published.
Inspect current values and their sources:
git config --show-origin --get user.name
git config --show-origin --get user.email
The official Git first-time setup guide explains global configuration, repository overrides, and origin inspection. Narrow queries avoid printing unrelated configuration that may contain private repository or credential-helper details.
Choose scope deliberately:
- use a global identity only when it is appropriate for most repositories on this Mac;
- use repository-local values when a course, employer, or public project needs a different identity; and
- use the hosting service’s documented privacy address when you do not want a personal address exposed.
For GitHub, review its current commit email
guidance
before choosing a verified or noreply address.
After setting the course-approved values, inspect them from inside the practice repository:
git config --show-origin --get user.name
git config --show-origin --get user.email
Do not place a password or token in user.name, user.email, or a remote URL.
Choose HTTPS or SSH for the remote
Git and SSH are separate layers. Git records and transfers repository history. SSH can authenticate a Git connection to a remote service. HTTPS is also a valid remote method and may be required by institutional policy.
Record:
Remote service:
Course-approved protocol: HTTPS | SSH | either | unknown
Authentication owner:
Organization SSO or authorization required:
Official setup source:
If HTTPS satisfies the course, you do not need an SSH key merely to appear more technical.
Set up SSH only when required
For GitHub, follow its current macOS sequence:
- Check for existing SSH keys.
- Decide whether an existing key is appropriate for this account and organization.
- If needed, generate a new key and add it to the macOS agent.
- Add only the public key to the remote account.
- Verify the remote host fingerprint through the provider’s official documentation before accepting it.
- Test the connection.
An SSH key pair has two different responsibilities:
- the public key may be uploaded to the service; and
- the private key remains private on the Mac and should be protected with the approved passphrase and credential workflow.
Never print, paste into chat, commit, email, or upload the private key. Filenames and provider instructions are safer to record than key contents.
GitHub documents this test:
ssh -T git@github.com
Its SSH test guide notes that a successful authentication message can still use exit status 1 because GitHub does not provide shell access. Interpret the message and status according to the provider’s documentation.
Use the institution’s hostname and official instructions for a campus or
enterprise Git service. Do not substitute github.com when the course uses
another host.
Install one course language environment
Return to the Required now list. Identify:
- language implementation and version;
- installation source;
- project dependency manager;
- manifest and lock or requirements files;
- isolation mechanism;
- run command; and
- test command.
Follow the language’s and course’s official instructions. Do not mix a Homebrew runtime, vendor installer, version manager, and system-provided executable without documenting which one should resolve.
Python illustrates why isolation matters. Its virtual-environment documentation explains that projects can require conflicting package versions and that a virtual environment is created from a particular Python installation. If the course uses Python, create the environment with the course’s exact command and record the base interpreter:
python3 --version
python3 -m venv .venv
Do not assume these commands or the .venv name apply to Node.js, Java, Rust,
or another ecosystem. Use the project files and official course procedure for
that ecosystem.
Verify the complete course path
From a new normal-user Terminal window:
- Open or clone the starter project into an approved practice directory.
- Confirm the project root and remote protocol.
- Inspect Git identity and configuration origins.
- Activate or select the documented project environment.
- Report language, package manager, and tool versions.
- Install only dependencies declared by the project instructions.
- Run the smallest provided program.
- Run the provided test or build command.
- Record expected and observed results.
A successful --version command is necessary but does not prove that the
starter project works.
Complete the course environment record
# Course environment
- Course and setup source:
- macOS and active developer directory:
- Git version and identity scope:
- Remote protocol and host:
- SSH used: yes | no
- Language and required version:
- Installation source:
- Project dependency and isolation method:
- Manifest or lock files:
- Run and test commands:
- Observed result:
- Not installed and why:
For the minimum first pass, complete Course and setup source, one required tool and version, Git identity scope, remote protocol and host, and the observed starter-project result. Complete the remaining fields after the relevant tool or environment is actually used.
Common mistakes
- Installing every tool mentioned in an old tutorial.
- Publishing a personal email address unintentionally in commits.
- Generating a new SSH key without checking existing keys or policy.
- Copying a private key into notes or support messages.
- Accepting an unverified remote host fingerprint.
- Installing dependencies globally when the project defines isolation.
- Verifying only versions instead of the starter project.
Do this now
Complete the three lists and one course environment record. Configure only the identity, remote authentication, runtime, and project dependencies needed for one safe starter workflow. Put every unsupported extra on Not now.
Log what you learned
The course environment record is the learning log. Save the required tools, approved repository protocol, version and path evidence, verification result, and next action there without recording private keys.
Next, turn the verified environment into a small reproducible macOS setup artifact.