A field guide to thirty years
of jargon.

In 1994, fewer than 1% of the world's population had used the internet. By 2004, search engines, online stores, and email had become load-bearing infrastructure for the global economy. The decade between was one of invention, fortune, ruin, and hard lessons.

The Web Era began when Netscape packaged the World Wide Web for ordinary users. Mosaic, then Netscape Navigator, gave people a way to browse hypertext. The 1995 IPO opened at $28 and closed at $58.25 — a company with no profits and no precedent. Wall Street had found the internet, and the dot-com bubble had started.

What followed was a decade of real and imagined opportunity in roughly equal measure. Amazon sold its first book in 1995. eBay sold its first broken laser pointer in 1995. Google was incorporated in 1998. Pets.com raised $300M and was dead within nine months. By 2001, the NASDAQ had lost 78% of its value. The survivors — Amazon, eBay, Google, Yahoo — came out leaner, having established that revenue eventually had to come from somewhere.

By 2004, the foundations were in place: HTTP, HTML, JavaScript, SaaS pricing, API-driven integrations, and an entire generation of consumers who expected to buy, read, search, and communicate online. Everything after — cloud, mobile, social, AI — was built on the infrastructure this era laid down.

• Commerce moved online. Brick-and-mortar stopped being the default; a web presence became a board-level question. Catalog businesses, travel agents, video rental, and classified ads were the first to be unbundled — most never returned.
• A new financing model emerged. Venture capital scaled up to chase software returns. The idea that a five-person team could build a global business became investable. Stock options as primary compensation became standard.
• The internet became infrastructure. By 2004, having a website stopped being a differentiator. The next questions — how fast to iterate, how cheaply to scale, how teams could ship without breaking everything — drove the next three eras.

For most of the 1990s, building software meant writing a specification document, handing it to engineers, and waiting twelve to eighteen months for delivery. The result was usually late, over budget, and a poor match for what the business needed by the time it arrived.

In February 2001, seventeen software developers gathered at a ski resort in Snowbird, Utah. They produced a one-page document — the Agile Manifesto — that would reshape how software gets built. The core ideas were straightforward: work in short cycles, ship working software frequently, talk to the customer continuously, be willing to change direction.

The Manifesto's signatories — Kent Beck, Ward Cunningham, Martin Fowler, Jeff Sutherland, Ken Schwaber, among others — each went on to develop specific practices: Scrum, Extreme Programming, test-driven development, pair programming. Each addressed the same underlying problem from a different angle.

By 2012, Agile had become the default. Fortune 500 companies were running standups. Project managers had become Product Owners. Job ads required Scrum certification. The Manifesto's authors expressed some ambivalence — they had wanted a culture change, and what arrived was a consulting industry. But the core shift was real: software stopped being a multi-year procurement and became a continuous, iterative practice.

• Software became a continuous practice, not a project. Budgets, contracts, and org structures had to adapt. 'When will it be done?' was replaced with 'what are we shipping next sprint?' — and finance departments had to learn to work with that.
• The product manager role expanded significantly. Someone had to translate business goals into a prioritized backlog and answer hundreds of small questions per week. The modern Product Owner profession was built inside Agile teams.
• The era also produced its own failure modes. Scrum theater — teams running the ceremonies without the underlying culture — became common. Many Agile transformations were rebrands. The core idea, that software is built better in small iterative chunks with continuous feedback, held. The ceremonies were easier to copy than the discipline.

Before 2006, running a software business meant buying physical servers. You estimated peak load, ordered hardware on six-week lead times, found rackspace in a colocation facility, paid for redundant power and cooling, and hired sysadmins to keep it running. A failed startup's last meaningful asset was usually its servers.

Amazon had a specific problem: its retail business had seasonal traffic spikes and needed enough server capacity to handle them. For most of the year, that capacity sat idle. In 2003, Andy Jassy and a small team designed a business that would rent that idle capacity to outside developers by the hour, with a credit card.

Amazon Web Services launched S3 (storage) in March 2006 and EC2 (compute) in August. The pricing was simple: a few cents per gigabyte per month, a few cents per CPU-hour. Within months, most cash-strapped startups in Silicon Valley had moved their infrastructure to AWS. Hardware vendors dismissed it. By 2010, IBM, Microsoft, and Google were building competing offerings.

The economic shift was significant. Companies that had treated computing as capital expenditure began treating it as an operating cost. The minimum viable startup dropped from $5M of server purchases to a $50 AWS bill. By 2014, AWS was a $5B business growing 50% annually. Microsoft Azure and Google Cloud had emerged as credible alternatives. Running in the cloud had become the default.

• The cost of starting a software company dropped. Where the 1999 startup needed $5M of servers, the 2009 startup needed an AWS account and a credit card. This made viable a range of businesses that would not have been fundable a decade earlier.
• IT spending shifted from CapEx to OpEx. CFOs stopped depreciating server purchases over five years and started paying monthly usage bills. This made spending more flexible — and introduced cloud overspend as a new category of corporate financial exposure.
• The cloud also concentrated vendor risk. By 2024, three companies — AWS, Azure, and GCP — accounted for roughly 65% of global cloud infrastructure. Sovereignty, lock-in, and concentration became board-level concerns.

By the late 2000s, Agile had delivered on its core promise: software teams could ship faster. But a new problem appeared. The faster developers shipped, the more they strained the operations teams responsible for running the software. Ops was still doing manual deployments at 2 AM, absorbing code that worked in development and broke in production.

The cultural divide was concrete. Developers were measured on velocity — shipping features. Operations was measured on uptime — not breaking things. Their incentives were directly opposed. Outages produced finger-pointing. 'It works on my machine' was the developer's standard response; 'you threw it over the wall' was the ops team's.

In 2009, a Belgian engineer named Patrick Debois organized the first DevOpsDays in Ghent. The premise was straightforward: what if developers and operations weren't separate functions but the same team, with shared responsibility for code in production? The idea spread through conferences, blog posts, and the 2013 novel The Phoenix Project, which gave executives a narrative to work with.

The technical practices followed the cultural shift. Continuous Integration and Continuous Delivery automated the build-and-deploy pipeline. Infrastructure as Code — Terraform, CloudFormation — made servers reproducible from version-controlled files. Monitoring became Observability. By 2016, Google had published its internal practice as Site Reliability Engineering, and DevOps had become a standard expectation in technical hiring worldwide.

• Deployment frequency shifted from quarterly releases to multiple times per day. Organizations that mastered this — Amazon, Netflix, Google — moved faster than competitors still running 6-month release cycles. The competitive value of shipping speed became measurable.
• The boundary between writing software and running software dissolved. The modern engineer is expected to own code in production, respond to incidents, and care about reliability. The traditional sysadmin role was largely replaced by SREs, platform engineers, and DevOps practitioners.
• The era also generated its own failure modes. 'DevOps team' became a misnomer: DevOps was meant to be a culture, not a department. Many transformations amounted to renaming the ops group. The harder work of shared on-call, shared ownership, and a blameless culture was the part most organizations never finished.

By 2013, virtualization was standard — every cloud server was a virtual machine sharing physical hardware. But VMs were heavy. Spinning one up took minutes. Each carried a full operating system. Running ten microservices meant ten full VMs, with all their overhead and patching and resource waste.

At a small French PaaS company called dotCloud, a developer named Solomon Hykes had been building an internal tool: a way to package an application and its dependencies into a lightweight, portable unit. In March 2013, dotCloud open-sourced it as Docker. Within months it was one of the fastest-growing open-source projects in history. dotCloud pivoted entirely and renamed itself Docker, Inc.

Docker solved the persistent 'it works on my machine' problem. The application, its dependencies, and its runtime were packaged into a container — a self-contained, shippable unit that ran identically on a developer's laptop, a CI server, or in production. Within two years, most serious engineering teams were building new software with it.

But containers alone weren't enough. Running hundreds of them across a fleet of servers required orchestration: scheduling, scaling, networking, health checks, secrets management. Google had been running everything internally on a system called Borg for over a decade. In 2014 it open-sourced a rewrite called Kubernetes. By 2018, Kubernetes had won the orchestration war so decisively that competitors like Docker Swarm and Apache Mesos conceded. The CNCF (Cloud Native Computing Foundation) emerged as the steward of the ecosystem. The cloud had a new operating system, and it ran in containers.

• Software became portable. The same artifact that ran on a developer's laptop ran in production. The 'works on my machine' excuse became a professional embarrassment. Onboarding new engineers went from days to hours.
• The microservices architecture became viable at scale. Without container orchestration, running 50 independently-deployed services was a tangle of port management and dependency conflicts. Kubernetes made it operationally tractable — and a new generation of architects adopted it, sometimes before they needed to.
• A new operational complexity followed. Kubernetes is capable and steep. Entire job categories (Platform Engineer, Cloud Native Engineer, DevOps SRE) emerged to manage it. By 2020, the conversation had shifted to keeping Kubernetes out of developers' way, and that question seeded the next era.

By 2010, the cloud had made storing data nearly free, the web had made generating data effortless, and businesses had far more information than they could analyze. The old approach — load it into a relational database, query with SQL, build a dashboard in Crystal Reports — broke at internet scale. The 2010s were the decade of figuring out what to do about it.

The first wave was Big Data, dominated by Hadoop and MapReduce. Yahoo and Facebook had pioneered batch-processing frameworks for analyzing petabytes of logs. Companies like Cloudera and Hortonworks raised hundreds of millions selling Hadoop distributions to enterprises that wanted to be data-driven. Most of those enterprises spent millions standing up clusters and got limited business value back. By 2018, 'Big Data' had become a dated phrase.

The second wave was the modern data stack. Snowflake (founded 2012) reimagined the data warehouse as a cloud-native service that separated storage from compute. Any company could load its data into a queryable warehouse for a manageable monthly bill. dbt let analysts transform data with SQL and Git. Fivetran and Stitch automated the ELT work. By 2020, a startup could stand up a modern analytics stack in a weekend.

The third wave, streaming and real-time, was driven by Apache Kafka. Built at LinkedIn in 2011 and open-sourced shortly after, Kafka let companies move data between systems in real time. The team behind it spun out Confluent. By 2022, every fintech, marketplace, and IoT company was running on Kafka or an alternative. The era ended with companies sitting on more data, in more places, with more tooling, and still no reliable answer to the original question of how to extract value from it.

• Storing data became effectively free. Analyzing it became affordable. This enabled a generation of products built on data by default — recommendation engines, dynamic pricing, fraud detection, supply chain optimization — and made a dedicated data team a fixture in mid-sized companies.
• A new job category emerged: the analytics engineer. Sitting between data engineers who build pipelines and analysts who answer questions, they own transformations in dbt, document metrics, and bridge raw data and business intelligence. By 2022 it was one of the most in-demand roles in tech.
• The era also surfaced an uncomfortable fact: most companies still couldn't reliably answer basic business questions. Data quality, governance, and discoverability remained largely unsolved. By 2022 the conversation had shifted from 'do you have data?' to 'can you trust it?' — and the answer was often no.

By 2019, the cloud-native promise had been delivered, and the bill had arrived. A typical mid-sized engineering organization ran 30+ different SaaS tools, used 5+ programming languages, deployed on Kubernetes, monitored with Datadog, alerted via PagerDuty, secured by Snyk, scanned by SonarQube, and shipped through GitHub Actions. Developer onboarding took weeks. A significant share of engineering time went to managing tooling rather than building product.

The response was Platform Engineering — building an internal platform that abstracted the underlying complexity and gave developers a self-service path to ship code. Spotify's open-source Backstage (released 2020) became the reference implementation. Gartner named Platform Engineering a top strategic trend in 2022. The DevOps Engineer role began to split into Platform Engineer (builds the platform) and Application Engineer (uses it).

Meanwhile, security failures kept accumulating. SolarWinds (2020) compromised 18,000 organizations through a poisoned software update. Colonial Pipeline (2021) shut down US East Coast fuel supply for six days after a ransomware attack. Log4Shell (December 2021) exposed a vulnerability in a logging library used in millions of Java applications. The software supply chain had become the attack surface, and the industry responded with SBOMs (Software Bills of Materials), SLSA (Supply-chain Levels for Software Artifacts), and an expanding DevSecOps tooling category.

Cloud costs followed a similar arc. By 2023, the average company was estimated to be wasting 30–35% of its cloud spend. FinOps (bringing engineering and finance together to manage cloud bills) emerged as a recognized discipline with a foundation, a certification program, and CFO-level attention. The era closed with a shared understanding: at scale, security, cost, reliability, and developer experience each need dedicated engineering investment.

• Security shifted left. Vulnerability scanning, secret detection, and SBOM generation became part of the CI pipeline rather than a pre-release gate. Developers now own first-line security responsibility, and tooling has had to follow.
• Cloud cost became a first-class engineering concern. CFOs got dashboards. Engineers got budget alerts. 'How much does this feature cost to run?' became a routine design question — especially for AI workloads where unit economics are unforgiving.
• Developer-experience investment matured. The recognition that engineer time is the most expensive resource — not compute, not licenses — drove investment in internal platforms, fast feedback loops, and friction reduction. The companies that did this well shipped faster; the ones that didn't lost engineers.

In September 2012, a neural network called AlexNet, trained on the ImageNet dataset using two consumer GPUs in a University of Toronto basement, achieved a top-5 error rate of 15.3% on image classification. The previous year's winner had scored 25.8%. The gap was large enough to trigger an immediate reassessment of what neural networks could do. Three of the researchers — Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton — were hired by Google within months.

What followed was a decade of measurable breakthroughs. Image recognition surpassed human performance by 2015. Speech recognition followed by 2016. Machine translation changed with Google's Neural Machine Translation in 2016. In March 2016, DeepMind's AlphaGo beat Lee Sedol, the world Go champion, 4-1. In June 2017, eight Google researchers published 'Attention Is All You Need,' introducing the Transformer architecture. The AI research community noticed; most of the industry did not.

The corporate response was large and fast. Google, Facebook, Microsoft, Amazon, and Apple acquired AI startups and poached university ML faculties. NVIDIA, primarily a GPU company for video games, found its hardware at the center of AI training workloads. Its stock began a multi-year climb that would make it one of the most valuable public companies on Earth by 2024.

For most of the 2010s, AI remained narrow. Each model did one task. A model trained to recognize cats could not recognize dogs. A translation model for French to English needed a separate model for Spanish. The work was specialized, expensive, and required ML engineers and researchers with deep domain knowledge. Deployments underdelivered against expectations more often than not. The Transformer paper changed the trajectory, but that would not be apparent for another five years.

• AI moved from research to embedded production infrastructure. By 2020, most major consumer products had AI components: recommendation engines, fraud detection, ad targeting, search ranking, spam filtering. Users did not interact with these systems directly; they just ran. Companies that invested early had measurable advantages; those that did not fell behind on specific capabilities.
• A new economic logic formed around AI. Data became valuable as training material. Compute became a strategic asset — Google built custom TPUs; others accumulated NVIDIA GPUs. AI engineering roles commanded compensation that detached from the broader tech market.
• The era ended in a particular state: the technology had delivered real, narrow results, but general-purpose AI had not arrived. Self-driving cars remained unresolved. Enterprise ML projects underdelivered more often than not. Then the Transformer architecture — published in 2017, mostly unnoticed outside research — produced ChatGPT, and the terms of the conversation changed.

On November 30, 2022, OpenAI released a chatbot called ChatGPT. Internally it was considered a modest research preview, built on GPT-3.5. The team did not expect wide adoption. By January 2023, ChatGPT had 100 million users — the fastest consumer product growth on record. Microsoft, an existing OpenAI investor, announced an additional $10 billion investment. The product had made the underlying technology legible to a general audience.

What ChatGPT did was straightforward: it placed a chat interface on top of a large language model trained on internet-scale text using the Transformer architecture. The technology had existed in earlier forms. The difference was access — anyone with a browser could use it without an API key or Python knowledge. People used it for email, code, essays, research, homework, and a large number of tasks no product designer had anticipated.

The competitive response was fast. Google declared an internal 'code red' and shipped Bard (later Gemini) in early 2023. Anthropic, founded by former OpenAI researchers in 2021, released Claude. Meta open-sourced Llama in early 2023; the model weights leaked to the internet within days, producing an unplanned but consequential open-source LLM ecosystem. Microsoft embedded GPT-4 into Bing, Office, and Windows under the Copilot brand. By mid-2023, most significant software companies had announced an AI strategy — ranging from vague to operational.

Within two years, a production stack had formed: foundation models accessed via API, augmented with company-specific data through RAG, constrained via system prompts, and monitored through observability tooling built specifically for LLMs. The cost structure became apparent and was not trivial. Tokens were the new compute unit. Organizations that had spent years optimizing cloud spend found themselves doing the same exercise for AI API budgets. By the end of 2024, the question had shifted from 'what can the model do?' to 'what can it do, with our data, automatically, at acceptable cost?' The Agentic Era was starting.

• Software development changed in practice, not just in theory. GitHub Copilot, ChatGPT, Claude, and Cursor became standard tools for engineers. By 2024, most professional developers used AI assistance daily. 'Vibe coding' — describing what you want and accepting AI-generated output — moved from joke to common practice.
• Content production economics changed materially. The marginal cost of producing a passable blog post, image, or video dropped close to zero. Industries built around premium commodity content production faced rapid compression.
• The labor question became practical. Knowledge work — paralegal research, customer service, data analysis, first-draft writing, code generation — became subject to AI augmentation or replacement in ways that were measurable and immediate. Every white-collar organization began auditing which workflows could be restructured around AI. The answer was more than expected but slower and messier than the hype suggested.

Through 2023, an LLM was something you queried. You submitted a prompt; it returned text. Real work — sending the email, executing the code, querying the database — remained the user's job. By 2024, models started doing those things directly, enabled by structured tool-use interfaces that let models call functions, browse the web, run code, and interact with external systems.

The tooling followed the capability. Anthropic released Claude Code — an agentic command-line tool — in early 2025. Cursor and Windsurf embedded LLMs into development environments in ways that went beyond autocomplete. Cognition Labs launched Devin in March 2024, billed as an autonomous software engineer. In late 2024, Anthropic published the Model Context Protocol (MCP), an open standard for connecting AI models to tools, databases, and services. Within months, every major AI vendor had implemented MCP support.

The economic consequences became concrete. Agentic workflows consume 5–10 times more tokens than simple LLM queries. Token costs, manageable in the GenAI era, became a P&L line item requiring active governance. FinOps teams that had spent years optimizing cloud spend applied the same discipline to AI API budgets. A new category — 'tokenomics' — named the problem.

By 2026, the operational questions had become unavoidable: which workflows have been redesigned around agents, what oversight exists at each step, and what happens when an agent acts incorrectly. A hallucinated paragraph is a quality issue. A hallucinated action — a deleted record, a sent email, an unauthorized API call — is a different category of problem. Human-in-the-loop controls and agent audit trails moved from optional to organizational policy at enterprises that had moved quickly in 2023 and 2024.

• The unit of work is shifting from task to outcome. Instead of prompting AI to draft a paragraph, you direct it to research and book a flight — the searching, comparing, and (sometimes) transacting happen within the agent loop. This compresses multi-step workflows into single requests, and raises the operational stakes when the agent makes an error.
• Software development is reorganizing around AI agents. Code review, refactoring, dependency upgrades, and feature implementation are increasingly delegated. Senior engineers spend more time orchestrating, reviewing, and setting architectural direction; less time writing code line by line. Junior roles are in flux in ways that have not yet resolved.
• New disciplines are maturing: prompt engineering evolved into context engineering, which is evolving into agent design. Tokenomics applies financial governance to AI API spend. Agent observability is its own product category. The open question for the rest of the decade is not whether AI agents are operational — they are — but how organizations restructure workflows, governance, and accountability around systems that can act autonomously.