Onboarding used to be about teaching a person how to use your product.

The game was progressive discoverability. You explained the product one piece at a time, because people first had to learn how to use it so that they would then use it more often and use it correctly.

That has changed, and it changed because developers now build their applications with Claude Code or Codex. I'm mostly talking about developer tools here, but for those products the one who has to learn how to use you is not the developer anymore, it's the agent. What matters most now is that Claude Code and Codex do a really good job of implementing and using your product.

It's worth the work. Across the companies I've worked with, best-in-class activation used to be 35%. With agents, best-in-class is closer to 60 to 65%, which means that if you do this really well you can roughly double your activation, just because the agents end up doing a much better job at it.

I'm working on this with Supabase, Clerk, n8n, and Brainbase, and here's how I think about it.

Before onboarding, be the default choice

The first step comes before onboarding: Claude Code and Codex have to recommend you. That's GEO, and it's not the focus of this article, but it decides who gets to your onboarding at all.

Developers will still ask questions, do research, and try to understand a platform before they make a decision. People who are not developers won't, and at a lot of companies, Supabase for example, they are now a big percentage of the users. They don't ask which database or which front-end framework to use. They just say "help me build an app for X", and Claude or Codex decides which platform to use for them.

So for those users you need to be the default choice. Once you are, everything is about making sure the experience of implementing your product is fantastic.

Build the projects and prompts your users start from

Developers start from different places. Some start with a blank project where nothing has been picked, just an empty GitHub repo. Others have an existing project where some decisions are already made: they've picked the front-end framework, or what they use for the backend API, or other services like auth, emails, or payments, but they haven't picked yours.

How your product gets implemented depends a lot on that base state. So the first thing to do is build several starting GitHub projects that cover the most common scenarios for your users: one blank, one with the front-end framework picked, one with some of the other services picked, and so on.

Then you need the prompts, because people ask for the same thing in different ways. Some people build a spec first and have the code created from that spec, and others just say "help me implement this". For Supabase, one person might say "let's design the database together, let's look at the permissions", and another might say "help me implement the database for my project with Supabase". It has to work for both.

I always recommend doing interviews with users and qualitative checks to see what they would ask in reality, and then testing with those prompts. Setting these base scenarios and base prompts is the most important thing to focus on, because everything after this is measured against them.

I've been using Gauge a lot lately for this, specifically Gauge Agents, which is a new product from them. It lets you run these scenarios as evals every week to see how your product is behaving. You can also do it with something manual that you build yourself.

Time to activation is now measured in tokens

With the scenarios and prompts in place, the question is how good Codex and Claude Code are at implementing your product. The goal is to get as close to a one-shot implementation as possible.

To know how close you are, run the implementation and track:

  • Which things the model checks the docs for, and which it does from its pre-training data.
  • How many errors come up while it's implementing. In a typed language, that might be a type error.
  • Whether it worked the first time once it finished, or whether it ran, got an error, and had to fix it and iterate.
  • How many tokens were used to finish the implementation.

That last one is the new metric. We used to measure time to activation. Time to activation is now how many tokens are needed until the app has your service implemented, running, and working.

Minimizing tokens matters for two reasons. Fewer tokens means less time, so it's less likely that people get mad that it's taking forever and switch to another service. And the faster it gets implemented, the more users feel that your service is really good, because it just works.

Change the docs until it works

Once you know which errors it hit in the middle, and why it didn't work the first time it ran, you fix those things. Most of the fixes are in the docs.

Start by looking at which docs it used and which things came from pre-training, because the two agents behave differently. In the analysis I've been running, Codex uses a lot more external docs, whereas Claude Code relies a lot more on its pre-training. You need a good experience for both.

When the agent fetched a doc and it was the wrong one, look at the search it actually did to find that doc, and make sure the correct doc is the one that's positioned for that search. At the same time, add a note to the wrong doc saying that if an agent landed there and it isn't the page it needs, it should go to this other URL.

Then make sure the docs themselves are in a really good place for agents. Most of these docs are now followed more by agents than by humans, which means step-by-step guides are not enough. You also need to add:

  • What's deprecated. The model assumes that what's in its pre-training is right, when it's actually from an old version, so it will keep using the old thing unless the docs tell it what to use now.
  • Which APIs are a poor choice for a specific job, and what it should pick instead.
  • The critical rules it always has to follow when it implements specific things.

The whole idea of running these evals is that you keep changing the docs until it works.

Iterate in a sandbox, so you don't have to deploy

While you're working on this, run all of the evals in a sandbox. In the sandbox, when the model tries to go to a specific doc URL, you serve your local version of the docs instead of the production URL. That way you don't need to deploy your changes, and you can keep iterating locally until it works. Gauge Agents does this, but you could do it on your own.

You can do the same for the landing pages that explain the product, and in general for anything the agent uses. The objective is always the same: get to one shot, and minimize the number of tokens it takes to get there.

Test the skills inside your connectors

Docs are not the only thing to check. A lot of people now use connectors to implement services. For Supabase, which is a database, the connector connects to the database using the MCP. But when you build a connector or a plugin, it can also have skills inside it.

So test those skills too. If they get used, they have to do a really good job of linking to the specific docs and of explaining how to think about the implementation. Having really good connectors, and getting people to use them, will matter.

Replace the sign up button with a copy prompt

Something I've seen at a lot of companies, and that I think you should build as well: instead of having a sign up button on your website, have a copy prompt button.

When a developer starts from Claude Code or Codex directly, which is what a lot of them do, the agent chooses the docs and skills on its own. With your own prompt, you choose. The main idea of that prompt is to guide the agent, based on exactly where the user is and what they've already done, to the docs and skills it should use:

Help me add <your product> to this project.

1. If there is already a repo here, check which programming language
   and which framework it uses.
2. Follow the guide for that stack:
   - <framework A>: <link to the specific doc>
   - <framework B>: <link to the specific doc>
3. Work out the use case from the README, from what has been built so
   far, and from what I asked for. If it matches one of these, follow
   its architecture scenario:
   - <use case A>: <link>
   - <use case B>: <link>
4. Use these skills if they are available: <skills>

For a real one, read Clerk's. It handles each starting point separately (an empty directory, an existing project, a project that already has another auth provider) and it links the quickstart for each framework.

The prompt has to understand really well which programming language they're using, which frameworks, and which use case they're running, and you need specific docs for each of those. One thing I've done lately is add architecture scenarios to the docs for the most common use cases. When we can guess the use case from the README, from what they've done before, and from what they asked, we link to that architecture scenario, which makes it much easier to implement it in that particular way.

If you build an onboarding UI, make it build a prompt

The copy prompt works really well when there's already something in the conversation or in the repo they've linked. When there's almost nothing, the agent can guess almost anything.

So for people starting from zero, if you want a UI that onboards the user, that UI shouldn't take them to the dashboard. It should create a customized prompt. They see all the possible use cases and pick one, they see all the features your product has and pick the right ones for them, and they pick from the platforms you support. Ideally the framework and the code are picked for them automatically. What comes out is a custom prompt for that person, which they then take to their agent.

This is for the people who explore your website while they do their research, which again is not most of them. But for the ones who do, it's how they discover what your product can do before the agent starts building.

Sign-up is the only step the user still does

Whether they come from the copy prompt, from the customized prompt, or straight from Claude Code or Codex, at some point while setting you up they have to sign up for your service. If your service doesn't have an API way of signing up, which I think is most of them right now, that sign-up usually goes through a browser where somebody has to click something.

It's basically the only interactive step the user has left, so test it as carefully as everything else. It has to work really well, and it has to consume the fewest tokens possible, because browser use and computer use are some of the things that burn the most. For this I always recommend having a really good WebMCP, so that going to your website to sign up, or later to change a setting in the dashboard, works well with an agent.

The other option is to take the sign-up out of the setup. Clerk does this with accountless setup: on the frameworks that support it, the agent runs the Clerk CLI and gets an application with temporary development keys, with no Clerk account needed. The user claims that application later, when they sign in.

After setup, your MCP needs feature parity with the dashboard

This last one is not onboarding, but once the product is set up, people will need to change things, like a setting. WebMCP works for that, but the best option is an MCP that the platform can connect to automatically.

That MCP has to have feature parity with the dashboard, meaning anything you can do in the dashboard you can also do from the MCP, so that people can just use it while they are building with their agents. It's also what makes the connectors possible, because a connector is basically a way to connect to your MCP that also includes the skills.

Start by changing your KPIs

If you're building a developer tool, you are now building the onboarding, and the entire experience of implementing, maintaining, and modifying your product, for agents. That has to be your top priority. On the implementation side, users are not as important anymore.

Thinking about agents changes everything, and you start by changing your KPIs. The KPI is activation from agents. And instead of less time to activation, it's fewer tokens used until your product is implemented and working.