The CodeGym installer: what it does to your computer

The CodeGym installer asks for administrator rights and puts about a dozen programs on your computer. Feeling wary at that point is normal, and it's the right instinct. Anyone who cares about their machine is entitled to ask: what exactly is this program going to do to it?

This article answers that question in full, without glossing over anything. What gets installed, where it goes, what we leave alone, what data is collected and how to undo all of it.

If you don't want to use the installer, don't. You can take the course without it: the lectures walk you through installing everything you need by hand, step by step. The installer just saves you the routine work.

1. Why you need it

The course needs quite a few tools: Claude Code itself, an IDE, languages, build tools. Each one installs its own way, each has its own settings, and some of them also have to be connected to each other and signed in.

You can do all of that by hand, but it's several hours of work where it's easy to make a mistake and then spend ages figuring out why something won't start. The installer does the same job in a single run. Boring, but predictable.

2. What gets installed

Here's the full list of what will end up on your computer.

Claude Code and voice input

Claude Code CLI - the main tool of the course, the AI agent itself. It's installed with Anthropic's official installer from claude.ai, always the latest version.

Handy - a speech recognition utility. It lets you dictate tasks to the agent instead of typing them. The Parakeet V3 recognition model (about 456 MB) is downloaded with it, and the model runs locally on your computer, no internet needed.

Two Claude Code plugins - superpowers and frontend-design from the official Anthropic marketplace.

Development environments

IntelliJ IDEA - the main IDE of the course. It comes with three plugins: Python support, the CodeGym plugin (for submitting tasks for review) and the Claude Code plugin (an agent panel right inside the IDE).

Visual Studio Code - a second IDE, installed alongside in case you prefer it. It gets two plugins from the same set: CodeGym (beta) and the official Claude Code extension.

Languages and utilities

Node.js 24 - runs the course projects and the result checks.
Python 3.14 - for scripts and some of the tasks.
Java 25 (Eclipse Temurin) - the foundation of the CodeGym platform.
Gradle 9.5.1 - builds Java projects.
Git - keeps your project history; you'll need it later in the course. On Windows, Git Bash comes with it.

Settings and sign-in

A settings file for access to the course AI server, the configuration for the CodeGym plugins and a course profile for Claude Code: the agent's working rules, helper techniques and starter templates for games and web projects. Everything is already filled in for you, so there are no keys to enter and no sign-in to go through.

Differences between systems

On macOS, if you don't have Homebrew (a package manager), the installer sets that up too, since Git, Python and VS Code are installed through it.

On Linux, the Node.js, Python and Microsoft (for VS Code) repositories are added. On Debian, Python 3.14 doesn't get installed: the installer tells you so plainly in the report, and you'll need to install it yourself.

3. Where everything goes

The installer doesn't scatter files all over your system. Everything lives in predictable places, so if you want to check later what went where, you won't have to dig for it.

Programs

System	Location
Windows	`Program Files`, `C:\Gradle`
macOS	`/Applications`, `/opt`
Linux	`/opt`

Three directories in your home folder

.claude-codegym - the course profile for Claude Code: settings, the agent's working rules, helper techniques.

.codegym - sign-in settings for the CodeGym plugins and two launch commands (more on them below).

.codegym-backups - backups of the files the installer changed, plus a change log. It keeps the last 10 runs or 30 days.

Separately: Claude Code itself goes into ~/.local/bin, and the speech recognition model goes into Handy's data folder.

What changes in system settings

The PATH variable - so the course commands run from the terminal. On Windows the change goes into the registry, on macOS into the .zprofile file, and on Linux into /etc/profile.d/codegym.sh and .profile.

On macOS and Linux our lines are wrapped in # CODEGYM START and # CODEGYM END markers. You can spot them at a glance, and undoing the install removes exactly those lines without touching your own settings.

The Windows registry - three entries, no more: the path to Gradle, the path to the course commands and acceptance of the IntelliJ IDEA license agreement.

4. Two commands: claude and claude-native

This is an important detail, and it's worth knowing about in advance.

The course has its own Claude Code settings: the connection to the course server, the agent's working rules, the course characters. They shouldn't get mixed up with your personal settings, so we keep the two separate.

claude - starts Claude Code with the course profile. This is what you use for the course.

claude-native - starts your personal Claude Code, as if we weren't there at all. Your own settings, your own account.

Here's how it works: both commands are small scripts in the .codegym/bin folder that launch the same real Claude Code but point it at different settings folders. I keep both handy myself: the course one for course work, my own for everything else.

The installer doesn't read, change or delete your personal Claude Code profile. If you had one, it stays exactly as it was.

One practical note: the commands only show up in a new terminal window. If you type claude right after installing, in a window that was already open, that window doesn't know about the commands yet. Just open a new one.

5. What we don't do

This is probably the most important section. The installer is built on a "do no harm" principle, and here's what that means in practice.

We don't remove or overwrite anything you already have. If your computer already has a different version of Java, Python, Node or Git, it stays put. The course version is installed next to it.

We don't touch version managers. If you use nvm, pyenv, sdkman or asdf, the installer leaves them alone and mentions in the report that it installed a version alongside. Breaking your pyenv setup is the last thing we want.

We don't reinstall what's already at the right version. Running it again won't break what's installed: the installer checks each tool and skips the ones that are already in place.

We don't touch an IntelliJ IDEA we didn't install. If you have IDEA from JetBrains Toolbox, we leave it alone, install a separate copy for the course and tell you about it.

We don't override your consent settings. If you've already accepted the IDEA license or set your usage statistics preference, those settings stay yours.

We don't mess with startup, services or system policies. The installer doesn't add itself to startup, doesn't create services or scheduled tasks, doesn't install certificates, and doesn't touch the firewall, hosts file or DNS.

We don't expand the AI agent's permissions. The course profile doesn't lift any of Claude Code's restrictions: the agent runs with the usual security settings and asks for permission just like it always does.

6. What data is collected

Your personal key

When you download the installer, a personal access key tied to your account is written into the archive. The CodeGym and Claude Code plugins use it to sign in to your account automatically, which is why you don't have to enter any keys by hand. It never ends up in the log: the same filter that masks passwords masks the key too. It's also the reason you shouldn't pass the archive on to anyone else.

Install log

During installation the installer keeps a detailed log: which steps ran, what was already on the computer, what worked and what didn't. This log stays on your disk. It doesn't go anywhere.

If something goes wrong, you send it yourself, if and when you decide to. On Windows it's in the temp folder (%TEMP%\codegym-install.log); on macOS and Linux it's next to the installer itself, in a file called install.log.

Passwords and keys don't make it into the log: before each line is written, it goes through a filter that replaces tokens and passwords with a [SECRET] placeholder. The contents of your config files aren't written there either, only the parameter names.

If automatic error reporting is ever added, we'll announce it in advance and give you a way to turn it off.

Course session log

This is a separate thing, and it deserves a straight answer.

The course profile for Claude Code is set up to keep a work log. When you work on a course task, a .codegym/cc-transcript.txt file is created in the project folder, and it records how the work went: your requests to the agent, the beginning of its responses, which files it changed, which commands it ran.

Why it's needed: the platform uses this log to check your solution. Think of it as your "show your work" notebook: it shows not just the result but how you got there. Sounds a bit unsettling, I get it. But without the log, the platform only sees what you ended up with.

What you should know:

the log lives in your project folder, and you can open it and read it;
it isn't sent anywhere on its own - the files that write the log don't make a single network call;
passwords and keys in it are masked the same way as in the install log;
it's only written in the course profile. Run claude-native and no log is kept.

Which server the AI traffic goes through

One more fact that's better stated openly than left unsaid.

CodeGym pays for the AI access you get in the course, and it runs through our server, llm.codegym.cc. That means your requests to the model and its responses physically pass through CodeGym's infrastructure.

That's how free access for students works. If you want to work directly with your own personal account, that's exactly what the claude-native command is for.

7. How to check it and how to undo it

You don't have to take this article's word for it. The installer has modes that let you look before anything happens and roll things back afterward.

Preview without installing anything

The --dry-run flag (-DryRun on Windows) runs the installer in "show only" mode. It prints the full list of what it would do (which files it would download, where it would put them, what it would add to PATH) and exits without installing anything.

To be fair, this mode doesn't leave everything completely untouched. It overwrites the log file from the previous run, creates its working folders and cleans up outdated backups. But no programs get installed, and your settings and PATH stay the same.

Leave PATH alone

The --minimal flag (-Minimal on Windows) installs all the programs but doesn't write any paths into system settings. Instead, it prints the lines for you to add yourself. This mode is for people who have their environment set up just the way they like it (if you're not sure whether you need it, you don't).

On Windows this mode doesn't fully work yet: the path to the course commands still gets added to your user PATH. The change is reversible, but for now the flag doesn't quite do what it says. We know about it and will fix it.

Undo the changes

The --rollback flag (-Rollback on Windows) reverts the settings the installer changed: PATH, shell profile files, configs, registry entries. Every change is recorded in an operations log, and the rollback follows that log exactly.

There's an extra safeguard: if you've edited a file since the install, the rollback won't touch it. It tells you instead and shows you where the backup is.

What the rollback doesn't do: it doesn't uninstall programs. IntelliJ IDEA, Java, Node and the rest stay where they are. Instead, the installer prints a list of them with ready-to-use uninstall commands, and you decide what to remove.

One more thing to be upfront about: on Windows, the Java, Node and Python installers add their own paths themselves, bypassing our operations log. The rollback can't undo those entries.

On Windows, the installer prints the ready-made rollback command at the end of the install. Here's how to run it:

Open PowerShell as administrator: right-click the PowerShell icon, then "Run as administrator".
Go to the installer folder.
Run the command:

powershell -NoProfile -ExecutionPolicy Bypass -File .\resources\Windows_install.ps1 -Rollback

See what was done

When it finishes, the installer prints a report: a list of steps, each with a status - done, skipped, warning, error or "do this manually". Failures aren't hidden: if something didn't install, the report says so plainly and gives the reason.

Anything the installer couldn't do by itself is collected in a separate "Finish manually" section with the exact commands to run.

8. What you'll have to do by hand

Some things simply can't be automated.

Permissions for Handy. The first time it runs, the system will ask for microphone access (and on macOS, for Accessibility access too). Without that, voice input won't work. Only a person can grant these permissions; no program can do it for you.

IntelliJ IDEA dialogs on first launch. The installer accepts the license in advance, but if a license dialog still pops up, accept it.

9. FAQ

How long does installation take?

20-40 minutes, with about a gigabyte to download. Most of that time goes to IntelliJ IDEA and the speech recognition model.

Why does it need administrator rights?

The programs are installed into system folders (Program Files, /opt, /Applications), and you can't write there without administrator rights. Your settings and the course profile, on the other hand, go into your user folder and stay yours.

Can I run the installer twice?

Yes, nothing will break. Anything already installed gets skipped. There's also protection against launching it twice by accident: the second instance sees that an installation is already in progress and simply closes.

What happens to my Claude Code settings?

Nothing. The course profile lives in a separate folder, and your personal one is never read or modified. For your own work there's the claude-native command.

My system shows a warning when I run it. Is that normal?

Yes. That's how operating systems treat any program downloaded from the internet, and our installer doesn't have a code signing certificate yet. On Windows, click "More info", then "Run anyway". On macOS, if you see a message saying the developer cannot be verified, right-click the file, choose "Open", then confirm once more.

The installer removes the "downloaded from the internet" flag from files. Why?

Otherwise the system blocks the bundled files from running, and the installation stops halfway. On Windows this is done for the unpacked folder; on macOS it means clearing the Gatekeeper quarantine on that same folder. The flag is only removed from the installer's own files, and the installer doesn't touch any of your other files.

Why shouldn't I share the archive with others?

It contains your personal sign-in data. Whoever gets the archive can work under your account. Sharing the download link is fine: everyone who uses it gets their own archive.

Something went wrong. What should I do?

Check the report at the end and the install.log file: they show which step failed and why. If it's still unclear, send that file to support. That's the normal route, not a last resort.

10. If you don't want to install everything at once

The installer isn't a required step in the course; it's a way to save time. Everything it does is covered step by step in the lectures: Claude Code installs with a single command, and the settings come as a single file you copy over.

The other tools get added as you need them, and by the time you need them, you'll understand what they're for. They stick better that way than as a ten-item list.