# Building epilot Apps from your terminal, with a little help from AI agents

> Source: <https://dev.to/epilot/building-epilot-apps-from-your-terminal-with-a-little-help-from-ai-agents-5caa>
> Published: 2026-08-13 09:54:12+00:00

A few months ago we shipped the **epilot CLI**, and it quietly became one of my favorite tools. One command, `npx epilot`

, gives you every single epilot API operation in your terminal: entities, journeys, workflows, pricing, files, permissions, 50+ APIs.

Interactive pickers if you're exploring, `--json`

and `--no-interactive`

if you're scripting.

It also turned out to be a perfect match for AI agents like Claude. Agents are great at driving CLIs: they discover operations, read the help, make calls, parse the JSON. No custom integration or MCP server needed, the CLI *is* the integration. And because handing an agent live CRM access is a scary idea, the CLI ships with two safety nets, both enforced server-side:

```
# A session that physically cannot write. The restriction is baked
# into the token, so the bearer can't turn it off.
epilot auth login --readonly

# A token that additionally gets all PII anonymized in every response
epilot access-token createAccessToken -d '{
  "name": "AI agent token",
  "read_only": true,
  "anonymize": true
}'
```

Read-only plus anonymized means an agent can explore, analyze and report on your real org all day, and the worst it can do is read data it can't even de-anonymize.

Now we've made the CLI even better. On top of the raw API commands, we added **app facades**: a set of high-level `epilot app`

commands that take you from an empty folder to a working app installed in your org. And that's what this post is really about, because apps are where the fun is.

epilot is very configurable out of the box: journeys, workflows, automations, pricing. But at some point every team hits a wall, something the UI simply doesn't offer.

That's what Apps are for. They extend the platform with your own UI and logic, running right inside the product. Everything an app is (its components, configuration and assets) is described in a single `manifest.json`

.

Until now, getting from "I have an idea" to "it's running in my org" meant a fair amount of manual manifest-wrangling. The App CLI turns it into four steps.

```
epilot app init my-app
cd my-app
```

You get a ready-to-go monorepo: the `manifest.json`

, a `components/`

folder, build tooling already wired up, and a `SKILL.md`

with instructions written specifically for AI agents (more on that in a minute).

```
epilot app add-component
```

An interactive picker lets you choose what to build:

`CUSTOM_CAPABILITY`

)`CUSTOM_PAGE`

)`CUSTOM_JOURNEY_BLOCK`

)`CUSTOM_PORTAL_BLOCK`

)Each choice lands as a working component from the [ epilot-dev/app-templates](https://github.com/epilot-dev/app-templates) repo, registered in your manifest, ready to build.

```
epilot app dev --component my-tab
```

This is my favorite command: it serves your component from localhost **inside the actual epilot UI**. You edit code locally, hit refresh, and see your tab or widget rendered in the real product, with real data, next to real features. No deploy loop while iterating. When you're done, `epilot app dev --off`

removes the override.

```
epilot app validate
epilot app deploy --dry-run   # see what would change
epilot app deploy             # ship it
```

`deploy`

reads the manifest, creates or updates the app, uploads your built assets, and handles versioning for you. If the latest version is already public (and therefore locked), it automatically creates a new one. `epilot app versions`

shows the history.

Here's where the two halves of this story click together.

Remember the `SKILL.md`

that `epilot app init`

scaffolds? It teaches AI agents the project structure, the manifest format, and the full workflow. Claude Code picks it up automatically. So building an epilot App in 2026 actually looks like this:

```
epilot app init my-app && cd my-app
claude
```

Then you describe what you want in plain language:

"Add a custom tab to the contact page that shows all meters linked to the contact, with their last readings in a table."

And the agent takes it from there:

`SKILL.md`

to understand the project`epilot app add-component`

to scaffold a custom entity tab`epilot app dev`

so you can watch it live inside epilot`epilot app validate`

and `epilot app deploy`

You review, the agent types. And this isn't just a developer workflow: colleagues who wouldn't call themselves engineers have shipped working apps this way. The CLI does the heavy lifting, the agent does the plumbing, and the human decides what to build.

```
npx epilot --help              # explore the CLI
epilot auth login --readonly   # safe mode for agent sessions
epilot app init my-first-app   # start building
```

If you build something with it, or let Claude build something with it, I'd love to hear how it goes. 🚀