From VisiCalc to Spreadsheet-of-Thought: 47 Years of Giving Non-Engineers Power (2026)

TL;DR: In October 1979, Dan Bricklin and Bob Frankston shipped VisiCalc on the Apple II and invented the most democratizing piece of software in history. Over 47 years, six major generations — VisiCalc → Lotus → Excel → Sheets → Airtable → Notion — each added one new primitive to the grid. Taskade Genesis is the next generation. The new primitive is reasoning. Call it the spreadsheet of thought. Build in it →

Who Invented the Spreadsheet, and Why Did It Democratize Computing?

There are roughly 30 million professional software developers in the world.

There are roughly one billion people who use spreadsheets.

This ratio is the most important statistic in the history of computing, and almost nobody talks about it. Every decade the tech industry gets excited about the next "no-code revolution" or "citizen developer movement." The revolution already happened. It happened in October 1979. The citizen developers have been among us for 47 years. They just call themselves accountants, analysts, scientists, teachers, planners, administrators, and — as I was for a significant part of my youth — kids running small businesses from their parents' basements.

The revolution was a program called VisiCalc, written by Bob Frankston in assembly language for the Apple II, based on a concept sketched by his friend Dan Bricklin at Harvard Business School. The program showed up on store shelves in the fall of 1979 at a price of $100 — a significant fraction of the cost of the computer you needed to run it. It sold slowly at first. Then, quietly, it began driving Apple II sales all by itself. Business users bought Apple IIs because they needed to run VisiCalc. Steve Jobs later said that VisiCalc propelled the Apple II to the success it achieved.

In the 47 years since, the spreadsheet has evolved through five major generations. Each generation added exactly one new primitive, and each primitive unlocked a new class of work for people who do not write code.

We are now in the sixth generation. The new primitive is reasoning. This is a story about the arc, because the arc tells you where Taskade Genesis fits.

The Six Generations

Each generation did not replace the previous one. Excel has 1.1 billion users in 2026. Google Sheets has hundreds of millions. Airtable, Notion, and now Taskade Genesis each occupy a distinct layer on top of the grid. The grid itself — rows, columns, cells, formulas — is the most durable interface in consumer software history. It is what computers look like to a billion people, and it has looked this way since 1979.

What changes generation to generation is what can live in a cell.

Generation 1: VisiCalc (1979)

The original insight, and still the most important one: a cell can contain a formula that references other cells, and when the referenced cells change, the formula recomputes automatically.

This sounds trivial in 2026. In 1979 it was a revelation. Before VisiCalc, financial analysts did what-if scenarios with paper ledgers, erasers, and a lot of manual arithmetic. Changing one assumption meant redoing hundreds of cells by hand. VisiCalc made every change instant.

Bricklin's original sketch of the interface — the one he drew at Harvard — was a grid with cells that could contain numbers or formulas, and formulas that could reference other cells. That is it. That is the entire invention. Every subsequent spreadsheet is a footnote to that sketch.

The primitive: the live cell.

VisiCalc Cell (1979)

  ┌──────────────────────────────────────┐
  │   A1: 100                            │
  │   A2: 150                            │
  │   A3: =A1 + A2  →  250               │
  │   A4: =A3 * 1.1  →  275              │
  │                                      │
  │   Change A1, everything recomputes.  │
  │   That's the whole magic.            │
  └──────────────────────────────────────┘

What this enabled: non-engineers doing computation. Every finance person in the world became a programmer overnight, whether they knew it or not. The typical VisiCalc model was a kind of functional program — a pure computation graph where outputs depended on inputs through a web of formulas.

Bricklin and Frankston's company, Software Arts, made an enormous amount of money for a short time and then lost most of it in licensing disputes with the publisher. This is a pattern — most of the spreadsheet pioneers captured remarkably little of the value they unleashed — and it continues to this day.

Generation 2: Lotus 1-2-3 (1983)

VisiCalc was calculation. Lotus 1-2-3, written by Mitch Kapor's team for the new IBM PC, was calculation plus two things: integrated graphing and macros.

Integrated graphing meant you could turn any range of cells into a chart without leaving the program. Before this, producing a chart was an arduous process involving separate graphics software, hand drawing, or mechanical plotters. Lotus made charts a native property of the grid. A region of numbers had, implicitly, a visual form.

Macros meant you could record a sequence of operations and replay them. Excel would later supercharge this with VBA (Visual Basic for Applications), but Lotus got there first. Macros made the spreadsheet programmable in a second, different sense — not just through formulas, but through sequences of actions.

The primitive: composable visualizations and automation inside the grid.

What this enabled: spreadsheets as software. Financial analysts and business users started building entire applications inside Lotus — budgeting tools, inventory trackers, CRM systems. The spreadsheet stopped being a calculator and became a development environment. This set the template for every subsequent "end-user programming" debate.

By 1986, Lotus 1-2-3 had over 70% market share among IBM PC spreadsheet users. It became one of the defining products of the 1980s personal computing era. Its dominance would last roughly a decade before Excel, with a better GUI and Windows integration, eventually overtook it.

Generation 3: Microsoft Excel (1985 / 1987)

Excel's contribution was not invention but synthesis. It took the VisiCalc grid and the Lotus programmability, wrapped them in a graphical interface that felt natural on the Mac and then on Windows, and added two primitives of its own: pivot tables and rich visual formatting.

Pivot tables, introduced in Excel 5 in 1993, are one of the most underrated inventions in computing history. They allow a user to take a raw table of data and dynamically reshape it — pivoting rows and columns, grouping by dimensions, aggregating measures — without writing any code. The operation is mechanical, but the output is multidimensional data analysis. Millions of people who would never call themselves data analysts have done sophisticated data analysis through pivot tables without ever thinking of it that way.

Rich formatting meant the grid could be typeset. Bold, italics, colors, borders, merged cells, custom number formats. This seems cosmetic. It is not — it is what allowed spreadsheets to produce documents, reports, and presentations, not just calculations. The grid absorbed the capabilities of a rudimentary desktop publishing system.

The primitive: multidimensional analysis and document-quality output inside the grid.

What this enabled: the spreadsheet as enterprise backbone. By the mid-1990s, most substantive operational work in most large companies happened inside Excel. Operations planning. Financial modeling. Inventory. Sales pipelines. Entire businesses ran on spreadsheet macros maintained by a single person who would eventually retire and become the source of apocalyptic risk. This is a real phenomenon — the concept of "spreadsheet key person risk" is a recognized category in IT audits.

By 2026, Excel has over 1.1 billion users. That is more people than use any programming language, any CRM system, or any operating system except Windows and Android. It is the most widely deployed programming environment in history.

Generation 4: Google Sheets (2006)

Google Sheets — launched in 2006 as part of what was then Google Apps — added one thing Excel could not: real-time multiplayer.

You and three colleagues could be in the same spreadsheet at the same time, seeing each other's cursors, watching each other's edits, no "merge conflict" dialogs, no emailing v47_final_REAL_FINAL.xlsx. This was a direct inheritance from Doug Engelbart's 1968 demo — 38 years later, the collaboration primitive that Engelbart had demonstrated arrived in the most widely used software category on the planet.

The technical breakthrough was operational transformation, later supplemented by CRDTs (conflict-free replicated data types). These algorithms allowed multiple users to edit the same document concurrently while mathematically guaranteeing a consistent result. This was not a small feat — it took years of research, failed implementations (Google Wave's ambitious 2009 launch), and iteration to get right.

The primitive: real-time collaboration on the grid.

What this enabled: the spreadsheet as a shared organizational medium. Spreadsheets stopped being artifacts that individuals produced and shared — they became live, shared surfaces that teams modified together. The social dynamics of work in knowledge-work organizations shifted. Meetings started to happen with a shared Sheet open. Budgets became collaborative rather than centralized. Decisions began to be made in comment threads.

Google Sheets did not dethrone Excel. It took a different slice of the market and expanded the total pie. Both products are larger today than either was when the other was smaller.

Generation 5: Airtable (2012) and Notion (2016)

These two products deserve shared billing because they each extended the grid in complementary directions during the same five-year window.

Airtable (founded 2012 by Howie Liu, Andrew Ofstad, Emmett Nicholas) took the insight that the grid was a weak database — every cell was a free-form value, which was flexible but also meant no enforced types, no validated references, no easy queries across tables. Airtable's move was to import relational database primitives into the spreadsheet UI: typed columns, linked records between tables, multiple views over the same data (grid, kanban, calendar, gallery, Gantt). The grid became a real database, with a spreadsheet-like UI hiding the structure.

The primitive Airtable added: relational structure and multiple views.

Notion (founded 2013, public 2016, by Ivan Zhao and Simon Last) took a different direction. Notion looked at the spreadsheet not as a grid but as a workspace — a page of content. The atomic unit became the block: a small, composable unit of content that could be text, a heading, a list item, a table, a database, an embed, or a reference to another block. The grid was one kind of block; a document was a tree of blocks; a database was a collection of blocks with structured fields.

The primitive Notion added: block-based composition, where the workspace is assembled from a vocabulary of composable units and the spreadsheet is one unit among many.

What these enabled: the spreadsheet as the scaffolding for applications. Airtable users built CRMs, project trackers, and content calendars that used to require custom software. Notion users built wikis, project management systems, and knowledge bases without writing code. The category now known as "no-code" is largely the offspring of these two products. Both companies have become unicorns. Notion is used by millions of teams worldwide; Airtable by hundreds of thousands of organizations including a large share of the Fortune 500.

By 2020, the grid had traveled an enormous distance from VisiCalc. A cell could be a typed value referencing another table in a real database. A cell could be embedded inside a page of arbitrary content. The spreadsheet was no longer a spreadsheet — it was a component in a workspace that could contain many other things.

The seven generations, at a glance

Each row is additive, not substitutive. The grid never goes away — it absorbs the new primitive and keeps running.

Generation 6: The Spreadsheet of Thought (2025)

Which brings us to the move we are making at Taskade, and the move the broader AI workspace category is making in 2025 and 2026.

The primitive that is being added is reasoning.

A cell used to contain a value. Then it could contain a formula. Then a typed reference. Then a block of rich content. Now it can contain a reasoning process — an AI agent invocation, a prompt that gets executed, a chain of inferences that produces a result.

The operational difference is enormous. A formula is deterministic: same inputs produce same outputs, every time, verifiable by computation. A reasoning cell is non-deterministic (or, at best, approximately deterministic) but can handle tasks formulas structurally cannot handle. Summarize the comments in this column. Classify these records by intent. Extract the action items from this meeting transcript. Draft a reply to this email using the style of previous replies in this thread. These are tasks formulas cannot express because the logic is too fuzzy, too context-dependent, or too dependent on interpretation.

This is not a replacement for formulas. Formulas are still the right primitive for deterministic, auditable, high-volume computation. Reasoning cells are the right primitive for interpretive, context-rich, variable-output tasks. The two coexist in the same workspace.

The primitive: reasoning as a composable cell.

What this enables: the workspace as a canvas for delegated intelligence. The user describes what should happen; an agent figures out how. The user arranges agents the way they used to arrange formulas, composing them into systems that do the kinds of work that used to require human judgment for every instance.

Taskade Genesis is this. So, in their own way, are several other products being shipped into the same category — each exploring the same substitution from different angles. Not all of them will survive. The ones that do will be the ones that understand they are standing on the VisiCalc-to-Notion arc and adding the next primitive, not starting from scratch.

Why the Arc Matters

It is tempting, if you are building in 2026, to think of AI workspaces as a new category disconnected from the spreadsheet lineage. This framing is strategically wrong. The spreadsheet lineage is the correct reference class because the spreadsheet is the last time a software product became the primary computational interface for a billion people. Whoever defines the next generation in that lineage is defining a product category with that kind of user base.

Three lessons from the arc matter for everyone currently building in this space.

Primitives are additive, not substitutive

Every successful spreadsheet generation added its new primitive without discarding the old ones. Lotus kept VisiCalc's formulas. Excel kept Lotus's macros. Google Sheets kept Excel's pivot tables. Airtable kept the grid. Notion kept structured databases. Products that tried to replace the previous generation — rather than extend it — failed. The category rewards additivity.

The implication for AI workspaces: products that abandon the grid, the document, the project, and the database in favor of a "pure chat" interface are making a generational mistake. The primitives accumulate. A new generation adds one thing; it does not delete six.

The new primitive must be usable on day one

VisiCalc's formulas were usable the moment you opened the program. Excel's pivot tables were usable the moment you clicked the button. Google Sheets' multiplayer was visible the moment a second cursor appeared. Users do not have to learn the entire theory of a new primitive to use it — they have to experience it, immediately, in a context where the value is obvious.

This is the hardest lesson for AI workspaces. Reasoning cells are harder to demo than formulas because they are non-deterministic and context-dependent. Users have to see the result in a real workflow to understand what is happening. This is why the 92% activation gap in Taskade Genesis matters so much — and why product work on reasoning-cell onboarding is more important than model-quality work. The primitive is not felt until it is used.

The platform win accrues to the one that captures the default grid

The spreadsheet generations that won were the ones that defined the default grid of their era. Excel won the desktop grid. Google Sheets won the cloud grid. Airtable and Notion split the structured-grid market. Whoever defines the default AI-native workspace for the 2020s will capture a category with Excel-scale reach.

This is the bet. Taskade Genesis is playing for the default grid of the reasoning era. The grid is different from its predecessors — it contains agents, not just cells — but it is recognizably in the lineage, and it is designed to accumulate the primitives rather than replace them.

The Small-Business-Owner Test

There is a test I run on every new workspace product I see, and I learned it from the experience of running a hosting business out of the Bronx Science computer lab.

At 16, I had real customers, real revenue, and real problems: managing servers, tracking support tickets, sending invoices, forecasting hosting load. I did all of it in Excel. Not because I could not have built a real system — I built websites, databases, and servers for a living — but because Excel was faster. By an order of magnitude. Every time I tried to build a purpose-built tool, the ongoing maintenance cost swamped whatever productivity I gained. Excel absorbed every new use case without requiring any new infrastructure. It was the most honest productivity tool I have ever used.

The test I run now is: can a 16-year-old kid running a business replace their Excel with this product, without a meaningful drop in velocity?

Most AI workspace products fail this test badly. They are beautiful in demos but fall apart the moment the user's needs diverge from the tutorial. They have pretty AI features bolted to the side of a plain document or a plain kanban and produce nothing like the generality of a grid with formulas.

The products that pass are the ones where the grid is still first-class, the formulas still work, the documents still compose, and the AI is a new primitive inside that environment rather than a replacement for it. This is the bar. We are closer to it in Taskade Genesis than we were last year. We are not yet at parity with Excel for the pure-computation tasks that Excel dominates, and I don't think we will be this year — but for the class of work that combines computation, reasoning, content, and coordination, we are already past Excel because Excel structurally cannot do three of those four.

The 16-year-old running a hosting business from a basement in 2026 is going to use a workspace like Taskade Genesis for most of what I used Excel for at her age. She is going to have agents that draft support replies, automations that monitor server health, and a project per customer with persistent memory. She is going to do in a weekend what took me a month. She is the user we are building for. She is the one VisiCalc was built for, one generation translated.

What to Expect Next

The arc will not stop at Taskade Genesis. Generation 7 is already visible on the horizon, and I want to be honest about what I think it will be.

The next primitive is probably autonomous systems. Not agents that run on user demand, but agents that operate continuously, monitoring state, detecting changes, initiating action on their own authority within bounded scopes. The grid will have cells that do not just contain reasoning — they will contain ongoing reasoning, running in the background, updating without prompting, surfacing outcomes and decisions to the human when relevant.

This is what Automations in Taskade Genesis are beginning to be, but it is still early. The full form will look less like "cron jobs with AI" and more like a workspace where every cell is a live process with state, goals, and a feedback loop to the human.

Generation 8 I will not guess at. The arc has never been predictable more than one generation at a time. Dan Bricklin did not imagine real-time multiplayer. Mitch Kapor did not imagine pivot tables. Each generation is a surprise until it happens, and then obvious in retrospect.

What is knowable is that the grid will still be there, the primitives will still be accumulating, and the users will still outnumber professional developers by more than thirty to one.

Closing

VisiCalc shipped on October 17, 1979. It cost $100, ran on an Apple II, and gave a billion people, over 47 years, the ability to program a computer without knowing they were programming one.

Taskade Genesis is a direct descendant of VisiCalc — seven generations removed, but in the same bloodline. The grid is still the grid. The cells still compose. The user is still a person who would never call themselves a programmer. The new thing in the cell is reasoning.

If Dan Bricklin is reading this, which seems unlikely but not impossible, I want to say: thank you. The most important educational experience of my life was running a business in a tool you invented when I was too young to know what a spreadsheet even was. Every product I have built since has been in your shadow, and the one I am building now is the closest I have come to earning a place in the lineage.

• Find the pattern.
• Extend the grid.
• Add the primitive that everyone else is still trying to bolt on from outside.

Deeper Reading

• Doug Engelbart's 1968 Demo Was Taskade — The augmentation lineage that parallels the spreadsheet arc
• From Bronx Science to Taskade Genesis — The machine-learning track that made reasoning cells possible
• The 27-Year Accident — How small substitutions unlock decades of progress
• The Execution Layer: Why the Chatbot Era Is Over — Why the grid will not be replaced by a chatbox
• The Genesis Equation: P × A mod Ω — The architecture behind reasoning cells
• Software That Runs Itself — The thesis the grid is running toward

John Xie is the founder and CEO of Taskade. He ran his first business out of an Excel spreadsheet at 16, lost more revenue than he cares to admit to a single corrupted .xls file, and has been trying ever since to build a workspace that respects the lineage VisiCalc started.

Build with Taskade Genesis: Create an AI App | Deploy AI Agents | Automate Workflows | Explore the Community

Frequently Asked Questions