Your Development Environment
Four parts, four questions — and the cloud shortcut, if you would rather install nothing at all.
In the last lesson you opened a terminal and typed a command. In the next one you will be asked to run git init. In between, one piece of information is missing: what has to be on your machine for any of that to answer at all?
The answer is not one big program you buy. It is four small parts — and the fastest way in runs through a different question. Not "what do I download", but "which question does this part answer".
Your agent uses the same four parts: it runs in the terminal or inside the editor and reaches for the same runtime and the same git you do. So this is not background knowledge. It is what lets you check its work.
What you will not find here: a click-by-click installation walkthrough. It looks different on every system and will be wrong in six months. It lives on the official pages linked below.
What a development environment actually is
A development environment is not a product. It is the sum of four parts: a place to read, a place to command, something that actually runs the code, and a way back to a state that worked. None of them contains the others. Not to be confused with an "integrated development environment" (IDE): that is a single program, the full kit discussed further down.
Two practical things follow from that: you can find out in under a minute what you are missing — and you can recognise what you only talked yourself into needing.
Note
What you will be able to do
- Name the four parts and say which question each one answers.
- Work out which runtime a project you did not write needs — and why that hangs on the project's language, not on you.
- Explain why an editor's version-control buttons stop doing anything when git is missing.
- Convert a free allowance stated in core hours into real working time, and say what does not survive the end of a rented environment.
- Argue from what official prerequisite lists actually contain that you need neither a full IDE, nor a graphical git program, nor a new computer.
Four parts, four questions
You can already picture the editor: a window with text in it, coloured and searchable. It is the place where you read and check — and the less you type yourself, because an agent has taken over part of the writing, the more that place matters.
You know the terminal from the last lesson. Only one thing is new here: it belongs to the basic kit, and you do not install one. Every operating system ships with one.
That leaves the part most beginners overlook, because you never lay eyes on it. An editor displays text, a terminal takes commands — neither of them executes anything.
Definition
Runtime
In plain words
Technically
That holds even if you never write a line yourself: the project's own tooling needs the runtime before you type anything. A major web framework lists a minimum version of it in its installation page, purely so the project can be started.
One misunderstanding is worth losing early: the package manager — the program that pulls ready-made code building blocks written by other people into your project — is not a second download. It normally arrives with the runtime; on some systems the distribution ships it separately. And which installation route you take is not this article's call but the package manager's own installation guide — npm's, for one, points at a version manager, for permission reasons.
The fourth part is git, the way back. What git does is the next lesson's subject; what counts here is that it is a separate program you install yourself, and that its entire mandatory setup is two configuration lines: name and email address, once per machine.
Example: four questions, four answers
Your setup is not a mood, it is four yes-or-no answers. You type the following queries into any terminal — your system's own or the one inside the editor, which is the same thing anyway.
- 1. Ask the runtime: node --version or python --versionIf it answers with a number, the third part is there.
- 2. Ask the package manager: npm --version or pip --versionIt usually answers only if step 1 worked.
- 3. Ask git: git --versionNo number coming back means the fourth part is missing.
- 4. Open the terminal inside the editorIf that works, all four sit in one window.
Two of the answers look identical and mean different things. "Command not found" means either: not installed. Or: installed, but the command line cannot find it. Even the official guide of a major programming language knows the second case: it treats the search-path entry as its own, explicitly optional step.
Caution
"The editor has git buttons, so git is included"
It has the buttons, not the program. The documentation of the most widely used editor says it in one sentence: the git installation it drives is the one sitting on your own machine. The minimum version is named in the git handbook. If that is missing, the buttons sit there and do nothing. And that is exactly how you can see that there really are four separate parts here — one can be missing while the other three carry on.
Two questions, and the table shows you for each of the four parts whether you need to install it or whether it is already there.
Note
Numbers with a shelf life (as of 5 November 2026)
Runtime: the Node.js download page lists v26.13.0 as the latest LTS version, with v24 and v22 alongside as older LTS lines. Up to Node.js 26, only even-numbered releases became LTS; starting with Node.js 27, one major version ships per year, and each one becomes LTS after its Current phase; an LTS line is maintained for roughly 30 months.
git: current version 2.56.0, released on 28 September 2026. According to the git handbook, Visual Studio Code's version-control view is happy with anything from 2.0.0 upwards.
Hardware: Visual Studio Code names 1.6 GHz, 1 GB of RAM, under 200 MB of download and under 500 MB on disk. What follows from that is my own assessment and is documented nowhere: practically any machine that still boots will clear it.
Python on Windows is mid-move: the Python Install Manager is now the recommended route, while the classic installer counts as deprecated from 3.14 onwards and 3.16 will no longer get one.
Adoption: in the most recent available Stack Overflow survey — fielded 23 June to 5 August 2026, 30,903 valid responses in total, 13,193 of them on the editor question — 70.9 percent named Visual Studio Code. The respondents are the readership of a developer platform, not a representative sample. The figure is good for exactly one statement: the most-used tool is a free one.
These numbers age. The linked pages do not — that is where the current state lives.
You can test the four-part thesis without installing anything. Open vscode.dev: the documentation describes it as a Visual Studio Code that costs nothing, installs nothing and lives in a browser tab. Files, search, syntax colouring, all present.
And then the same documentation draws the line, which is what this is about: two things are absent there, the terminal and the debugging tool — absent because a browser does not let programs be compiled and started in the first place. Take the terminal and the runtime away from an environment and what is left is not a workplace but a text window. Open a rented environment such as GitHub Codespaces next to it, and the queries from above answer. Two tabs, one proof, zero installations.
The comfort that actually counts
Three conveniences of the editor are more than cosmetics, and one of them hides a trap.
Auto save exists, but it is off out of the box. You can switch it on in three ways: after a short delay, when you leave the file, or when you leave the window. Until then "it is in the editor" and "it is on the disk" are two different statements; once git joins in, a third one appears. Why unsaved text can be lost in a crash is something you know from step 1 of this learning path; VS Code does keep a backup of its own, but git and every other program only see what is on the disk.
The diff view puts old and new side by side. It is the one genuinely useful thing on screen when an agent has rewritten files you did not watch being written.
And the built-in terminal is not a different terminal: every command from the terminal lesson works in there unchanged.
The shortcut: renting an environment
There is a route where you install none of it: a cloud development environment. That is a machine somebody else keeps ready, reachable in a browser tab, with all four parts already on it.
What it takes off your hands is the installation. Nothing more. The four parts are still there, you just operate them on somebody else's machine. Which is why this section comes after the first one and not before it.
Think of a rented workshop rather than your own basement. You rent time and space at somebody else's bench, the clock runs while you work, and when your time is up you are out. Your only copy is best not left lying there.
Example: the arithmetic behind the free allowance
Two free tiers, two opposite shapes. One of them counts in core hours, and that is the whole point: the provider works it out on its own product page using a two-core machine — and there, half of the monthly allowance survives as real run time. On a machine with twice as many cores it halves again.
The second tier is the inversion: more hours per week, less persistent storage, a hard cap per session and a deletion deadline of 120 days instead of 30. That is not a ranking, it is a choice.
Note
Two free tiers side by side (as of 18 August 2026)
120 core hours per month, which on two cores is 60 hours of run time. 15 GB of storage per month. Once the allowance is used up and no payment method is on file, usage is blocked. A stopped codespace is deleted automatically after at most 30 days without use, even with changes that have not been uploaded yet.
Less time, more storage
50 hours per week by default. 5 GB of persistent storage in the home directory. Sessions end after 12 hours at the latest, unattended ones after 40 minutes. After 120 days without access the home directory is deleted.
More time, less storage
Core hours divided by cores
120 ÷ 4 = 30
Same allowance, four cores instead of two: 60 hours a month become 30. As of 18 August 2026.
The thing to remember is not a number at all but a calculation: divide by the core count. It holds for every provider, including the ones that do not exist yet.
Caution
"So-and-so many hours for free"
The unit is core hours, not hours. One provider's billing page abbreviates it to "hrs" in its table and invites exactly the wrong reading; the same provider's plans page states it precisely. On every free tier, read the unit first and the number second.
"In the cloud I need nothing" is not quite true: you need a browser and an account. And the browser-only editor from the deep dive above is explicitly not an environment — without a terminal and a runtime you can read and edit, but you cannot run anything and cannot check anything.
"Whatever is in the cloud stays there" is even less true. One provider deletes the home directory after the period of inactivity named in the tier box above and states that the files cannot be recovered. The other deletes a stopped codespace after just 30 days without use, changes not yet uploaded included. Once the allowance is exhausted it blocks usage — and, in the same documentation, names exporting your work-in-progress to a branch as the way out.
That is where the analogy breaks, and it breaks in your favour: from a rented workshop you carry the workpiece home, here it moves into a repository that any new workshop can open again. The environment is the perishable part, the repository is what persists — and it lives in a third place, neither in the rented workshop nor in your hands.
What you do NOT need
This section is not an opinion about tools. It is a count.
Example: what the official guides actually require
Take the installation pages of real projects and write down what they list as required. A major web framework carries four points: a runtime in a minimum version, a text editor, a terminal — and, fourth, an add-on tool for the editor that it explicitly only recommends. Three of them are required; the fourth is advice. A second one names two under "System requirements". Git's own book asks for two configuration lines, once per machine. The editor asks for the hardware in the box above.
Now the second count: what appears on none of those lists? A full IDE, a graphical git program, a container runtime, a Linux subsystem as a requirement, a new computer. This list is longer than the first, and everything on it is something somebody added themselves.
The packing list is written by the destination, not by the shop. What you have to take with you is decided by where you are going — not by how well prepared you would like to feel. That is exactly why one page requires three things and the other two: the difference comes from the projects, not from you.
And here is the limit of a packing list: it names the floor, not the ceiling, and it is written per destination. The documented case is the Linux subsystem on Windows. The vendor recommends it under an explicit condition — if your software is going to run on Linux servers, or your tooling is Linux-based. If neither applies, it is an option and not a rite of passage.
Caution
"A professional tool makes me a professional faster"
Start at the lower bound. Every system ships with a notepad that opens text and saves it again; the beginner guidance of one of the largest web documentation projects lets it pass but rates what it can do as thin. The upper bound is the full IDE, and the same source waves that away: at this stage it asks for more operating than it gives back. What it recommends is the middle, a proper code editor. That price does not decide the choice is clear from that source's own example list — Notepad++ (free, Windows only) sits beside Sublime Text (paid). So: one step above the notepad, one step below the full kit.
"I need a new computer" is settled by the box above: the floor documented there sits far below what any device that still boots brings with it today.
"Without a graphical git program I will never understand git" gets it backwards: git's own book records that such programs can do nothing the command line cannot. The one genuinely useful view you already have in the editor.
There is now a category of editors with a built-in agent. For the minimal setup you do not need one: any editor plus a terminal will do.
An open departure
The web documentation behind the beginner guidance above also tells beginners not to worry about version control yet. I depart from that one item, and I would rather say so than quietly trim the source: its advice is written for somebody typing HTML by hand. You work with an agent that changes files you have not read.
The most-used editor costs nothing, privately and commercially, and its source code sits under the permissive MIT licence. The download carrying the brand logo is still a different thing: the same sources, but under the vendor's own product licence.
Free of charge and free are two separate statements here. Anyone who wants the free one takes VSCodium — the freely licensed build from those same sources. What separates a source licence from a product licence is the subject of the open-source article in this learning path.
What now?
Four questions, four parts: where do I read? How do I command? What executes? How do I get back? Three of them you now have as far as you need them for a start.
The fourth has earned a lesson of its own. The cloud provider's way out from earlier — get your work into a branch — only helps if you know what a branch is.
The next article lays the groundwork: the repository and the commit, which every branch builds on.
Note
The essentials in five points
- Four parts, four questions: the editor answers where you read and check. The terminal, how you command and see the result. The runtime, what executes the code. git, how you get back.
- The runtime belongs to the language of the project, not to you. Ask the project, not the tutorial.
- The editor does not contain the other three. It borrows them from your machine — which is why its git buttons stop working when git is missing.
- The cloud spares you the installation, not the four parts. The rented environment is the perishable thing, the repository is what persists.
- Anything that appears on no official requirement list is something you bought yourself.
Check
Understanding check
Can you explain this in your own words? Tick what you've got.
0 of 4 done
Check
Test your knowledge
Which question does the runtime answer in a minimal setup?
Select one answer
1. Which question does the runtime answer in a minimal setup?
2. You are handed a project written in Python. You type no line of code yourself; the agent does that. What do you still need on your machine?
3. Suppose a free tier advertises 100 core hours per month, and you work on a machine with 4 cores. How many real working hours are free for you each month?
4. The version-control buttons in your editor are there, but they do nothing. What is the most likely cause?
5. Two readers stop after four months and come back half a year later. One had installed everything locally, the other had worked exclusively in a rented cloud environment. Who is more likely to find their work still there?