A Bicycle for the Mind

Steve Jobs had a way of explaining complex technology in simple words.

In a 1990 interview, he recalled an article that compared how much energy different species used to move. The condor came first. Humans finished far down the list.

Then someone tested a human riding a bicycle. The human did not just beat the condor. It blew it off the chart.

Jobs used the story to make a larger point: humans build tools that amplify our natural abilities. The personal computer, to him, was a bicycle for the mind.

Since the Apple I launched in 1976, computers have transformed almost every part of our lives. But the relationship remained unchanged.

The computer helped us do the work. The human was still on the driving seat.

AI Gets Hands

When ChatGPT arrived in late 2022, it felt like we had gotten our first real look at intelligence sitting inside a chat window.

You typed a prompt, watched it generate an answer, and then carried that answer to wherever the actual work happened. You copied the code into an editor, moved the text into a document, checked the facts, fixed the mistakes, and decided what to do next. Until you entered another prompt, the system remained idle.

Then models started getting access to the tools we used for work. They could read files, search the web, query databases, call APIs, use browsers, and run commands in a terminal.

The AI had acquired hands.

Frameworks such as OpenClaw make the next stage easier to understand. An agent can have its own workspace, memory, tools, and the ability to run tasks in the background. Instead of responding to one prompt, it can take an objective, act on it, observe what happened, correct its approach, and continue.

This changes the role of the human. We define the objective, provide the context, decide what the agent is allowed to do, and review important decisions. The agent handles more of the execution.

A chatbot waits for the next prompt. An agent continues to work even as you sleep.

The Age of Self-Driving Software

For most of its history, business software was designed around a function.

Salesforce and HubSpot helped sales teams manage customers. Shopify and Webflow helped businesses build websites and sell online. PostHog helped product teams understand how people used their products. Visual Studio and JetBrains IDEs helped developers write, test, and debug code.

These products transformed how companies operated. But they were still passive.

A CRM stored sales activity, but a salesperson had to update it and follow up with the customer. An analytics platform showed where users were dropping off, but a product manager had to investigate the problem and ask an engineer to fix it. An IDE helped a developer write code, but the developer still decided and executed every step.

A new generation of software is beginning to close these loops. The software is moving from helping us perform a job to taking responsibility of the job itself.

Visual Studio → Cursor → Devin & Vorflux

Integrated development environments such as Visual Studio and JetBrains IntelliJ IDEA brought writing, testing, debugging, and navigating code into one place. They made developers much more productive, but the developer remained responsible for every change.

Cursor and Windsurf put AI at the centre of the development environment. The agent could understand the codebase, edit multiple files, run commands, inspect errors, and revise its work. Instead of writing every line of code, the developer could describe what they wanted to build.

The developer was still sitting inside the editor and guiding the work, but now there was an agent working beside them.

Both Cursor and Windsurf have since added cloud agents that can work more autonomously.

Devin and Vorflux took this further. You can assign them a software problem much like you would assign a ticket to an engineer. The agent plans the work, writes the code, runs tests on its own machine, fixes errors, and returns a pull request.

The interface is no longer limited to an editor. It is increasingly becoming a task queue.

Visual Studio helped developers write code. Cursor allowed developers to build with an agent. Devin and Vorflux allow parts of software development to be delegated to the agent.

Webflow → Ploy

Webflow made it possible for designers and marketing teams to build professional websites without writing custom code.

But the human still had to decide which pages to create, write the copy, monitor traffic, study competitors, check search rankings, and make every improvement.

Ploy approaches the website as an active system. It can learn the company’s brand and design system, draft and publish pages, monitor traffic and search performance, track competitors, and prepare the next set of improvements.

The team continues to set the goals and approve important changes. But the software keeps watching what is happening and finding the next piece of work.

Webflow made website building visual. Ploy is beginning to turn website management into something that can be delegated.

PostHog: From Analytics to Action

PostHog started as a platform that helped teams understand and improve their products.

It tracked how users behaved, replayed sessions, monitored errors and performance, ran surveys, and managed feature flags and experiments. It gave teams the evidence they needed to build a better product.

The team still had to interpret that evidence and act on it.

PostHog’s new self-driving product functionality begins to close this loop. It watches product signals such as errors and session replays, groups related signals into a problem, investigates the code, prepares a fix, and opens a pull request.

A human still reviews and merges the change. PostHog then measures what happened after the fix, creating another signal for the system to learn from.

The earlier version told you what happened. The new version can begin changing what happens next.

From Interfaces to Objectives

Coding, websites, sales, and product analytics may look like different software categories. But the same underlying transition is happening across all of them.

Traditional software was organised around an interface. Every business function had its own application, and employees spent their days visiting these applications, entering information, clicking buttons, and moving work from one system to another.

Agentic software is increasingly organised around an objective.

Instead of learning how to operate every part of the software, you tell it what you want to accomplish. The software decides which tools to use and which steps to take within the permissions and guardrails you provide.

This will likely change the business model of software as well. SaaS companies traditionally charged per seat because every seat represented a human operating the product. If the software starts performing the work, the natural unit of value may become the task completed, the problem resolved, or the business outcome delivered.

We are still in the early days. Agents make mistakes. They need good context, clear permissions, carefully designed feedback loops, and human review. Many products being described as autonomous today still need considerable supervision.

But the direction is becoming clear.

For fifty years, the computer amplified human effort. It made us faster, more capable, and more efficient, but it waited for us to keep the work moving.

Agents do not remove the human. They move us one level up. We choose the destination, define the constraints, and make the difficult trade-offs. The software handles more of the journey.

The bicycle for the mind is evolving into a self-driving rocketship.