VS Code

Most initial commits in this newsletter are small. A README. A handful of C files. A single .gitmodules. The first commit of a project is usually a seed: something you could fit on a napkin.

This week's commit is 704,173 lines across 300 files, and it is titled "Hello Code."

This is not a seed. This is a forest that was planted somewhere else and then transplanted, fully grown, into public view.

1. Three hundred files, no origin

You open the commit on GitHub and scroll. And scroll. .vscode/launch.json. build/gulpfile.js. build/lib/bundle.ts (397 lines). build/lib/typescript/typescriptServices.js (44,323 lines, committed as a single file). ThirdPartyNotices.txt (1,488 lines). Layout systems, language services, extension hosts, renderer workers, Monaco editor internals. A debugger protocol. A terminal. A full tree of src/vs/ (Visual Studio's internal shorthand) containing everything that would ship as the first public release of the product.

The diff is so large that GitHub refuses to render most of it inline. It is not a "project starting." It is a product arriving.

In October 2015, Microsoft open-sourced a code editor that had already been in development for years under the internal name "Monaco." It had shipped as a closed-source web app inside Visual Studio Online. It had a team, a roadmap, and a design language. In November 2015, three weeks after the public announcement, someone at Microsoft ran what must have been an exhausting scrubbing-and-exporting process and pushed the result into a public GitHub repo.

The result of that process is this commit.

2. Who typed it in

The author line is worth staring at for a moment:

Author: Erich Gamma

There are people whose names you recognize from history books. Erich Gamma's name appears in three of those history books, and he wrote two of them.

• In 1994, he co-authored Design Patterns: Elements of Reusable Object-Oriented Software, the "Gang of Four" book, which gave a generation of programmers a shared vocabulary for how object-oriented systems fit together. If you have ever heard someone say "Observer," "Singleton," "Factory," or "Decorator" in a sentence about software, Erich Gamma is partly responsible.

• In the late 1990s, he co-created JUnit with Kent Beck: the unit testing framework that popularized automated testing for Java and inspired essentially every "xUnit" framework that exists today.

• In the 2000s, he was one of the lead architects of Eclipse, the open-source IDE that dominated Java development for most of a decade.

• And in the 2010s, at Microsoft, he led the team that built Monaco, which became Visual Studio Code.

The first commit of VS Code was made by a person who has now been responsible for a foundational piece of developer tooling in every decade since the 1990s. Design patterns. Testing frameworks. IDEs. Code editors. He keeps quietly showing up at the root of the thing you already depend on.

3. "Hello Code"

The commit message, "Hello Code", is a two-word pun. It is "hello world" with the product name substituted in. It is the minimum possible greeting. It is also unusually humble for a commit that contains 700,000 lines and represents years of work by a large team at one of the richest companies in the world.

There is something fitting about it. Erich Gamma's entire career is a long argument that software is a craft, that conventions matter, that good tools help people do good work. "Hello Code" is the kind of commit message a craftsman writes when the product is the statement, not the commit.

It is also, arguably, an invitation. VS Code was open-sourced partly as a bet: that Microsoft could win the long-term loyalty of developers by giving them a genuinely great editor for free, in public, with extensions and telemetry and all. In 2015, it was not obvious that the bet would pay off. Sublime Text was entrenched. Atom was the new darling. Visual Studio the product was seen as a Windows-only artifact.

Ten years later, VS Code is the most widely used code editor on earth, and the derivatives built on top of it (Cursor, Windsurf, everything that begins life by forking microsoft/vscode) are reshaping how software gets written. "Hello Code" was the opening line of that story.

4. The strange genre of the dump-commit

Kubernetes has one of these, too. So does React. So do a lot of projects that begin their public life as an export from a private codebase. The "dump-commit" is a specific genre of initial commit: enormous, meticulous, opaque. It contains a fully-formed product with no visible evolution. It has the vibes of a ship launching with a crew already aboard, rather than a hull being laid down.

These commits are frustrating to read, because the interesting history is not in the git log: the arguments, the rewrites, the wrong turns, the fights over how to name the thing. It happened before, in a different repository, which was probably deleted. What you see in git log --reverse is the cleanup.

But they are also, in their own way, honest about what the project actually is. VS Code is not a thing that grew up in public. It is a thing that was built in private, judged ready, and then released. That is a legitimate way to make software. Sometimes it is the only way. The "Hello Code" commit is that philosophy at full scale.

5. The file that made me laugh

Buried in the 300 files is this one:

build/lib/typescript/typescriptServices.js    44,323 lines

That is the TypeScript compiler, bundled into a single JavaScript file, checked directly into the repo, and committed as part of the initial commit. In 2015, the idea of depending on TypeScript via npm and pinning a version was apparently less appealing to the Monaco team than just committing the whole compiler. It is a reminder that even the most professional teams sometimes solve problems by saying "you know what, let's just vendor 44,000 lines of JavaScript and move on."

Monaco would go on to ship its own TypeScript language service inside the editor, which is part of why VS Code's TypeScript support is uniquely good. That story, too, starts in this commit.

6. Footnotes from the commit log

• The commit is not the true first commit of the Monaco/VS Code codebase. The actual first commit is somewhere in a Microsoft-internal repository, which is not public, and probably never will be.
• "Monaco" is still in the source tree today. If you grep VS Code for monaco, you will find the editor component at the heart of it, still using the internal name. Every VS Code-derived editor (Cursor, Windsurf, GitHub Codespaces, StackBlitz, etc.) uses the Monaco component, directly or indirectly.
• Erich Gamma's Microsoft office was in Zurich, not Redmond. The VS Code team was run out of a European Microsoft lab for most of its first years.
• The commit's 300 files include .vscode/launch.json and .vscode/settings.json, meaning VS Code was, from its first public commit, being developed in VS Code. A small bootstrap miracle that mirrors the one in the git issue.