What Is GitHub? Complete History: Octocat to Copilot, AI Agents & the $7.5B Microsoft Era (2026)

GitHub is the home of modern software — the place where more than 150 million developers and over 1 billion repositories live, and the platform Microsoft paid $7.5 billion to own. But it started as a weekend side project written in Ruby on Rails by a handful of San Francisco developers who just wanted an easier way to share code. This is the complete story: from the 2008 founding and the Octocat to GitHub Actions, Copilot, AI coding agents, and what GitHub's arc teaches us about where building software goes next.

TL;DR: GitHub launched in 2008 as a social layer on top of Git, bootstrapped to a ~$2B valuation, and was acquired by Microsoft for $7.5B in 2018. It then evolved from hosting code → collaborating on code (pull requests) → automating code (Actions, 2019) → assisting code (Copilot, 2021) → writing code (AI agents, 2025-26). That same operator-to-director shift is now reaching non-coders through AI app builders. Build a working app from a prompt with Taskade Genesis →

This article is part of our technology-history series alongside the history of OpenAI, the history of Anthropic and Claude, the history of NVIDIA, and the history of computing.

When Was GitHub Founded and Who Owns It in 2026?

GitHub was founded in 2008 by Tom Preston-Werner, Chris Wanstrath, P.J. Hyett, and Scott Chacon, and is owned by Microsoft, which acquired it for $7.5 billion in 2018. It is the largest code-hosting platform in the world, serving more than 150 million developers and over 1 billion repositories as of 2026. What began as a bootstrapped startup is now core infrastructure for the entire software industry.

GitHub at a Glance (2026)

What Is GitHub, Exactly?

GitHub is a cloud platform for storing, sharing, and collaborating on code using Git. Git, created by Linus Torvalds in 2005, is the version-control engine that tracks every change to a project on your own machine. GitHub puts that engine in the cloud and wraps it in collaboration: hosting your repositories, showing changes for review, and adding social features like forking, starring, following, and the now-universal pull request. Git is the engine; GitHub is the garage where teams build together.

The distinction confuses almost everyone at first, so here it is visually:

What made GitHub special wasn't the storage — plenty of services hosted Git. It was the social model of code. By making it trivial to fork someone's project, change it, and send a pull request back, GitHub turned version control into a collaborative network. Open source exploded because contributing went from emailing patches to clicking a button.

The Throughline: Five Eras of GitHub

The whole history rhymes with one pattern. GitHub kept moving the developer up a level — from manually doing the work to directing a system that does it. Hold this diagram in mind; every section below is one step on it.

Each step did the same thing: it took work that used to require deep manual skill and turned it into something you direct rather than do by hand. That arc is the real subject of this article — and by the end, it points somewhere bigger than code. For the broader version of this idea, see what is agentic engineering and our manifesto on why we generate runtime, not code.

The History of GitHub: From Side Project to World's Code

Before GitHub: Git and the Collaboration Gap (2005)

To understand GitHub you have to start with a crisis. In 2005, the Linux kernel project lost free access to BitKeeper, the proprietary tool it used for version control. Linus Torvalds — who'd created Linux itself — took a few weeks and built his own distributed version-control system: Git. It was fast, distributed (every developer had the full history), and brilliant at merging parallel work. It was also famously unfriendly. Git gave the world a powerful engine but no welcoming place to use it together. That gap was the opening.

The Bootstrap Era: A Rails Side Project and the Octocat (2008-2012)

In late 2007, Tom Preston-Werner, Chris Wanstrath, and P.J. Hyett — Ruby developers in the San Francisco scene — started building a site to host Git repositories with a friendly social layer. Scott Chacon (later GitHub's CTO and the author of Pro Git) joined as a co-founder. They built it on Ruby on Rails, opened a private beta in early 2008, and launched publicly on April 10, 2008.

The mascot came almost by accident: GitHub licensed a stock illustration of a cat-octopus hybrid called "Octopuss" by designer Simon Oxley, renamed it the Octocat, and it became one of the most beloved logos in tech.

Here's the part most people miss: GitHub was profitable and bootstrapped for its first four years. It took no venture capital until 2012. Developers paid for private repositories, the product sold itself, and the company grew on its own revenue. By the time investors came calling, GitHub had leverage few startups ever get.

That leverage showed in the raise. In July 2012, Andreessen Horowitz led a $100 million Series A — at the time one of the largest in the firm's history — valuing GitHub at roughly $750 million. In July 2015, Sequoia Capital led a $250 million Series B at about a $2 billion valuation, bringing total outside funding to $350 million.

The Leadership Shake-Up (2014)

GitHub's bootstrap-era idealism collided with growing pains in 2014. After an internal investigation into harassment allegations raised by engineer Julie Ann Horvath, co-founder and CEO Tom Preston-Werner resigned in April 2014. The investigation found no legal wrongdoing but cited mistakes in judgment and handling. Co-founder Chris Wanstrath stepped in as CEO and led GitHub through its enterprise-scaling years and, ultimately, into the Microsoft deal.

Why Did Microsoft Acquire GitHub for $7.5 Billion?

Microsoft acquired GitHub in 2018 to put itself at the center of the developer ecosystem. The deal was announced on June 4, 2018, for $7.5 billion in Microsoft stock, and closed on October 26, 2018. By then, Microsoft — under Satya Nadella's open-source pivot — had become the single most active organization on GitHub, largely through projects like the wildly popular VS Code editor and TypeScript. Buying GitHub wasn't about owning code; it was about owning the place developers already lived.

The acquisition was controversial. Many developers feared Microsoft — historically hostile to open source ("Linux is a cancer," a previous CEO once said) — would ruin GitHub. Nadella's Microsoft was a different company, and it largely kept its promise to run GitHub independently. The skeptics were proven wrong in a way nobody predicted: the acquisition set up the single most important developer product of the next decade, Copilot.

The hindsight that reframes everything: By 2024, Microsoft CEO Satya Nadella said GitHub Copilot's business had grown larger than all of GitHub was worth when Microsoft bought it in 2018. The $7.5 billion that looked expensive became one of the best-timed acquisitions in software — not for the code GitHub hosted, but for the AI distribution channel it became.

Nat Friedman, formerly CEO of Xamarin (a Microsoft subsidiary), became GitHub's CEO on October 29, 2018. His tenure (2018-2021) was the most product-dense in GitHub's history.

Leadership Timeline

How GitHub Became a Platform, Not Just a Host (2011-2021)

GitHub's durability comes from a steady drumbeat of features that turned a code host into an entire developer platform. Each addition gave teams one more reason to never leave. The most consequential, in order:

Two things stand out. First, GitHub Enterprise — the self-hosted edition launched in 2011 — quietly became the business. Large companies that couldn't put code in a public cloud could run GitHub behind their own firewall, and that's where much of the revenue came from. Second, Codespaces (2020) prefigured the AI era: if your entire dev environment lives in the cloud, an AI agent can work in it too. The platform was, without quite saying so, getting ready for agentic engineering.

GitHub Actions: When Code Started Automating Itself (2018-2026)

GitHub Actions, announced in 2018 and made generally available for CI/CD in November 2019, lets you automate any software workflow directly in your repository — building, testing, and deploying code automatically when something happens, like a push or a pull request. It was the moment GitHub stopped being only a place to store and review code and became a place where code tests and ships itself. This is step three of the throughline: automate.

Before Actions, teams bolted on separate CI/CD services (Jenkins, Travis CI, CircleCI). By building automation into the repository itself — triggered by the same events developers already used — GitHub made continuous integration the default, not an add-on. Today Actions powers millions of automated workflows, and a marketplace of reusable Actions means most automation is a few lines of YAML away.

An Insider's View: Scale, Simplicity, and the Rewrite

What does building Actions at GitHub scale actually look like? A rare, grounded answer comes from Bassem Dghaidi, a senior software engineer on the GitHub Actions team, in a 2025 interview on the Beyond Coding podcast. Three of his points cut against everything junior engineers are taught to chase:

• Scale is smaller than you think. "I've built services that handle millions of requests per second running on five or six containers in a tiny Kubernetes cluster." Most teams over-provision for scale they'll never reach.
• Simple is the hard requirement. "Simple is complicated enough, especially at scale. Just write it in the dumbest, most simple way possible." Over-clever abstractions become the thing nobody can safely touch — which is the definition of legacy.
• Design for the next order of magnitude, not 100x. GitHub runs its current architecture to its real limit, gathers data, then rebuilds for the known next step. The famous Actions rewrite wasn't premature optimization; it was a deliberate investment made only once the data demanded it.

That philosophy — exhaust the simple thing before you complicate it — is the same instinct behind the best modern tools. It's why we believe in generating runtime instead of code and in reliable, durable automation workflows that you describe rather than hand-wire. We unpack the full set of lessons from that interview in our breakdown of what the best software engineers do differently.

GitHub Copilot: From Autocomplete to Autonomous Agents (2021-2026)

GitHub Copilot is an AI pair programmer that launched in technical preview in June 2021 and became generally available in June 2022. Originally built on OpenAI Codex, it suggests code completions and entire functions inside your editor. By 2026 it has more than 20 million users, generates roughly 46% of its users' code on average (up from 27% in 2022), and has expanded into chat and autonomous agents. This is step four of the throughline: assist.

Copilot landed like a thunderclap. For the first time, the editor finished your thought — a whole function from a comment, a test from a signature, boilerplate from a single line. It also kicked off hard questions about copyright (more below) and about what coding even is when the machine writes most of it.

The Copilot Evolution

A critical shift happened along the way: Copilot became multi-model. What started as a single OpenAI-powered product opened up to route across OpenAI, Anthropic Claude, and Google models — an acknowledgement that no single model is best at everything. (Taskade Genesis took the same view from the start, with 15+ frontier models from OpenAI, Anthropic, Google, and open-weight providers under one roof. For the broader landscape, see the best Claude Code alternatives and GitHub Copilot alternatives.)

By the numbers, Copilot's adoption is staggering:

The AI-Engineering Transition: When 90% of Code Is Written by Agents

The biggest change in GitHub's recent history isn't a product — it's a shift in who writes the code. Autocomplete (2021) became chat (2023) became agents (2025-2026) that complete whole tasks: read the codebase, plan a change across many files, write and run the tests, read the errors, fix them, and open a pull request for a human to review. This is step five: write. The developer moves from operator (typing every line) to director (describing intent and reviewing the result).

How far has it gone? Consider the GitHub engineer we met earlier. On the Beyond Coding podcast, Bassem Dghaidi said roughly 90% of his code is now written by AI agents — and he ships it to production, using agent mode daily. His point wasn't that judgment disappears; it's that judgment moves up the stack. Instead of syntax and structure, his attention goes to the spec, the security implications, and operational correctness. The agent writes; the engineer directs and verifies.

Independent measurements back up the trend without the hype. The most rigorous large-scale study found that about 27% of all production code was AI-authored in late 2025 — not 90% across the industry, but a remarkable share for a capability that barely existed in 2021. The honest read: AI-assisted and AI-authored are different numbers, and the truth sits between the breathless claims and the skeptics. Either way, the direction is unmistakable. We tracked the whole movement in the state of vibe coding, what is agentic engineering, and the taxonomy of AI agents vs. copilots vs. chatbots.

GitHub by the Numbers (2026)

GitHub's scale is the clearest measure of how it won. From 3 million users in 2013 to 150 million in 2025, and from a few million repositories to over a billion, its growth curve is one of the steepest in software history.

Milestone Timeline

The pull request — GitHub's signature invention — is worth seeing as a flow, because it's the ritual that made collaborative software at planetary scale possible:

GitHub Controversies: A Balanced View

No platform this central is without friction. A complete history has to include the hard parts:

• ICE contract protests (2019). Employees protested GitHub's services being available to U.S. Immigration and Customs Enforcement through a reseller. Engineer Sophie Haskins resigned in October 2019, and an open letter circulated internally. Leadership called the contract immaterial and declined to cancel it, drawing sustained criticism.
• master → main (2020). On October 1, 2020, GitHub changed the default branch name for new repositories from "master" to "main," part of a broader industry move away from master/slave terminology. Existing repos were unaffected; the change was praised by many and dismissed as symbolic by others.
• Copilot copyright litigation (2022-present). A class action filed in November 2022 against GitHub, Microsoft, and OpenAI alleged Copilot reproduced licensed code without attribution. Copilot was trained on 54 million public repositories. Some claims were dismissed; the core questions about training on public code and fair use remain unresolved and shape AI policy industry-wide.
• 2023 layoffs. GitHub cut about 10% of staff (~300 roles) in February 2023 and shifted to fully remote, including eliminating its India-based engineering team.

These aren't footnotes — they're the negotiations a platform makes as it becomes infrastructure. They're part of why the platform is trusted to host a billion repositories, and part of why scrutiny of it matters.

GitHub vs GitLab vs Bitbucket

GitHub isn't the only Git platform, and a fair history says so. The three big hosts split along clear lines:

GitHub leads on reach, ecosystem, and AI. GitLab is the choice when you want the entire pipeline in one self-hostable application. Bitbucket makes most sense inside the Atlassian world. There's no universal winner — only the right fit for your team and constraints.

What GitHub's History Teaches Us About the Future of Building

GitHub's whole arc is one move repeated: take work that required deep manual skill and turn it into something you direct. Host → collaborate → automate → assist → write. Each step pulled the developer up a level of abstraction and let more people build more software, faster. The natural question is: where does that line point next? It points past code — to letting anyone build working software by describing what they want.

That's not speculation; it's the data. According to Gartner, the low-code/no-code market will reach roughly $44.5 billion in 2026, and 75% of new enterprise applications will be built with low-code technologies by 2026 — with 80% of those builders coming from outside traditional IT. The operator-to-director shift that hit professional developers via Copilot is now reaching everyone else.

Here's the clean way to think about it: GitHub handles your code; Taskade Genesis handles the rest of your team's work — and the software you'd otherwise need a developer to build. They're not competitors; they're two ends of the same democratization. If you write code, GitHub is irreplaceable. If you have an idea and don't write code, you no longer have to wait for someone who does.

GitHub vs. Taskade Genesis: Two Layers of Building

Not sure which layer you're on? This decision tree settles it in one read:

                    What do you want to do?
                              │
        ┌─────────────────────┴─────────────────────┐
   Write & host code                       Build a working app / tool
   (you are a developer)                   (you have an idea, not a codebase)
        │                                           │
   ┌────┴─────┐                              ┌───────┴────────┐
 Solo /     Team with                   Need agents,        Just need
 open src   CI/CD + review              automations &       a place to
   │           │                        a database?         store text?
 GitHub     GitHub +                         │                  │
 (free)     Actions + Copilot         ▶ Taskade Genesis     GitHub works,
                                       (prompt → live app)   but a workspace
                                                              is friendlier

Taskade Genesis is an AI app builder where you describe what you want and get a working app — with built-in AI agents, databases, and automations — no Git, hosting, or deployment to wire up. It's powered by 15+ frontier models, 33 built-in tools, and 100+ bidirectional integrations (triggers pull events in, actions push data out), wrapped in Workspace DNA: Memory + Intelligence + Execution — the loop where your workspace remembers, decides, and acts so the next build is smarter than the last.

Build a Living GitHub Release Tracker in Taskade Genesis

Want to feel the operator-to-director shift yourself? Here's a prompt that takes about two minutes — no code:

Build me a developer dashboard app that:
- tracks GitHub repos, open pull requests, and CI status across my team
- has an AI agent that summarizes new issues every morning and tags priority
- automates a weekly digest of merged PRs to our Slack channel
- shows a board view for triage and a calendar view for release dates

Taskade Genesis turns that prompt into a working app with the right project views, an embedded agent, and live automations — the kind of internal tool a team would normally file a ticket and wait weeks for. Explore real examples in the Community Gallery, or compare approaches in Taskade Genesis vs. Cursor and Claude Code vs. Cursor vs. Taskade Genesis.

The bottom line: GitHub spent 18 years pulling developers up the ladder of abstraction — from hosting code to directing agents that write it. The next rung extends that climb to everyone. Developers keep GitHub for code; everyone gets a way to build the software around it. Start building free with Taskade Genesis →

Related Reading

• What Is OpenAI? The Complete History — the company behind Codex, which first powered Copilot
• The History of Anthropic & Claude — the model family now inside Copilot and Taskade Genesis
• What Is Anysphere? The History of Cursor — the AI editor reshaping how code gets written
• The History of NVIDIA & Jensen Huang — the hardware powering the AI coding era
• What Is Agentic Engineering? — the discipline behind AI that writes code
• Best Claude Code Alternatives & Best GitHub Copilot Alternatives — the AI coding tool landscape
• The State of Vibe Coding — market data on AI-built software
• They Generate Code, We Generate Runtime — the Taskade Genesis manifesto
• The History of Mermaid Diagrams — the docs-as-code tool with 85K GitHub stars
• The Ultimate Guide to Taskade Genesis — build your first app

Sources & Further Reading

• GitHub Blog — official announcements (launch, Copilot, 100M developers, leadership): github.blog
• Microsoft News — Microsoft to acquire GitHub for $7.5 billion (June 4, 2018): news.microsoft.com
• Wikipedia — GitHub and Timeline of GitHub
• TechCrunch — funding rounds and acquisition reporting (2012 Series A, 2015 Series B)

Frequently Asked Questions