Is product-led growth dead?

No. The shape of PLG is changing. The classic motion was a developer signing up, exploring, hitting an aha moment, and inviting a team. Increasingly, the developer asks an AI agent to do all of that. Stripe Projects shows a CLI that an agent can call to provision services, and the John Collison demo shows the same agent paying for them with stablecoins. PLG is still alive. The primary user has changed.

What is Stripe Projects and why does it matter for PLG?

Stripe Projects is a CLI for provisioning software stacks. A developer or an AI agent runs a single command and the project is wired up across services. From a PLG perspective it matters because it makes signup itself agent-callable. The agent does not visit your signup page. It runs a command. If your product is not represented in that surface, the agent goes to a competitor that is.

How does an AI agent pay for a service?

Programmatically. The John Collison Stripe Projects demo shows an agent signing up for a service and completing payment with stablecoins from the CLI. Credit cards behind a hosted checkout flow do not work for agents because there is no human to type CVV codes. Stablecoin rails and programmatic billing APIs are the agent-friendly equivalent of a checkout button.

What does PLG 2.0 look like in practice?

The agent has to be able to run five parts of the funnel on its own. It signs up through a CLI or MCP entry point rather than a web form. It gets credentials it can request and rotate rather than email confirmations. It activates by making a real API or CLI call rather than clicking through a dashboard. It pays through stablecoins or a programmatic billing API rather than a card-only checkout. And it reads its own usage in real time so it can make smarter calls on the developer's behalf. Those five parts are signup, authentication, activation, billing, and metering.

Should an early-stage developer tools startup still launch with a free tier?

Yes, but design it for the agent that will trigger the signup, not just the human who reads the pricing page. A credit-based free tier that an agent can provision through a CLI and consume against a metered API is a sustainable on-ramp. An indefinite unlimited free tier on an LLM-backed product is a subsidy that no marketing budget can absorb.

What Stripe Projects means for PLG

A developer asked an AI agent to spin up a SaaS stack this week. The agent ran a CLI command, signed up for a handful of services, configured them, started using them, and paid for at least one of them with stablecoins. The developer never visited a signup page.

That was the John Collison demo for Stripe Projects, and that is the entry point PLG has to be designed for.

For most of the last decade, PLG ran on a clean assumption: the developer is the evaluator and, eventually, the buyer. The free tier, the activation flow, the in-product nurture, the team invite prompt, the sales-assist on usage signals were all engineered around a developer reading the page, signing up, clicking around, and forming an opinion. That assumption is breaking. The developer is increasingly the orchestrator. The agent is the one who signs up.

PLG still works. What changed is the user it was built around.

What Stripe Projects shows about the new entry point

Stripe Projects is a CLI for provisioning software stacks. A developer or an AI agent runs stripe projects init and the project is wired up across services in a single command. That one command sets up authentication, billing, and infrastructure together. The CLI is the entry point, not the homepage.

The Collison demo took that one step further. The agent did not just provision the stack. It paid for the services it provisioned, using stablecoins, programmatically, with no human in the loop after the original prompt. That is the part that matters for PLG. The agent went all the way through the funnel, including the part where money changes hands.

If your PLG motion still depends on a developer landing on your homepage, reading the hero, clicking through to pricing, signing up with a corporate email, confirming the email, choosing a plan, entering a credit card, and waiting for the welcome email, you are already behind the company whose stack the agent provisions in one command.

I made the broader version of this point in if Picks and Shovels had one more chapter, on marketing to AI agents. Agents are an audience. Stripe Projects is the proof that they are also a buyer.

Discovery, activation, and expansion in the agent era

Classic PLG ran on three mechanics: discovery, activation, and expansion. Each of them is being reshaped.

Discovery used to be the search funnel. A developer typed "best Postgres ORM" into Google, scanned a list, clicked the first promising result, and tried it. In 2026, the same developer asks Claude or ChatGPT and gets a shortlist with reasoning. The recommendation is the entry point now. Your website is downstream. If your product is not on the shortlist, the developer never sees your homepage. I covered the playbook for this in startups noticed by LLMs.

Activation used to be the aha moment. A while of clicking around to feel the value. With agents in the workflow, activation collapses to whether the API returns the expected output on the first programmatic call. The agent does not need a tour. It checks the response. A product that requires clicking through a UI to reach value is invisible to the agent.

Expansion used to be bottom-up. One developer adopted a tool, told a teammate, the team adopted it, the company eventually paid. Stripe Projects shows expansion folding into provisioning itself. The agent picks the stack. The team inherits the choice. The company pays from the start. There is no slow window for bottom-up adoption to do its work.

I covered the parallel argument for the pricing page in what changes for PMM when an agent reads your pricing page first. The pricing page is one surface. The PLG funnel is the entire experience. Both have the same primary reader now.

The five surfaces that have to be agent-callable

Five surfaces in the PLG funnel have to work for an agent. Most are usually built only for humans.

Signup. The agent needs a CLI command, an MCP server, or a programmatic signup API. Web forms with email confirmations are dead ends for a process that runs on its own. Stripe Projects is the model.

Authentication. The agent needs scoped, programmatic credentials it can request, store, and rotate. OAuth flows that require a human to click Allow are not viable. Service accounts and machine-issued API keys are.

Activation. The agent needs an API or CLI surface that produces real output on the first call. A welcome email and a guided tour do not register. The first programmatic call is the activation event.

Billing. The agent needs a payment rail it can call. Stablecoins and programmatic card-on-file APIs are agent-friendly. Hosted checkout pages built for a person to fill out are not. The Collison demo shows the agent paying without any of that.

Metering. The agent needs to read its own usage in real time. A dashboard chart is for humans. The agent needs a /usage endpoint or an equivalent so it can decide whether to keep going, throttle, or escalate to its developer.

A PLG team with all five is in the new race. A PLG team with none of them is still optimizing the signup form.

The argument I made in API marketing strategy about treating the API as the primary product surface compounds here. If the API is the activation event, the API is also the marketing surface. The DX argument from developer experience is your best growth lever extends the same way. Developer experience is now agent experience plus developer experience, in that order.

The economics still break on inference

There is a second reason the old free tier is dying: the unit economics break when every interaction calls an LLM. Classic PLG free tiers, including Slack, Notion, and Postman, ran at near-zero marginal cost per user. AI-native developer tools do not have that luxury.

Lovable moved from unlimited free access to a credit-based free tier of around 30 monthly credits. Cursor caps fast requests on the free plan. Users complained about both moves, but both companies made the right call, because nobody can give away unlimited AI compute for free and stay in business.

Agents make this worse, not better. An agent runs in loops. A single developer prompt can fan out into a flood of API calls, each one calling an LLM somewhere in the stack. A free tier sized for a human's pace gets exhausted in a single agent session.

The honest version is credit-based metering with the meter visible to the agent. Stripe Projects already gestures in this direction by building billing into provisioning. As agentic commerce grows, the products that win are the ones whose metering the agent can read and reason about, not the ones whose pricing the developer has to translate from a sales-friendly summary.

What to do this quarter

For PLG teams running the 2018 motion, the work is concrete:

Audit the signup path. Can an agent sign up without a human? If not, design a CLI or MCP entry point.
Audit authentication. Can the agent request and rotate credentials programmatically? If not, ship machine-issued keys.
Audit activation. Does the first programmatic call produce real output? If not, the agent moves on.
Audit billing. Can the agent pay without a human typing a CVV? If not, add programmatic payment rails. Stablecoins are one option. Stored cards on file with metered debit is another.
Audit metering. Can the agent read its own usage in real time? If not, build the endpoint.

For early-stage teams, the developer marketing for startups guide covers the broader sequence. PLG 2.0 is product work with marketing consequences. The companies that ship the agent-callable funnel first are going to take share fast, the same way the companies that shipped self-serve signup in the early 2010s took share from the seat-license incumbents.

For any PLG team in 2026, the honest question is simple. Can an agent run the funnel from end to end on its own? If yes, the rest of the PLG playbook still works. If no, the funnel is leaking shortlist position before the developer ever shows up.