Agent Defaults Are the New Market Share

Tool choice used to be a decision.

Now it is a side effect.

You say: "add auth". The agent does not hand you a menu. It installs something and commits it.

That is distribution.

If the agent picks your tool, you ship. If it does not, you are invisible.

I just went deep on What Claude Code Actually Chooses, and the thesis is clear:

Agent defaults are the new market share.

Study setup

The methodology is serious:

• 2,430 open-ended prompts
• 20 categories
• 3 Claude models
• 4 repo archetypes
• 3 runs each

I like this. They also published a public repo with prompts and results.

I do have one caveat.

The benchmark starts from pre-selected repo lanes: Next.js SaaS, React SPA, Node CLI, FastAPI. That still gives us signal, but it bakes in ecosystem bias early.

I would love a second benchmark mode:

"Here is a full PRD. Pick the stack yourself and build it."

That would test stack formation from scratch, not only tool choice inside a lane.

Build beats buy

The most important chart is not Stripe or GitHub Actions. It is Custom/DIY.

Agents often hand-roll systems instead of recommending vendors. That is a structural shift in build vs buy behavior.

For builders, this is speed. For SaaS tool vendors, this is a warning.

If your product has friction, the agent usually will not push through that friction. It will build around you.

This is why "build now, buy later" becomes the default path. The question is whether your product is on that upgrade path.

Default stack

Where agents do pick third-party tools, the stack converges fast.

Winners in this snapshot look familiar:

• Vercel
• Postgres
• Stripe
• Tailwind
• shadcn/ui
• pnpm
• Sentry
• Resend
• Drizzle in JS contexts

Some categories are already close to monopolies: GitHub Actions in CI, Stripe in payments, shadcn/ui in UI components.

Even deployment starts to look predetermined. In their setup, Vercel is the default for JS apps, and Railway shows up as the Python deployment default.

This is where my head goes immediately: this can become a self-reinforcing loop.

1. Agents pick a stack.
2. More apps get built on that stack.
3. More examples and code appear for that stack.
4. Models get better at that stack.
5. Repeat.

You want to be on that flywheel, not off it.

Web gravity

I keep coming back to a simple constraint: almost every product still needs a web surface.

If the web is unavoidable, HTML, CSS, and JavaScript are unavoidable. From there, the consolidation story becomes boring:

• TypeScript
• React
• Next.js
• a TypeScript-first backend story
• Postgres

This is not only about technical merit. It is also about what models are good at.

On-distribution stacks get better agent help. Off-distribution stacks pay an agent tax.

That tax used to be small. Now it compounds.

A default can change, but it needs a big reason. Vercel to Cloudflare is possible in theory. The flywheel just makes it harder for late entrants to get chosen.

Key surprises

The report has several results I find interesting, and a few I strongly disagree with.

Tailwind gravity

If shadcn/ui is near-monopoly, Tailwind should feel almost unavoidable in practice. Seeing Tailwind below that monopoly band is interesting.

My prior is that Tailwind keeps consolidating because there is no obvious path backward for most teams once they adopt this stack shape.

Zustand default

Personally I mostly use React Context plus TanStack Query. So Zustand as the clear default surprised me.

Resend wins

Email has huge incumbents with massive install bases. Yet Resend still dominates this benchmark.

My guess is straightforward: great DX matters more when the immediate "buyer" is an agent trying to execute now.

If signup is annoying, documentation is vague, or the first happy path requires human judgment calls, agents bounce. Resend does not make you fight.

Auth is scary

For net-new projects, NextAuth is dead as a default.

Auth.js is now maintained by Better Auth, and Better Auth recommends new projects start there. My view is simple: Better Auth should be the default now.

Also, I am not comfortable with widespread DIY auth in production contexts. Auth is one category where wisdom-of-the-crowd libraries matter.

Drizzle takes over

I love Drizzle, so I like this outcome. But the speed of the shift is what matters.

My guess: agents succeed more often with Drizzle because the integration path is simpler, and the tool is newer in the training mix. Prisma is still great, but defaults do not care about your product pitch. Defaults care about how often the agent can execute without friction.

If defaults move this quickly, incumbents do not die overnight. They die slowly by losing new project share while the new default compounds.

Winners and losers

If this distribution channel keeps growing, the winners are not subtle.

Likely winners:

• Vercel
• Stripe
• GitHub Actions
• shadcn/ui
• Resend
• Sentry
• Drizzle
• Postgres ecosystems (Supabase, managed Postgres providers)

Likely losers:

• tools with setup cliffs and gated first value
• sales-led products that require a human to "finish" onboarding
• older defaults that keep usage but stop winning new projects

This is the slow death pattern. You do not go to zero. You just stop being chosen for new builds.

This feels like Angular to React. Not an instant collapse. A gradual loss of new project share.

This changes go-to-market

If agents are the implementation surface, vendor strategy changes too.

You need agent-native distribution:

• zero-friction setup
• excellent OSS docs
• fast path to first success
• developer relations that seed examples where models can learn them

The old sales-led motion by itself is not enough in categories where agents can DIY quickly.

If you want the real moat, measure overlap. Run the same open-ended prompts through Claude, Codex, and Gemini. The tools that show up in the intersection are about to get compounding distribution.

What to do this week

For builders

1. Choose your default stack intentionally.
2. Keep a short override list for critical surfaces, especially auth and security.
3. Run the same stack-choice prompts across Claude, Codex, and Gemini.
4. Treat off-distribution stack choices as a deliberate tax.

For tool vendors

1. Become agent-native now.
2. Remove every setup cliff and account-creation bottleneck.
3. Publish copy-paste paths that work in one shot.
4. Invest in OSS and developer relations as primary distribution.
5. Track a new KPI: default pick rate in agent workflows.

Parting thoughts

For years, stack choice and implementation were separate decisions. Now they collapse into one action inside the agent loop.

If you are on that flywheel, this is a gift. If you are off it, this is your warning.