---
title: "If an Agent Cannot Use Your SaaS, Someone Will Vibe Code It"
date: "2026-11-22"
description: "Why the future of SaaS belongs to products that AI agents can use without a browser, and the design rules I took from making the SignatureAPI CLI work for coding agents: machine readable output, errors that name the next step, secrets that never land in a log, and one set of rules behind every entry point."
tags: ["Artificial Intelligence", "Work"]
url: "https://rolandoandrade.me/blog/saas-that-agents-can-use/"
author: "Rolando Andrade"
---

# If an Agent Cannot Use Your SaaS, Someone Will Vibe Code It

> Why the future of SaaS belongs to products that AI agents can use without a browser, and the design rules I took from making the SignatureAPI CLI work for coding agents: machine readable output, errors that name the next step, secrets that never land in a log, and one set of rules behind every entry point.

A few days ago I read a post by Theo, the developer behind t3.gg. His point was simple. If he has to open a dashboard to use an app, he would rather vibe code his own version of it. Vibe coding means asking an AI to build the software for you, and not reading much of the code.

It made me look at my own work. I lead SignatureAPI, and we sell a product with a dashboard.

I think Theo is right, with one change. The dashboard is not the problem. The problem is a product where the dashboard is the only way in. Agents are the present and the future of how software gets built. The SaaS products that win next will be the ones agents can find, understand and use on their own.

This week I wrote a post for the company blog, [Our CLI is becoming a second dashboard](https://signatureapi.com/blog/our-cli-is-becoming-a-second-dashboard). It explains the designs behind our command line tool. This post is the opinion behind it, and the rules I would give any team that wants agents to pick their product.

## The dashboard tax

A dashboard is a set of web pages for people. You log in, click through screens, copy a value, and paste it somewhere else. For a person, that is fine.

For an agent, every one of those steps is a wall. An agent works in a terminal. It reads text, runs commands and checks the result. When a task needs a browser, the agent has to stop and ask a person. Or it has to fake a person with browser automation, which breaks when a button moves.

So the developer pays a tax. They wait, they click, they come back. And every time they pay it, a little voice says what Theo said out loud. "I could build this myself in an afternoon."

With coding agents, that voice is often right. A simple internal tool, a report or a small admin screen is now cheap to build. If your product is mostly screens on top of a database, an agent can rebuild the screens.

## Agents are already the users

At SignatureAPI we decided to build agent first. Our rule is short:

> An agent should be able to do everything a person does in our dashboard without opening a browser, through the API, the MCP server or the command line.

The API is the classic way for code to talk to a product. The MCP server speaks the Model Context Protocol, a standard way for AI assistants to call tools. The CLI is a program you run in a terminal. We expect the CLI to be the main door for coding agents, with CI (the machines that test and deploy code) as the second.

The CLI has moved fast. It had nine stable releases since September 24. Resource commands shipped on November 16. A new secrets rule shipped on November 18. Uploads and emails came on November 19, in version 0.7.0. Today it has 31 commands, and 15 of them work with account resources like envelopes, recipients and signed documents. One of them, `agent setup`, installs our agent skills and the MCP server for 11 coding agents.

Building it taught me what "usable by agents" really means. It is not a chat box on top of the product. It is a list of small, boring design rules.

## Give machines real output

A person reads a nice table. An agent needs output it can parse without guessing.

Every resource command takes `--json`. With it, the CLI prints NDJSON, which is one JSON object per line. First come progress lines. Then one `result` line with the credential used, the mode, the data, a cursor for the next page and any problem.

The exit code tells the story in one number. 0 means success. 1 means failure or a partial result. 2 means the command was used wrong.

Partial results get extra care. If the CLI changed something but cannot confirm it, it reports an `*_unconfirmed` result. It never retries that change on its own. An agent that retries a half finished cancel can make things worse, so we leave that decision to the caller.

## Errors that name the next step

People can search the docs when they are stuck. Agents act on the text in front of them. So the text has to say what to do.

Every command's help has examples, the global options and a link to the docs. A test checks all 31 commands for this, so no command ships without it. A usage error includes the next action, which names the `--help` command to run. It never repeats the value it rejected, because that value could be a secret.

One small detail shows the idea well. When `init` runs under an agent, it installs nothing. It prints the exact `agent setup` command instead. The agent gets the next step, and the person keeps the choice.

## Protect where secrets go

This is the part I am proudest of. The easy answer to "agents and secrets" is to block agents. We did not do that. A secret becomes a problem when its value lands somewhere it should not, like a terminal transcript or a log. That is true whether a person or an agent ran the command.

So we protect the destination, not the caller. Three choices follow from that.

1. There is no `--api-key` flag. Flag values end up in shell history, process lists and logs. The CLI reads a key only from an environment variable, `SIGNATUREAPI_KEY` by default.
2. A command that creates a secret writes it to an env file by default. It can also pipe it to another command. It prints it in the terminal only when you ask with `--show-secret`.
3. The `run` command starts another program with the test key in its environment. The key is never written to disk. If it shows up in that program's output, the CLI replaces it with `<concealed by signatureapi>`.

```
npx signatureapi run -- npm test
```

That last one has a limit, and we say so in the docs. Masking is not isolation. The child program still receives the key.

## Ask for decisions, not people

Some commands are dangerous. Cancel and delete always ask for confirmation. In live mode, creating an envelope and the three recipient commands ask too.

Without an interactive terminal, those commands fail with `confirmation-required`, unless the caller passes `--yes`. Any caller can pass `--yes`, an agent included. That is on purpose. The prompt asks for an explicit decision. It does not ask for a human.

I think this is the right line for most SaaS products. If only a person can confirm, agents cannot finish the job, and the developer goes back to paying the dashboard tax.

## One rule behind every door

A SignatureAPI account has four entry points: the public API, the dashboard, the MCP server and the CLI.

The tempting way is to build each operation four times, once per door. Then a rule change needs four edits. The one you forget becomes the hole that lets people skip the rule.

We did the opposite. Every entry point resolves to the same account identity. Every entry point calls the same set of operations, with the same secrets rule. When we shipped that rule, it reached all four doors on the same day.

<FourDoors caption="Four ways into one account. The dashboard, the API, the MCP server and the CLI all call the same operations under the same rules." />

This is also why we did not let the CLI quietly swap local file paths for uploaded URLs inside an envelope. That trick would let the CLI accept requests the API rejects. Two doors with two sets of rules is the same bug. Uploading is its own command instead, and its result goes into the envelope body.

```
npx signatureapi uploads create template.pdf --key contract-template-v2
```

## What survives vibe coding

So what happens to SaaS when anyone can vibe code a dashboard?

I do not think SaaS dies. I think the screens stop being the product. An agent can draw a screen in minutes. It cannot give you the hard part behind the screen. For us, that is a signed document with an audit log. It is also the same rules in every entry point, and secrets that never land in a transcript.

The products that become popular next will be the ones agents choose. An agent chooses the tool it can install, call and understand without help. That means clear output, clear errors, safe defaults and docs written for a reader that takes every word literally.

If a product makes agents stop and wait for a person, developers will route around it. Some will vibe code a replacement, like Theo said. Others will pick a competitor whose CLI just works.

The full design, with every command and error code, is in [the original post on the SignatureAPI blog](https://signatureapi.com/blog/our-cli-is-becoming-a-second-dashboard). Our goal there is simple to say and hard to finish. Every capability in the dashboard should reach the API, the MCP server and the CLI, under the same rules. When that is true, the dashboard is just one more door.
