14-Day Quick Pass
From editor configuration to an efficient dev workflow, one topic a day
🚀Start Your Journey
VSCode is the most widely used code editor in the world. These 14 days will take you from zero to proficient, covering every core skill a sophomore needs.
Setup & Configuration
Install, interface, settings, shortcuts
Efficient Editing
Multi-cursor, search & replace, snippets
Debugging & Tools
Breakpoints, terminal, Git integration
Extension Ecosystem
Curated plugins, remote dev, collaboration
Meet VSCode and Its Interface
Install the editor and understand every panel
🧭Why VSCode
VSCode (Visual Studio Code) is Microsoft's open-source, cross-platform code editor. It's not an IDE (it doesn't bundle a compiler), yet thanks to its lightweight core + extension ecosystem it has become the most widely used editor in the world. For second-year students, it's an all-rounder for C/Java/Python/frontend — one tool for every course assignment.
📦Installation
# macOS (Homebrew recommended)brew install --cask visual-studio-code
# Windows / Linux
# visit https://code.visualstudio.com to download the installer
# be sure to tick "Add to PATH" at install time
🪟Five Interface Regions
Activity Bar
The vertical bar on the far left, to switch between Explorer, Search, Git, Debug and Extensions
Side Bar
Shows the content of the current view, such as the file tree or extension list
Editor
The main battlefield for writing code, with multi-tab and split views
Panel
Terminal, Problems, Output and Debug Console
Status Bar
The bottom bar shows language, line/column, Git branch and encoding
⌨️The First Must-Learn Shortcut: Command Palette
The Command Palette is the soul of VSCode. Almost anything can be done from here — search for it when you can't remember a shortcut.
Ctrl+Shift+P
# Windows / Linux open the Command PaletteCmd+Shift+P
# macOS
# type "theme" to switch themes
# type "font size" to adjust font size
# type "toggle sidebar" to hide the Side Bar
>; entries without > let you jump to a file. Just type a file name to quickly open it.✅Hands-On Tasks
🧠Quick Quiz
File Explorer and Workspace
Organize projects with folders, and understand folders vs. multi-root workspaces
📂Open a Project
The basic unit of work in VSCode is a "folder". The best way is to enter the project directory in a terminal and open it with code ..
# in the terminal, enter your project foldercd ~/Desktop/my-projectcode .
# open the current folder in VSCodecode ~/Desktop/my-project
# equivalent form
code: command not found, the command isn't on PATH. On macOS open VSCode → Command Palette → search "shell command" → choose "Install 'code' command in PATH".🗂️Explorer Operations
| Action | Shortcut / Method |
|---|---|
| New File | Ctrl+N or right-click the file-tree empty area → New File |
| New Folder | Right-click the file tree → New Folder |
| Rename | Select the file and press F2 |
| Delete | Select the file and press Delete |
| Copy File Path | Right-click → Copy Path, or Shift+Alt+C |
| Reveal current file in the tree | Shift+Alt+R |
🏢Workspace
When you open just one folder, that's "single-folder mode". When you need several folders at once (for example a frontend + backend pair of directories), use a workspace.
Menu File → Add Folder to Workspace... → add multiple folders, then File → Save Workspace As... → save as project.code-workspace
A .code-workspace file is a piece of JSON that records which folders are included and any shared settings. Just double-click it next time to restore the whole environment.
✅Hands-On Tasks
🧠Quick Quiz
Editing Fundamentals
Move, copy and delete lines like a pro so your typing gets faster
✂️Line-Level Editing
You'll use these operations hundreds of times a day. Train them into muscle memory.
| Action | Windows / Linux | macOS |
|---|---|---|
| Delete current line | Ctrl+Shift+K | Cmd+Shift+K |
| Move current line up | Alt+↑ | Option+↑ |
| Move current line down | Alt+↓ | Option+↓ |
| Copy current line up | Shift+Alt+↑ | Shift+Option+↑ |
| Copy current line down | Shift+Alt+↓ | Shift+Option+↓ |
| Insert line below | Ctrl+Enter | Cmd+Enter |
| Jump to line start/end | Home / End | Cmd+← / → |
📐Indentation and Formatting
# after selecting code:Tab
# increase indentShift+Tab
# decrease indent
# format the whole document: Shift+Alt+F
# Windows / LinuxShift+Option+F
# macOS
# format the selected part: Ctrl+K Ctrl+F
💾Auto-Save
Don't want to hit Ctrl+S manually every time? Turn on auto-save:
{ "files.autoSave": "afterDelay", "files.autoSaveDelay": 1000}
Three modes: off (manual), afterDelay (auto-save after a 1-second pause), onFocusChange (save when you switch away).
✅Hands-On Tasks
🧠Quick Quiz
Multi-Cursor Editing
Change ten places in one action — the core skill for batch editing
✨Multi-Cursor: VSCode's Most Addictive Feature
Imagine typing in 10 places at once — that's multi-cursor. Renaming 10 variable occurrences used to take 10 operations; now it takes one.
🖱️Method 1: Alt+Click to Add a Cursor
Hold Alt (macOS Option) and click anywhere to add a new cursor. You can type in several places at once.
🔤Method 2: Ctrl+D to Select the Next Same Word
This is the superpower for renaming variables. Select a word, press Ctrl+D repeatedly to add every identical word to the selection, then rename them all at once.
# after selecting a word:Ctrl+D
# select the next same word (macOS: Cmd+D)Ctrl+Shift+L
# select all same words at onceCtrl+K Ctrl+D
# skip current, select nextCtrl+U
# undo last selection (go back)
📊Method 3: Column (Block) Selection
Hold Shift+Alt (macOS Shift+Option) and drag, or drag with the middle mouse button, to make a vertical rectangular selection. Great for editing aligned tables or adding batch comments.
Shift+Alt+Drag
# rectangular selectionCtrl+Shift+Alt+↓/↑
# keyboard column selection (move cursor down/up)
🎯Live Demo
Convert this set of variables from camelCase to snake_case:
// Steps: select userName, press Ctrl+D three times to select all,
// then just type the new name user_namelet userName = getUserName();console.log(userName);saveUser(userName);
✅Hands-On Tasks
🧠Quick Quiz
Search, Replace and Global Refactor
Search within one file, or across the whole project
🔍Search Within a File
| Action | Shortcut |
|---|---|
| Find | Ctrl+F (macOS Cmd+F) |
| Replace | Ctrl+H (macOS Cmd+Option+F) |
| Next match | Enter or F3 |
| Previous match | Shift+F3 |
| Select next match | Ctrl+D |
🌐Global Search
Search for a function, variable or string across the entire project — the feature you'll use most when reading other people's code.
Ctrl+Shift+F
# global search (macOS: Cmd+Shift+F)
The top of the global-search panel has three advanced filters:
- Match Case (Aa): case-sensitive matching
- Whole Word: only whole words, not substrings
- Regex (.*): use regular expressions
There's also a "files to include/exclude" box to filter by file type, e.g. *.py, *.js or -*.min.js.
🔬Regex Search in Practice
# find all console.log statements (handy for cleaning up debug code)console.log(.*)
# find all TODO comments//s*TODO.*
# find phone numbers (simple version)1[3-9]d{9}
🔗Symbol Search
Jump to the definition of a function/class:
Ctrl+Shift+O
# list of symbols (functions/classes) in the current fileCtrl+T
# symbol search across the whole workspaceF12
# jump to the definition of the symbol at the cursorAlt+F12
# peek at the definition (preview popup, no jump)
✅Hands-On Tasks
🧠Quick Quiz
Integrated Terminal
Run commands without leaving the editor
💻Integrated Terminal
VSCode has a built-in terminal, so you don't need a separate Terminal/iTerm window. Write, compile, run and do Git — all in one place.
Ctrl+`
# open/close the terminal (macOS: Ctrl+`)Ctrl+Shift+`
# create a new terminal instance
🔀Multiple Terminals and Splitting
In the terminal panel, the right side has a + to create a terminal and a split icon to split the view. Run a server in one and tests in another without interference.
| Action | Method |
|---|---|
| New terminal | Click + or Ctrl+Shift+` |
| Split terminal | Click the split icon, or Ctrl+Shift+5 when a terminal is open |
| Switch terminal | Choose from the dropdown, or Alt+↑/↓ |
| Close terminal | Click the trash-can icon |
| Toggle focus terminal/editor | Ctrl+Shift+↑/↓ |
⚙️Compile and Run Course Assignments
# compilegcc main.c -o main -Wall
# run./main
# compilejavac HelloWorld.java
# run (note: no .class suffix)java HelloWorld
# run directlypython3 main.py
# interactivepython3 -i main.py
🎨Recommended Terminal Settings
{ "terminal.integrated.fontSize": 14, "terminal.integrated.scrollback": 10000, "terminal.integrated.copyOnSelection": true}
✅Hands-On Tasks
🧠Quick Quiz
Version Control: Git Integration
Commit, diff and resolve conflicts without touching the command line
🌿VSCode's Git Capabilities
VSCode has built-in Git support — no extension required. The second icon in the Activity Bar (Source Control) is it. Most everyday Git operations can be done with the GUI.
📝The Three-Step Commit
- Modify: after editing, file names turn yellow (modified) or green (new)
- Stage: in the Source Control panel, click the
+next to a file to stage it (equivalent togit add) - Commit: type a message in the input box and press Ctrl+Enter (equivalent to
git commit)
📊Diff View
Click a file in the Source Control panel to open the diff view: the old version is on the left (red shading for deletions), the new one on the right (green shading for additions). Reviewing your own changes like this is a good habit.
| Action | Shortcut |
|---|---|
| View diff | Click the file name |
| Stage a single file | Click +, or use Ctrl+Shift+G then operate |
| Stage selected ranges | Right-click in the diff view → Stage Selected Ranges |
| Discard changes | Click the ↺ icon (dangerous! discards uncommitted changes) |
🔀Branches and Sync
The Status Bar's bottom-left shows the current branch name; click it to create/switch branches. The ↑↓ number next to it shows commits ahead/behind the remote; click the sync icon to push/pull.
# left of the Status Bar: main ↓2 ↑1
# 2 commits behind the remote, 1 ahead
# click the branch name → create/switch branch
# click the sync icon (↻) → git pull + git push
⚔️Resolving Merge Conflicts
When a pull hits a conflict, VSCode shows four buttons at the conflict site:
<<<<<<< HEADyour changes=======remote changes>>>>>>> branch-name
# VSCode shows 4 buttons:Accept Current
# keep only yoursAccept Incoming
# keep only the remote'sAccept Both
# keep bothCompare
# compare the two versions
After resolving, save and commit.
git pull before writing code and commit + push as soon as you're done. Don't hoard changes and push them all at once — the conflicts will kill you.✅Hands-On Tasks
🧠Quick Quiz
Essential Extension Ecosystem
Install the right plugins and VSCode becomes complete
🧩Extension Marketplace
The last icon in the Activity Bar (the block shape) is the extension marketplace. VSCode is powerful because of its tens of thousands of extensions. But don't over-install — too many will slow the editor down. Here's a curated list for sophomores.
⭐Must-Have Extensions Top 10
Chinese (Simplified) Language Pack
Chinese UI pack; takes effect after a restart
Prettier
Code formatter supporting JS/HTML/CSS/JSON
ESLint
JS/TS code linting that flags problems with red underlines
Python
Microsoft's official Python extension: debugging + IntelliSense
Extension Pack for Java
The full Java bundle incl. debugging, Maven and testing
C/C++
Microsoft's official C/C++ support incl. debugging
GitLens
Shows who changed each line and when
Live Server
Local server for frontend with save-to-refresh
Path Intellisense
Auto-completes file paths
indent-rainbow
Colors indentation levels so nesting is clear
🔍How to Pick Extensions
- Check the install count: the million-level ones are usually reliable
- Check recent updates: be wary of anything not updated in over a year
- Check ratings: avoid anything below 3 stars
- Check the author: prioritize Microsoft or official language publishers
📦Language Support Extensions
VSCode only ships full JS/TS support by default. Other languages need the matching extension for IntelliSense, debugging and more:
| Language | Recommended extension | Capabilities |
|---|---|---|
| Python | Python (ms-python) | IntelliSense, debugging, Jupyter |
| Java | Extension Pack for Java | Full set: debugging, Maven, refactoring |
| C/C++ | C/C++ (ms-vscode) | IntelliSense, debugging (needs a compiler) |
| HTML/CSS | Live Server + built-in | Live preview, Emmet abbreviations |
| Markdown | Markdown All in One | Shortcuts, TOC, preview |
🚫Disable and Uninstall
In the extension list, each extension has "Disable" (temporarily off) and "Uninstall" (permanently remove). You can also enable/disable per workspace.
✅Hands-On Tasks
🧠Quick Quiz
Debugger Essentials
Stop print-debugging; learn to set breakpoints
🐛Why Use a Debugger
Sophomores love using printf / System.out.println to debug — recompiling after every one-line change is extremely inefficient. A debugger lets you pause the program, step line by line, and inspect variable values at any moment — a fundamental skill of professional development.
🔴Set a Breakpoint
Click in the empty space left of a line number and a red dot appears — that's a breakpoint. The program pauses automatically when it reaches that line.
# normal breakpoint: click the blank space left of the line number
# conditional breakpoint: right-click the line-number gutter → Add Conditional Breakpoint
# only pauses when the expression is true, e.g. i == 50
# logpoint: right-click → Add Logpoint
# doesn't pause, just prints a message (replaces print debugging)F9
# toggle breakpoint on the current line
▶️Start Debugging
Press F5 to start debugging. The first time you'll be asked to pick an environment (e.g. Python, C++ (GDB)). VSCode generates a .vscode/launch.json config file.
| Action | Shortcut | Description |
|---|---|---|
| Start / Continue | F5 | Run until the next breakpoint |
| Step Over | F10 | Run the current line without stepping into functions |
| Step Into | F11 | Step into a function and run line by line |
| Step Out | Shift+F11 | Finish the current function and return to the caller |
| Stop | Shift+F5 | End debugging |
| Restart | Ctrl+Shift+F5 | Restart debugging |
👁️Four Sections of the Debug Panel
Variables
Values of all variables in the current scope, auto-updated
Watch
Manually add expressions to monitor continuously
Call Stack
Shows the function call chain; click any frame to jump to it
Breakpoints
List of all breakpoints; enable/disable each
🐍Example Python Debug Config
{ "version": "0.2.0", "configurations": [ { "name": "Python: Current File", "type": "python", "request": "launch", "program": "${file}", "console": "integratedTerminal", "justMyCode": true } ]}
i == 500 — it pauses only on that iteration. Far more efficient than printing a thousand times.✅Hands-On Tasks
🧠Quick Quiz
Code Snippets and Emmet
Do more with less typing: custom code templates
✂️Code Snippets
There are always a few blocks you type over and over — the main function, a for loop, a class template. Save them as "snippets", type a few letters, and press Tab to expand. This is a weapon against repetitive typing.
📝Create a Custom Snippet
In the Command Palette search "Configure User Snippets", pick a language (e.g. python.json). The syntax is JSON:
{ "Print debug": { "prefix": "pdb", "body": [ "print(f'{$1} = {$1}')", "$2" ], "description": "Quickly print a variable for debugging" }, "For loop": { "prefix": "ffor", "body": [ "for ${1:i} in range(${2:10}):", " ${3:pass}" ] }}
Type pdb and press Tab to expand. Here $1, $2 are placeholders — press Tab to jump between them, saving mouse movement.
$1 is the first cursor position; ${1:default} carries default text; $0 is the final cursor position.⚡Emmet: The Frontend Abbreviation Tool
When writing HTML/CSS, VSCode has Emmet built in. Type an abbreviation and press Tab to expand it into full code.
# type the abbreviation below and press Tab:div.container
→ <div class="container"></div>ul>li*3
→ <ul> <li></li> <li></li> <li></li> </ul>button.btn.btn-primary{Click me}
→ <button class="btn btn-primary">Click me</button>
# CSS abbreviations: m10 → margin: 10px;p20-30 → padding: 20px 30px;d:f → display: flex;
🔤Emmet Syntax Cheat Sheet
| Syntax | Meaning | Example |
|---|---|---|
# | id | div#header |
. | class | p.text-center |
> | child element | ul>li |
+ | sibling element | h1+p |
* | repeat N times | li*5 |
{} | text content | a{Home} |
() | grouping | (div>p)*3 |
✅Hands-On Tasks
🧠Quick Quiz
Settings, Shortcuts and Customization
Make VSCode look and work your way
⚙️Two Ways to Configure
VSCode settings can be opened two ways: the graphical UI (Settings UI) and the JSON file (settings.json). Beginners use the UI; advanced users use JSON — because JSON lets you batch-edit, comment and version-control your config.
Ctrl+,
# open the Settings UICtrl+Shift+P → "Open Settings (JSON)"
# open the JSON
🏢Setting Scope
| Level | File location | Scope |
|---|---|---|
| User | ~/.config/.../settings.json | Shared across all projects |
| Workspace | project/.vscode/settings.json | Current project only |
| Folder | each folder in a multi-root workspace | That folder only |
Workspace settings override user settings. For example, give a specific project a larger font or a custom Python interpreter path.
📋Recommended Configuration
{
// editor "editor.fontSize": 15, "editor.fontFamily": "'JetBrains Mono', Consolas, monospace", "editor.tabSize": 4, "editor.formatOnSave": true, "editor.minimap.enabled": false, "editor.wordWrap": "on",
// files "files.autoSave": "afterDelay", "files.trimTrailingWhitespace": true,
// terminal "terminal.integrated.fontSize": 14,
// search "search.exclude": { "**/node_modules": true, "**/.git": true, "**/dist": true }}
🎹Keyboard Shortcuts
Every shortcut in VSCode can be viewed and customized. In the Command Palette search "Keyboard Shortcuts", or press Ctrl+K then Ctrl+S.
# open the shortcut settingsCtrl+K Ctrl+S
# custom example in keybindings.json:[ { "key": "ctrl+shift+c", "command": "editor.action.commentLine", "when": "editorTextFocus" }]
🔌High-Frequency Shortcut Cheat Sheet
| Feature | Windows/Linux | macOS |
|---|---|---|
| Command Palette | Ctrl+Shift+P | Cmd+Shift+P |
| Quick Open file | Ctrl+P | Cmd+P |
| Toggle Side Bar | Ctrl+B | Cmd+B |
| Toggle Terminal | Ctrl+` | Ctrl+` |
| Toggle comment | Ctrl+/ | Cmd+/ |
| Format | Shift+Alt+F | Shift+Option+F |
| Find | Ctrl+F | Cmd+F |
| Split | Ctrl+\ | Cmd+\ |
| Close tab | Ctrl+W | Cmd+W |
✅Hands-On Tasks
🧠Quick Quiz
Multi-Root Workspaces and Project Config
Manage multiple projects in one window, and share team config
🏢Multi-Root Workspace
When you develop frontend and backend at the same time, or need to view docs and code together for a big assignment — a multi-root workspace lets you manage several folders in one window.
# method 1: menuFile → Add Folder to Workspace... → pick a second folderFile → Save Workspace As... → save as my-project.code-workspace
# method 2: command linecode folder1 folder2
# open multiple folders at once
{ "folders": [ { "path": "frontend" }, { "path": "backend" }, { "path": "docs" } ], "settings": { "editor.fontSize": 15 }}
📁The .vscode Directory
Each project folder can contain a .vscode directory with project-level config:
| File | Purpose |
|---|---|
settings.json | Project settings (font size, language mode, etc.) |
launch.json | Debug configuration |
tasks.json | Custom tasks (compile, run scripts) |
keybindings.json | Project-level shortcuts |
extensions.json | Recommended extensions list |
🔨Custom Tasks
Save your common build/run commands as "tasks" and trigger them with one key. Press Ctrl+Shift+B to run the default build task, or Ctrl+Shift+P → "Run Task".
{ "version": "2.0.0", "tasks": [ { "label": "build C", "type": "shell", "command": "gcc", "args": ["${file}", "-o", "${fileDirname}/${fileBasenameNoExtension}", "-Wall"], "group": { "kind": "build", "isDefault": true }, "problemMatcher": ["$gcc"] } ]}
After that, pressing Ctrl+Shift+B auto-compiles the current C file, and errors are click-to-jump in the "Problems" panel.
👥Team-Shared Config
Commit the .vscode directory to Git, and teammates get the same tasks, debug config and recommended extensions after cloning.
{ "recommendations": [ "ms-python.python", "esbenp.prettier-vscode" ]}
When teammates open the project, VSCode will suggest installing the recommended extensions.
.gitignore. Only commit config that's safe to share.✅Hands-On Tasks
🧠Quick Quiz
Remote Development and Live Share
Write code on a server, or collaborate with classmates in real time
🌐Remote - SSH
Sophomores often have to connect to a school server for experiments, once stuck with the painful SSH + Vim combo. The Remote-SSH extension lets you edit remote files with your local VSCode UI — IntelliSense, debugging and the terminal all run remotely.
# 1. install the extension: Remote - SSH (ms-vscode-remote.remote-ssh)
# 2. Command Palette → Remote-SSH: Connect to Host
# 3. type ssh user@hostname
# 4. VSCode installs a server component on the remote
# 5. once connected, File → Open Folder to open the remote directory
Host school-server HostName 192.168.1.100 User student Port 22 IdentityFile ~/.ssh/id_rsa
Once configured, just pick the school-server alias when connecting.
🐳Dev Containers
"It works on my machine" is a classic excuse. Dev Containers use Docker to package the whole dev environment (compilers, dependencies, toolchain) into a container, so everyone's environment is identical.
pull it and get started — saving all the environment-setup time.
{ "name": "C Dev Environment", "image": "gcc:latest", "extensions": ["ms-vscode.cpptools"], "postCreateCommand": "gcc --version"}
🤝Live Share: Real-Time Collaboration
Live Share is VSCode's real-time multi-person collaboration feature — like Google Docs for code. One person "shares" a session, others join, and everyone edits the same file simultaneously while seeing each other's cursors.
# 1. install the extension: Live Share (ms-vsliveshare.vsliveshare)
# 2. click the Live Share icon in the Status Bar / Activity Bar
# 3. "Share" generates a link to send to your classmate
# 4. your classmate opens the link and joins in the browser/VSCode
# 5. both edit in real time; terminal and debug sessions can be shared
🔗Comparing the Three Remote Methods
| Method | Scenario | Requires |
|---|---|---|
| Remote-SSH | Develop on a remote server | SSH access |
| Dev Containers | Unified dev environment | Docker installed locally |
| Remote-Containers (WSL) | Run Linux on Windows | WSL2 |
| Live Share | Real-time multi-person collab | Network + Live Share extension |
✅Hands-On Tasks
🧠Quick Quiz
Capstone: Build a Complete Dev Workflow
Connect all 13 days into a real project that runs end to end
🏆Ultimate Task: Build a Small Python Project From Scratch
Use every skill from these 14 days to walk through a full professional development flow. We'll build a simple "To-Do" command-line program.
1️⃣Step 1: Scaffold the Project
mkdir todo-cli && cd todo-cligit initcode .
# open with VSCode
Create the file structure in the Explorer:
todo-cli/├── .vscode/│ ├── launch.json
# debug config│ ├── tasks.json
# run tasks│ └── settings.json
# project settings├── main.py
# program entry├── todo.py
# core logic└── README.md
# docs
2️⃣Step 2: Write the Core Code
class TodoList: def __init__(self): self.items = [] def add(self, text): self.items.append({"text": text, "done": False}) print("f"Added: {text}"") def complete(self, index): if 0 len(self.items): self.items[index]["done"] = True print("f"Completed: {self.items[index]['text']}"") def show(self): for i, item in enumerate(self.items): mark = "✓" if item["done"] else "○" print("f"{i}. [{mark}] {item['text']}"")
3️⃣Step 3: Configure the Debugger
Press F5, choose Python, and launch.json is generated automatically. Modify it to accept command-line arguments:
{ "version": "0.2.0", "configurations": [{ "name": "Debug Todo", "type": "python", "request": "launch", "program": "${workspaceFolder}/main.py", "args": ["add", "Finish homework"], "console": "integratedTerminal" }]}
4️⃣Step 4: Debug + Git Full Flow
- Set a breakpoint: at the first line of the
addmethod - Start debugging: press F5, program pauses at the breakpoint
- Step through: use F10 to watch variables change line by line
- Inspect variables: watch how
self.itemschanges in the Variables panel - Commit: Source Control panel → stage → write a message → commit
- Configure a task: tasks.json with
python3 main.pyfor one-key run
5️⃣Step 5: Productivity Checklist
Go through this checklist and see whether you've really internalized all 14 days:
🚀Where to Go Next
- Go deep in one language: for your main language (C/Java/Python), dig into its debugging, testing and LSP setup
- AI-assisted coding: install GitHub Copilot / Codeium to experience AI completion
- Theme polish: try popular themes like One Dark Pro, Material Icon Theme
- Vim mode: install a Vim extension to learn keyboard-driven editing (advanced)
- Custom extensions: write one of your own in TypeScript (advanced)
✅Hands-On Tasks
🧠Quick Quiz
All 14 Days Complete!
You've grown from a VSCode novice into an efficient developer. Keep going — tools are leverage: the more skilled you are, the more powerful they become.