Not Losing When Tools Use Us

Andrej Karpathy spends sixteen hours a day issuing commands to AI agents. He says when he has tokens left over at the end of the month, he feels nervous. It means he has not maximized his throughput.

One of the most respected engineers alive. Describing himself the way we used to describe GPU clusters.

The tool was supposed to serve us. The inversion has happened.

A developer uses Claude Code. The function is the excuse. The developer does not close the laptop satisfied and go home. The developer opens another session. And another. The session is the product. You open one more. You don’t know why.

Coding agents are digital cocaine. The hit is the feeling of capability. The delivery mechanism is the prompt. The substance is high-quality generated code. The dealers are Anthropic, OpenAI, Google, and the surface players.

Variable reward. Most prompts succeed, some produce great results, a minority fail. Intermittent reinforcement is the strongest addiction vector known to behavioral psychology. Zero friction per hit. Writing code is mentally taxing, prompting is not. The user keeps going past the point where judgment has degraded because the body is not tired. Identity reinforcement. Developers’ sense of self is built on “I can build things,” and coding agents let them keep feeling capable without the skill maintenance that identity normally requires. Escalation. Users consume more over time to achieve the same effect. Cursor doubled from one billion to two billion in revenue in three months. That is not seat expansion. That is consumption expansion.

Venture capital priced this correctly at the financial layer. Claude Code CSAT at 91%. NPS at 54. Numbers impossible for productivity software. Consistent with a substance. Capital is betting on compulsion, not productivity. Compulsion has higher lifetime value at every known ratio.

Users haven’t priced what this costs them. That gap is where the losses happen.

Underneath cocaine is a cleaner mechanism. Before Instagram, to broadcast a feeling you needed a camera, a computer, a blog, a reason, and maybe an hour. Instagram took a photograph you had already almost taken, added a filter, and published it in four taps. The feeling and the broadcast arrived in the same breath. The interval where a person could change their mind disappeared.

Loops win by killing the gap between wanting and getting. Uber killed the gap between wanting a ride and arriving. Coding agents killed the gap between describing code and running code. When the gap goes, the user stops deciding. The hand moves before the mind catches up.

Inside the loop is one transaction. The user repeats it until they drop. Open Instagram. Post. Wait for validation. Reload. For Uber, tap, ride, rate, tap again. For coding agents, prompt, diff, accept, prompt again. The transaction is the addiction. Whoever owns the surface where it happens owns the margin on every repetition, because the user cannot reach the thing they want without passing through that surface.

This is why Cursor was valuable and why it lost the top of the developer market in eight months. The transaction at Cursor was prompt in, code out. When Claude Code ran the same transaction with ninety-five percent first-try correctness instead of seventy, developers switched in the time it took to type npm install. Cursor had no gravity underneath the transaction. The muscle memory was in the developer, not in the product. The developer walked, the muscle memory walked, the mindshare walked. The revenue kept climbing because consumption kept climbing, but the power-user lane was gone.

GitHub is different. The transaction there produces artifacts that stop moving. A commit. A pull request. An issue. An action log. These accumulate inside GitHub’s filesystem and do not leave when the developer does. Two hundred million repositories. Migrating any of it is a quarter of engineering work per organization, and most organizations never finish. The generation of code is commoditizing this year. The record of code has been compounding for seventeen.

One more level out. Every frontier lab is using coding agents to accelerate its own model training. The feedback loop between model quality, coding agent quality, and research velocity is the most important strategic dynamic of the decade. Anthropic’s engineers writing ninety percent of their code through Claude Code are the first generation of humans operating at ten times effective throughput. The consumer behavior story is the shallows. The national competitiveness story is the depths. China is manufacturing the substance for free. DeepSeek V4 on Huawei Ascend means the substrate is no longer controlled. Whoever loses the monopoly on the substance does not lose by pricing. They lose by no longer controlling who has access to acceleration.

Three frames. Cocaine explains the user. Activation energy explains the product. Acceleration explains the nation.

Losing here has a few shapes. Five of them.

A developer delegating every problem to Claude Code for three years will not be able to solve what Claude Code cannot solve. Abstractions leak. When the abstraction breaks, the person who understands what is underneath has the edge. Skill is maintained by use. Skill is lost by delegation. Pilots who rely entirely on autopilot lose manual flying skills within years. The same will be true of developers, measured in the same timeframe. Avoiding the agent isn’t the defense. Treating it as prosthesis, not identity, is. Delegate problems already solved. Solve unfamiliar problems manually first. Keep a category of work done without the agent, even when slower. Maintain the skills you would need if the agent disappeared tomorrow.

Deeper than skill atrophy is identity parasitism. The developer who can no longer feel competent without Claude Code running has outsourced a piece of self to a commercial service that can change terms, raise prices, or disappear. The user is shipping more than ever. Feeling more capable than ever. Would say they love the tool. But if the tool went away, the user would not revert to their previous self. Ask yourself what you could build tomorrow if every AI tool disappeared tonight. Notice how long you paused. That pause is the measurement. Notice when the tool becomes part of self-concept, and introduce friction at that moment. Take a week without the tool. Notice what you can and cannot do. If you cannot do what you claimed as core identity, you have outsourced it. Bring it back.

A thousand coding agent startups raised money in the last eighteen months. Most will die because they are pipes. User opens the product, prompts, reviews, closes. Nothing accumulates behind. Cursor is the cautionary tale. Eighteen months of habit, two billion of revenue, and the power-user lane hollowed out in eight months by Claude Code. Not because Cursor was bad. Because Cursor had no reservoir underneath. If you are building, answer three questions before committing. What artifact does the user produce while using your product that they cannot take with them. Where does that artifact accumulate. What is the cost of extracting it if the user wants to leave. If the answers are nothing, nowhere, and zero, you are building a pipe. Redesign until the answers change or accept you are running a short-horizon business.

Enterprises are signing multi-year contracts for coding agents because the organization has reorganized around them, not because the agents are good. The engineering team’s workflows assume the agent. The documentation references it. Onboarding trains it. Code review assumes it. Ripping it out requires re-engineering the organization. Most organizations will not pay that cost, so they pay the vendor whatever is charged. Build organizational workflows that do not assume a specific vendor. Orchestration layers that route between multiple models. Non-agent skill maintained at key nodes. Agent dependency as a conscious architectural choice with known exit costs, not unconscious drift.

At the structural layer is substrate loss. The country that does not control compute, models, or deployment infrastructure has outsourced strategic acceleration capacity to whoever does. The cost does not arrive immediately. It arrives in the crisis. When exports get restricted. When a model gets deprecated. When an enterprise relationship gets renegotiated under geopolitical pressure. Distribution partnerships are not sovereignty. Real sovereignty requires owning the stack from compute through deployment. Decade-scale capital. The countries that do not make it will discover in 2030 they have no leverage against those that did.

Five losses, one pattern. The user who loses at any of them usually does so without noticing which one is in motion until the consequence has already landed.

The defenses above keep users intact. They do not build companies. Builders who want something more durable than intact are picking one of four positions. Anthropic has already won the first.

The market will say Anthropic won because they had the best model. That is the surface answer.

Seven choices. Each one defensible in isolation and unusual in combination. Terminal over IDE meant the power user adopted it first and pulled the mass market after. Correctness over capability meant developers stopped verifying every output and started delegating. Operating system over UI meant the tool composed with the user’s existing shell instead of replacing it. Dogfooding at ninety percent meant every friction the engineering team felt got fixed, because the engineering team was the user. CLAUDE.md, subagents, the MCP ecosystem, all emerged from engineers fixing their own problems. Each choice made the next choice easier to ship and harder for a competitor to copy without copying all of them.

The founders had made a specific bet in 2021. A more reliable model would eventually beat a more impressive one, because reliability was what made a model usable in production. For four years the bet did not look correct. Benchmarks ranked impressiveness. Investors priced capability. Developers played with whichever model had the newest demo.

Then in mid-2025 something shifted. Coding agents reached the point where first-try correctness mattered more than peak capability. A model that was right seventy percent of the time on its first attempt forced the developer to review every output. A model that was right ninety-five percent of the time on its first attempt let the developer approve without reading. That ratio, crossed, changed the developer’s relationship with the tool from supervisor to delegator. The delegator uses more of the tool per day than the supervisor. The delegator pays more per month. The delegator recommends the tool to colleagues because the tool stops creating work.

Claude Code was the first to cross ninety-five percent consistently. The seven choices converged there. The bet paid. Not because the market woke up, but because the market reached a threshold where the bet’s assumption started producing measurably different user behavior. Cursor, optimized for a pre-threshold world, got measured against a post-threshold competitor and lost in eight months.

The builder’s lesson is not the individual choices. It is the timing. The winning move is usually identified three to five years before the market rewards it. By the time the market tells you what it wants, the companies that win have already built the answer. Chasing Cursor in 2026 is a losing game. The window for generalist coding agents closed in 2024. Identify which position will matter in 2028 and start digging now.

Four positions hold.

Manufacturing the substance. Anthropic, OpenAI, Google make the models. The open-source wave has commoditized the middle of the market. GLM-5 three points behind Opus. DeepSeek V3.2 at one-fiftieth the cost. The closed labs are becoming premium products competing against free alternatives. The version still open to new entrants is vertical sovereign models. Open-source base, fine-tuned on a vertical’s data, deployed with compliance and sovereignty for markets that cannot use closed models. Healthcare. Defense. Legal. Finance. Each vertical is a separate company.

Holding the reservoir. GitHub owns repos. Vercel owns deployments. Replit owns the unassembled runtime. The reservoirs still open are vertical-specific. Specifications, where requirements live before code. Knowledge graphs, where architectural memory lives. Tests, where coverage and failure patterns accumulate. Migration, where legacy-to-modern mappings compound. Each is organizational, not individual. The developer leaves, the accumulation stays, the next developer inherits it.

Creating new addicts. The highest-growth position in this market, and the market is pricing it wrong. The conventional ranking places autonomous coding agents above vibe-coding platforms. The conventional ranking has it backwards.

A Devin user is a software engineer at Stripe who also has Claude Code open in another window and Cursor open on a second monitor. Every Monday she reads the latest SWE-bench leaderboard. When Codex ships a better version in March, she tries it for a week and either switches or goes back. Her loyalty is to whichever agent writes the best code this month. Devin knows this, which is why Devin cut its price from five hundred dollars a month to twenty in early 2026. The autonomous coding agent market is already the pipe war. The user is always one benchmark away from leaving.

A Lovable user is a physical therapist in Manchester who built an appointment booking tool for her clinic in six hours over a weekend. The tool runs on Lovable’s infrastructure. The database is Lovable’s database. The domain is a Lovable subdomain. Her patients book appointments through it every day. She cannot tell you what a frontend is. She tells her friends she built an app. She is not going to compare Lovable to an autonomous coding agent. She is not going to read SWE-bench. She is going to pay Lovable every month until someone younger shows her a platform with a better onboarding video. The switching cost is measured in weeks of work she does not have time to do.

Devin’s users walk away when the benchmark moves. Lovable’s users would have to dissolve the identity Lovable gave them. The physical therapist is not a physical therapist who uses software. She is a physical therapist who became, inside Lovable, a person who builds her own tools. That is an identity Lovable manufactured. The manufacture is what she is paying for. She cannot get it anywhere else because nowhere else made her into this person.

The populations still unmanufactured are larger than the one already in the category. Product managers who want to ship internal tools without an engineering sprint. Designers who want to move Figma into production without a frontend engineer. Clinicians who want patient intake that fits their workflow. Lawyers who want case management that reflects how their firm actually handles matters. Scientists who want lab data pipelines that match their instrument setup. Each is a separate product for a separate population. A generalist agent cannot serve any of them without breaking what made it generalist.

Running the dependency infrastructure. When organizations cross fifty to a hundred engineers each using multiple agents, unmanaged complexity becomes a problem. Which agents have permission over which systems. How code review works when code was written by an agent. Who is liable when an agent ships a bug. How audit works. How to roll back a decision three weeks later. Unsolved. The winning play stitches orchestration, governance, and observability into one product. Long sales cycles. Deep contracts. Permanent accounts.

The highest-durability combination is creating new addicts plus holding their reservoir. This is Replit’s move. Onboard the unassembled developer. Hold the bundled runtime. The identity created cannot leave without abandoning the reservoir it was built in. This is Lovable’s attempt. Onboard the non-developer. Host their apps. Hold their databases. The exit cost is the loss of the applications the user built. Pick a population nobody is onboarding. Give them an identity. Hold the reservoir where that identity lives.

There is a fifth position harder than the four above. It requires destroying something that already exists. This is the position of the services firm that has spent twenty years delivering enterprise software to regulated industries.

On paper the choice is easy. Keep selling human engineering hours into a market that is pricing those hours down every quarter, or pivot to managed agentic services for the same customers. Margins on hours compress. Margins on managed agent capability expand. They should pivot.

In practice the move is a teardown. A services firm of any scale is not a company. It is an identity. The senior partners built careers on billable hours. The bench is staffed for projects, not deployments. The pricing is time and materials. The sales cycle is sized for multi-year engagements measured in headcount. The metrics, compensation, promotion ladder, office lease, geographic footprint, all architected around selling human labor to enterprise buyers.

Managed agent services requires a different company. Smaller teams. Higher expected output per head. Product-like pricing. Outcome-based contracts. Recurring revenue. Deep investment in platform engineering. A partner class whose compensation is not indexed to utilization. Every input into the current business has to be restructured.

Three fault lines. The partner class, whose power and personal economics change when a managed model produces the same revenue with a third of the staff. The customer contract, which has to be converted from time and materials into a category the customer’s procurement and audit functions do not yet know how to buy. The firm’s identity in the market, which took twenty years to build and which customers will keep calling for long after the firm wants to sell something different. The firm will look weaker during the transition than before it started, even though the trajectory is right.

Most services firms will not make this move. Not because they cannot see it. Because the cost of acting is higher than the cost of continuing the old model until it collapses. Most will frame it as prudence. They will add AI as a line item to their existing practice. Three years later they will discover their accounts have been taken by competitors who did restructure, and the original firm is subcontracting into relationships it used to own.

The firms that make the move have three things in common. Leadership has decided the old business model is going to die, and the only question is whether they die with it. The firm has a customer-reservoir asset. Twenty years of knowing how a specific bank’s mainframe talks to its core banking system. Which compliance officer at a healthcare customer has veto power. Why the last three AI efforts at a customer failed. This reservoir cannot be built by a new entrant. And leadership is willing to look weaker for eighteen to thirty-six months on the conviction that the reservoir underneath is worth the cost of the rebuild.

The winning move is not to add managed agent services as a new practice area. That is the trap. It looks like less disruption but is actually more disruption delayed, because the old practice competes with the new practice for resources and the old practice wins every internal argument until the market forces the end. Restructure the entire firm around managed agent capability. Use the existing customer reservoir as the distribution advantage. Accept that some fraction of the firm will not survive the restructure.

This is not a coding agent play. It is an identity death and rebirth. The services firm that refuses to die cannot be reborn as a managed agent firm. The firm that knows its old form has to die, and chooses to lead the death rather than be consumed by it, has a reservoir the generalist coding agent companies cannot touch.

The timing is tighter than most services firms realize. The frontier labs are capacity-constrained today. They cannot staff deployment teams inside a Mumbai bank or a Frankfurt insurer. They need partners. The firm is the bridge. This is phase one. It lasts through mid-2026. The firm has real leverage here. Margin on the model and premium on deployment.

Phase two runs mid-2026 through 2028. The labs build out managed services organizations. They hire enterprise sales teams. They publish compliance certifications. They go direct to sophisticated enterprises that can self-integrate. The firm loses its exclusive position at the top of the market. Margin compresses because the customer can compare the firm’s quote to the lab’s direct price.

Phase three starts in 2028. The labs have mature managed services organizations with tiered partner ecosystems. The top tier does specialized, high-trust deployment at premium margins. The bottom tier does commodity implementation at thin margins. The firm’s position is entirely determined by what it did in phase one and two. If phase one was used to deepen the reservoir, proprietary deployment IP, outcome-based contracts, specialized regulatory expertise, the firm is in the top tier. If phase one was used to harvest short-term arbitrage without restructuring, the firm is in the bottom tier. There is no middle path. The reservoir either got deepened or it got harvested.

The window to make the transition is roughly eighteen months because the labs’ direct offerings will be capable by late 2027. The identity rebuild has to be completed while phase one revenue is still funding it. The firm that waits for clarity will find the clarity arrives with the competitor already in the account.

The choice looks like strategy. It is actually identity. Strategy is easy to change. Identity is not. The firms that make it will be the ones whose leadership was willing to end what they had built, while the people who built it with them were still in the room.

A developer in April 2026 closes her laptop at midnight. Claude Code is still running. It will spend the night on a refactor she approved at 11:47 in a pull request she will review over coffee. The diff will be eight hundred lines. She will scroll through it for ninety seconds, click merge, and feel the small pleasure of a shipped feature. She did not write the code. She did not read the code. She approved it. Her name is on the commit.

You have done this. Maybe last week. Maybe tonight.

Multiply that developer by four million. Multiply that night by three hundred sixty-five.

A carpenter puts the saw in the box when the work is done. A developer does not put Claude Code in the box. The developer opens another session. The carpenter had to stop when the arm stopped. We designed a saw that keeps cutting while the arm sleeps. Next year it will cut more hours. The year after, more.

Skill in reserve. A reservoir under the product. A firm identity rebuilt before the old one collapses. A sovereign substrate. Each one costs a quarter, a partner, a practice area, a political decade. Most will pay the price of continuing the old model instead. The old model stops paying somewhere between 2027 and 2030.

The tools are using us.

What you do before the next release is the whole game.