Skip to content
Engineering

Why local Claude is dead

Collage of faded app screens and dashboards surrounding an orange Base44 logo mark, with the headline Every builder needs a base

Claude is fine. The laptop is the problem. For two years the picture of AI-assisted development has been a developer at a desk, a terminal open, an agent typing into the repository on the machine in front of them. That picture is already out of date, and the evidence is in our own commit history.

In the first week of November 2026, 2,214 pull requests merged into the repository that runs Base44. Of those, 713 came from branches an agent session opened and named for itself: Claude sessions, Codex sessions and Base Code sessions. Roughly a third of everything that merged started without a developer naming a branch on a laptop. The place where an agent writes code has moved, and it is not moving back, because a laptop is single-player and the work stopped being single-player.

TL;DR

Local AI coding is dying because the laptop is the bottleneck, not the model.

An agent session needs a repository, a branch, an environment and a reviewer. None of those live on a laptop by necessity, and keeping them there limits you to one session, one person and one machine at a time. In our own repository a third of merged pull requests now start in a cloud session.

  • Send a prompt, close the laptop. The work keeps going.
  • Continue from your phone. Steering does not need a keyboard.
  • Share the branch, not a screenshot. The work has a URL a teammate can stand in.
  • Keep the laptop for hardware, debugging and judgment.

The laptop was always the bottleneck

Consider what a local agent session needs from the machine it runs on. A checkout of the repository. Dependencies at the right versions. A running copy of the app to check against. Credentials. A terminal that stays open. And a person, sitting there, because the session dies with the lid.

Every one of those is a constraint the model does not care about. The model is in a data center. The repository is on GitHub. The only reason the work happens on a laptop is that laptops are where developers happened to be when the tools arrived. That is history, not architecture.

The cost shows up in three places. You run one session at a time, maybe two, before your machine and your attention run out. Your environment drifts from everyone else's, so "works on my machine" now applies to the agent too. And the session is tied to your presence: close the laptop and the work stops, open it tomorrow and the context is cold.

Branch opened byMerged pull requestsShare of the week
Claude sessions46821%
Codex sessions1396%
Base Code sessions1065%
Everything else1,50168%

Table 1.Merged pull requests into the Base44 monorepo by how the branch was opened, November 1 to 8, 2026.

Strip the laptop away and the list of what a session needs gets short: a repository to read, a branch to write to, an environment that runs the result, and a reviewer at the end. Each one is better served somewhere other than a developer's machine. Once the environment is shared rather than personal, five things change, and we have felt all five.

Send a prompt, close the laptop

The first thing that changes is that the session outlives the window. In a shared environment the branch has its own sandbox, and every reply commits and pushes to GitHub as the work happens. Close the laptop. Nothing is lost, because nothing was only on the laptop.

The second is that one becomes many. An engineer on our team with a laptop runs one session. The same engineer with cloud sessions runs five, checks on them between meetings, and reviews five pull requests that afternoon. The constraint moved from how fast the agent types to how fast the human reads. That is the right constraint to have, because reading is where the judgment is.

Continue from your phone

When the session is not on your machine, your machine stops mattering. Our team operates remote development workspaces from a phone: open a branch, check a pull request, approve a change, from an installed web app that was deliberately designed to feel like a chat app. Nobody built that because phones are good for coding. They built it because the coding was already happening somewhere else, and the phone only had to steer.

Base Code's task board is the same idea in product form. Every branch you have open sits in one of four columns: Base Code is working, Needs you, Ready for review, Done. The column that matters is Needs you. Everything else is running without you.

Forget worktrees

Local AI coding created a small industry of coping mechanisms. Worktrees so two sessions do not trip over each other. Stashes. A second clone. A note on a sticky about which terminal has which branch. All of it exists because one machine was being asked to hold several parallel pieces of work it was never designed to hold.

In a shared environment each branch simply has its own environment. Start a change and it gets a sandbox, a preview URL and a chat of its own. Start another and so does that one. There is nothing to juggle, because nothing shares a filesystem with anything else. The sidebar lists the branches; the branches hold the work.

Share the branch, not a screenshot

This is the one that ends the argument. On a laptop, an AI session has an audience of one. The conversation that produced the change, the running result and the diff all live in a window on a machine nobody else can open. To involve a teammate you describe it to them, paste a screenshot, or push and hope the pull request explains itself.

Move the session into a shared environment and the branch becomes the unit of work: the request, the conversation with the agent, the code and the running preview, together, behind one URL. Now a teammate can open it. They can see you are on it, join you there, click the thing that looks wrong in the running preview and pin a comment to it with a screenshot attached. Mention the agent in that comment and it becomes the next instruction on the branch. Two people and an agent, in the same place, on the same change, without a meeting.

Every team building cloud agent environments has landed on the same word for this, multiplayer, and the same observation: once the work lives somewhere shareable, the conversation about the work moves there too, out of chat tools and into the thing itself. In our repository that is where review has started to happen: on the branch, with the preview open, before the pull request is even filed.

Start it from Slack, not a terminal

The last shift is the one that makes "local" impossible rather than merely slow. A session can now be started by a Slack mention or by an internal operations tool calling an API. There is no laptop in that sentence. A flaky test fails at 3am, a "Fix with Base Code" button appears on the report, and by the time anyone wakes up there is a branch, a fix and a pull request waiting. The laptop did not go to sleep. It was never involved.

The environment is the product

The model is a commodity you rent. The thing that decides whether an agent can do useful work on your codebase is the environment it runs in: the checkout, the services, the checks and the path to review. Build that once and every session, from anyone, anywhere, inherits it.

What the laptop is still for

A fair heads-up: "dead" is a headline, and headlines round up. Three jobs stay local for good reasons, and pretending otherwise would be a different kind of wrong.

Hardware is one. If the thing you are building talks to a device on your desk, the session has to be near the desk. Deep debugging is another. When you need a debugger attached to a process with a breakpoint on line 412, the local loop is still the fastest, because the latency between thought and keystroke matters more than parallelism. And judgment is the third: deciding what to build, reading the diff with real attention, and saying no. That was never the agent's job, and it is not moving to the cloud because it was never in the laptop either. It was in the person.

Everything else, the long implementation turns, the flag cleanups, the test fixes, the copy changes, the migrations that take forty minutes of agent time and two minutes of human time, has no reason to be on your machine. Our numbers say the team already agrees.

Something worth knowing going in: a cloud session is only as good as the environment you give it. A repository with no declared services, no health checks and no agent instructions will produce sessions that ask more questions and guess more often. The teams that get the most from the shift are the ones that wrote down how their codebase works, once, in a place the session can read. That document is worth more than any model upgrade.

What this means for a team with an existing codebase

If you are building something new, the shift is already made for you: you describe it and it runs in the cloud from the first line, which is what vibe coding has meant all along, and the guide to vibe coding with Claude on this blog covers that path.

If you have a codebase with history, reviewers and production traffic, the shift is the part that matters, and it is the part we built Base Code for. Connect the repository, and it becomes a shared cloud environment: one verified copy of main, a branch per session, a live preview per branch, and a pull request at the end of every one. Start a session from the editor, from Slack, or from an API. See who is on which branch and join them. Comment on the preview itself. Review it from wherever you are. Nobody installs anything.

Move the session off the laptop

Connect your repository to Base Code

Connect your repo

Key takeaways

  • The laptop was never a requirement of AI coding, only an accident of where developers were sitting.

  • A session needs a repository, a branch, an environment and a reviewer. All four are better shared than personal.

  • Send a prompt, close the laptop, continue from your phone, share the branch. In our repository, a third of merged pull requests already start that way.

  • Keep the laptop for hardware, deep debugging and judgment. Move everything else.

Why local Claude is dead FAQ

No. The model and the agent are doing more work than ever. What is changing is where the session runs: in a shared cloud environment instead of on one developer's machine.

Because it removes four limits at once: one session per machine, an environment that drifts from everyone else's, a dependency on the developer being present, and an audience of one. A branch in a shared environment is something a teammate can join, see and comment on while it is being built.

Work that touches hardware on your desk, debugging that needs a live debugger attached to a process, and the judgment calls about what to build and what to merge.

Give the repository a declared environment and written agent instructions, then connect it to a shared cloud environment such as Base Code, where every session gets a branch, a preview and a pull request.

Go ahead. Build it yourself.

Start building