Editor • Terminal • Git • SSH • Student Workflow

VS Code is the student control room.

Visual Studio Code is a free editor where I can write code, open folders, run terminal commands, use Git, connect to remote servers, manage projects, and install extensions for different languages.

The reason VS Code feels powerful is that it is not just a text editor. It becomes the place where the whole workflow comes together: files on the left, code in the center, terminal on the bottom, Git changes on the side, and remote servers one SSH connection away.

Main idea: VS Code is useful because it connects editing, terminal work, Git, debugging, extensions, and remote development in one clean workspace.
Project folder Open the real folder, not random loose files.
Editor + terminal Write code and run commands in the same workspace.
Git + extensions Track changes and add language support.
Remote SSH or Codespaces Edit on servers, Raspberry Pis, or browser-based cloud environments.
VS Code becomes much more useful once I treat it as a full project workspace, not just an editor.

Why VS Code matters

VS Code is one of the best tools for students because it works across many kinds of projects: Python scripts, Java assignments, C++ labs, static websites, Flask apps, Markdown notes, GitHub repos, and remote Linux servers.

Coding

One editor for many languages

I can use the same editor for Python, Java, C++, HTML, CSS, JavaScript, Markdown, JSON, Bash scripts, and config files.

Linux

Terminal built in

I can run commands, compile programs, start servers, use Git, and test scripts without leaving the project window.

Remote work

Edit servers over SSH

With Remote SSH, I can open a folder on a VPS, VM, Raspberry Pi, or lab machine and edit it almost like it is local.

Install VS Code

VS Code is free and runs on Windows, macOS, and Linux. On Linux, I usually install it from the official package. On Debian or Ubuntu-based systems, the downloaded .deb package can be installed with apt.

# After downloading the official .deb package
sudo apt install ./code_*.deb
Note: the official VS Code Linux install page explains the current package options for Debian, Ubuntu, Fedora, RHEL, SUSE, Snap, and other Linux setups.
Raspberry Pi note: on Raspberry Pi OS, VS Code can usually be installed through apt with sudo apt install code.

Want to try it before installing?

VS Code itself is free, but I do not even need to install it first to understand the workflow. GitHub Codespaces gives me a VS Code-style editor in the browser with a Linux terminal attached to a GitHub repo.

Free editor

VS Code costs nothing to start

VS Code is a free editor that works on Windows, macOS, and Linux. I can install it locally and use it for Python, Java, C++, HTML, CSS, Git, SSH, and general project work.

Browser option

Codespaces lets me test the workflow

Codespaces is useful when I want to try the VS Code-style workflow without setting up a full local toolchain first. I can open a repo, use the editor, run Linux commands, test code, and commit changes from the browser.

Want to try it first? Start with the GitHub Codespaces Guide to open a browser-based VS Code-style workspace, then install VS Code locally once the workflow makes sense.
Student note: GitHub personal accounts include some free Codespaces usage each month, and verified students may get more through GitHub Education. Check GitHub's current quota and billing page before relying on exact usage limits.

Open a project the right way

The best habit is to open the whole project folder, not just one file. That lets VS Code understand the folder structure, Git repo, terminal location, and project settings.

# Go to a project folder
cd ~/projects/launchshell-org

# Open the folder in VS Code
code .
Common beginner mistake: opening one random file makes VS Code less useful. Opening the full folder gives me Explorer, terminal, Git status, search, and workspace context.

My normal VS Code workflow

This is the loop I use for most student projects.

01

Open folder

Start from the project root so VS Code can see the whole workspace.

02

Edit files

Use Explorer, search, tabs, and split view to work across files.

03

Run commands

Use the integrated terminal to test, compile, serve, or debug.

04

Commit changes

Use Git from the terminal or Source Control panel after checking the diff.

The integrated terminal is the key feature

The terminal inside VS Code is not a fake terminal. It runs my normal shell inside the project folder. That means I can use the same Linux commands I would use in a separate terminal window.

1

Open terminal

Open the integrated terminal from the VS Code menu or keyboard shortcut.

Ctrl + `
2

Check the folder

Confirm I am in the project directory.

pwd
ls
3

Run project commands

Test scripts, compile code, or run a local server.

python3 weather.py --zip 11234
javac Movies.java
python3 -m http.server 8000
4

Use Git

Check changes before committing.

git status --short
git diff
git add .
git commit -m "Add VS Code guide"

Install useful extensions

Extensions are what turn VS Code into a good editor for specific languages and workflows. I do not need hundreds of them. I need the right few.

Extension type Why I use it Good for
Python Syntax help, linting, testing, virtual environments, and debugging. Scripts, Flask apps, API tools, automation.
Java Extension Pack Java language support, project tools, running, and debugging. Data structures assignments and Java class projects.
C/C++ Editing, IntelliSense, compiling, and debugging support. C++ labs, systems work, algorithms practice.
Remote - SSH Open folders on remote Linux machines over SSH. VPS work, Raspberry Pi projects, cloud servers.
GitHub Pull Requests Review issues and pull requests from inside VS Code. GitHub workflow and collaboration.
Markdown tools Preview Markdown and improve docs. README files, project notes, LaunchShell writeups.
My rule: install extensions when they support an actual project. Do not turn VS Code into a cluttered dashboard of extensions I barely use.

Use the command palette

The command palette is one of the fastest ways to control VS Code. Instead of searching through menus, I can type what I want to do.

Ctrl + Shift + P

Open settings

Search for settings without digging through menus.

Preferences: Open Settings

Open keyboard shortcuts

Find or change shortcuts.

Preferences: Open Keyboard Shortcuts

Install extensions

Open the extension interface quickly.

Extensions: Install Extensions

Remote SSH connect

Start a remote SSH session.

Remote-SSH: Connect to Host...

Use VS Code with Git

VS Code makes Git easier because I can see changed files, inspect diffs, stage changes, and commit. I still like knowing the terminal commands because they are portable.

Terminal Git

Portable commands

git status --short
git diff
git add index.html assets/site.css
git commit -m "Add VS Code guide"
git push
Source Control panel

Visual review

The Source Control panel is useful for seeing exactly which files changed and reviewing diffs before committing.

Public repo habit: before committing, check for API keys, passwords, private IPs, screenshots with secrets, local settings files, and anything that should not be public.

Use VS Code for LaunchShell HTML work

For a static HTML/CSS site like LaunchShell, VS Code is a clean setup because I can edit HTML, check CSS, serve the folder locally, and commit the changes from one workspace.

# From the LaunchShell project root
python3 -m http.server 8000
http://localhost:8000/

Edit the page

Open a guide or project page and make the content changes.

guides/vs-code/index.html

Keep CSS centralized

Use assets/site.css for styling instead of inline CSS.

assets/site.css

Preview locally

Use the local server and refresh the browser.

python3 -m http.server 8000

Check before commit

Review the diff before publishing.

git diff --check
git status --short

Use VS Code for Python scripts

Python projects are a good fit for VS Code because I can edit the script, run it in the terminal, and use Git from the same workspace.

# Example: Tiny Terminal Weather project
cd ~/projects/tiny-terminal-weather
code .

python3 weather.py --zip 11234
Good habit: run the script from the terminal, not only through a play button. That teaches command-line arguments, file paths, environment variables, and real execution.

Use VS Code for Java assignments

VS Code can work for Java class projects, especially small single-file assignments or data structures projects. I still want to know the raw compile and run commands.

# Compile and run a Java file
javac Movies.java
java Movies

# Another example
javac RadixIP.java
java RadixIP
Why this matters: even if VS Code can run Java through extensions, knowing javac and java helps me understand what is actually happening.

Use VS Code for C++ labs

For C++ assignments, VS Code is useful, but the compiler still matters. On Linux, I usually want g++ and sometimes gdb for debugging.

sudo apt update
sudo apt install build-essential gdb -y

g++ main.cpp -o main
./main
Student habit: compile manually at least sometimes. It makes autograder errors and terminal output less mysterious.

Remote SSH is one of VS Code's superpowers

Remote SSH lets me connect VS Code to a remote machine and open a folder there. This is useful for VPS work, Raspberry Pi projects, Linux servers, and cloud labs.

Local machine

Where VS Code runs

My laptop or desktop runs the VS Code window, keyboard shortcuts, theme, and interface.

Remote machine

Where the files live

The project folder is on a VPS, VM, Raspberry Pi, or Linux box. VS Code connects through SSH and lets me edit remote files.

# Example SSH config entry
Host launchshell-vps
    HostName example.server.ip
    User deploy
    Port 4222
    IdentityFile ~/.ssh/id_ed25519
Security habit: use SSH keys, keep private keys private, avoid committing SSH configs with sensitive hostnames or IPs, and only connect to systems I own or administer.

Recommended beginner settings

VS Code has many settings. These are a few practical ones that make student work cleaner.

{
  "editor.wordWrap": "on",
  "editor.tabSize": 2,
  "files.trimTrailingWhitespace": true,
  "files.insertFinalNewline": true,
  "terminal.integrated.defaultProfile.linux": "bash",
  "explorer.confirmDelete": true
}
Note: settings are personal. I would not blindly copy a huge settings file. Start small and add settings only when they solve a real problem.

Workspace files worth knowing

VS Code and Git projects often create small config files. Some should be committed. Some should stay local.

File or folder Purpose Commit?
.vscode/settings.json Workspace settings for the project. Sometimes, if they are useful for everyone.
.vscode/extensions.json Recommended extensions for the project. Often yes.
.env Environment variables and secrets. No. Add to .gitignore.
.gitignore Files Git should ignore. Yes.
README.md Project explanation and run instructions. Yes.

Good keyboard shortcuts

I do not need to memorize every shortcut. These are enough to make VS Code faster.

Shortcut Action Why I use it
Ctrl + ` Toggle terminal. Fast switch between editing and commands.
Ctrl + P Quick open file. Jump between files without clicking through folders.
Ctrl + Shift + P Command palette. Run commands without finding menus.
Ctrl + Shift + F Search across files. Find text across the entire project.
Ctrl + / Toggle comment. Quickly comment or uncomment code.
Ctrl + S Save file. Still worth knowing. Save before testing.

Beginner mistakes to avoid

VS Code is helpful, but it can hide what is happening if I rely on buttons without understanding the project.

Avoid this

Bad habits

  • Opening single files instead of the full project folder.
  • Installing too many extensions without knowing what they do.
  • Running code only with a play button and never learning the terminal command.
  • Committing .env files, tokens, passwords, or private screenshots.
  • Editing files on a server without backups, Git, or a rollback plan.
Do this instead

Better habits

  • Open the project root with code ..
  • Use the integrated terminal constantly.
  • Know the real run command for each project.
  • Check git diff before committing.
  • Use Remote SSH carefully on systems I own or administer.

My VS Code starter checklist

This is the short checklist I would give a student setting up VS Code for real technical work.

# 1. Install VS Code

# 2. Open a real project folder
cd ~/projects/my-project
code .

# 3. Open the terminal
Ctrl + `

# 4. Confirm project location
pwd
ls

# 5. Run the project manually
python3 script.py
javac Main.java && java Main
g++ main.cpp -o main && ./main
python3 -m http.server 8000

# 6. Check Git before publishing
git status --short
git diff --check

# 7. Ignore private files
echo ".env" >> .gitignore
echo "weather_settings.json" >> .gitignore

Related LaunchShell guides and projects

VS Code is the workspace I would use for many of the projects on this site.

Browser IDE

GitHub Codespaces

Try a VS Code-style coding environment in the browser before installing a full local setup.

Open the Codespaces guide

Python

Tiny Terminal Weather

Edit weather.py, run it in the terminal, and commit the project with Git.

Java

Java Movie Database CLI

Compile and run Java class projects while using the editor to inspect methods and data structures.

Web

LaunchShell.org

Edit static HTML/CSS pages, preview locally, and publish through Git and Cloudflare Pages.

Official docs worth bookmarking

VS Code and Codespaces both have useful official documentation. These are the areas I would start with.

Setup

Install VS Code

Official setup instructions for different operating systems.

Open setup docs

Terminal

Integrated Terminal

Official explanation of how the terminal works inside VS Code.

Open terminal docs

Remote

Remote SSH

Official guide to connecting VS Code to remote machines over SSH.

Open Remote SSH docs

Browser

GitHub Codespaces

Official GitHub docs for browser-based cloud development environments.

Open Codespaces docs

Students

GitHub Education

Student benefits, GitHub Pro for verified learners, and included Codespaces usage.

Open GitHub Education

Final idea

VS Code is most useful when I use it as a complete workspace. The editor handles files, the terminal runs real commands, Git tracks changes, extensions support languages, and Remote SSH connects the same workflow to servers and Raspberry Pis. If I want to try the workflow first, Codespaces gives me a VS Code-style browser environment with a Linux terminal and GitHub repo already attached.