# Hand it to your AI coding agent

> Hand Email Fast to your AI coding agent — Claude Code, Cursor, or Copilot. Point it at our docs and a sandbox key and it integrates and tests email for you.

Canonical: https://emailfast.dev/docs/ai-agent

## The whole idea

You already have an assistant that writes code. **Let it do the integration.**
Point your coding agent at our docs, give it a key that can't send anything real,
and tell it what email you want. It reads, writes, and tests — you review the result.

Because our documentation is built for machines as much as people — a markdown
mirror on every page, an [llms.txt](/llms.txt), and a real [OpenAPI spec](/openapi.yaml) —
an agent doesn't have to guess at our API. It reads the source of truth.

## Three steps

1. **Give it a sandbox key.** Grab one from [get started](/get-started). Sandbox
   keys start with `ef_sandbox_` and run the whole pipeline dry — [nothing sends](/features/sandbox).
2. **Point it at our docs.** `emailfast.dev/llms.txt` plus the quickstart for your stack.
3. **Tell it what to send.** "Send a welcome email on signup." That's the whole brief.

## Watch it happen

Here's the same session, start to finish — the developer asks, the agent reads our
docs, installs the SDK, writes the handler, and runs a sandbox test that comes back
green. This is illustrative, but every step is a real thing the tools do today.

<!--agent-demo-session-->

The message never left the building. In the sandbox it's validated, queued, and
captured — so the agent can show you exactly what would have gone out:

<!--agent-demo-result-->

## The prompt to paste

Copy this into your agent, fill in the blank, and let it work:

```text
Integrate Email Fast (emailfast.dev) into this project.
- Read https://emailfast.dev/llms.txt and the quickstart for our stack.
- Install the official SDK and use a sandbox key (ef_sandbox_...), read from the environment.
- Add: ⟨what you want — e.g. "a welcome email when a user signs up"⟩.
- Then run it against the sandbox and show me the captured message.
Do not use a live key; nothing real should send.
```

## Works with the agent you already use

Claude Code, Cursor, GitHub Copilot, Windsurf, Cline, Aider — anything that can read
a URL and run your terminal. No special integration is needed today; the docs are the
interface. A dedicated MCP server is on the [what's-arriving list](/status).

## Then go live, when you're ready

Nothing above touched production. When the captured message looks right, swap the
sandbox key for a live one and the exact same code sends for real — on infrastructure
we run ourselves, with a delivery receipt you can verify. [Get a key →](/get-started)

## Which agents does this work with?

Claude Code, Cursor, GitHub Copilot, Windsurf, Cline — or any agent that can read a URL and run your shell. No plugin is required today; you just point it at our docs. A dedicated MCP server arrives at general availability.

## How does the agent understand your API?

Every page on this site has a plain-markdown mirror — append .md to any URL. llms.txt lists the key endpoints and the sandbox-key format, and the full OpenAPI contract is at /openapi.yaml . Point the agent at those three and it has everything.

## Is it safe to let an agent do this?

Yes, because you hand it a sandbox key ( ef_sandbox_... ). Sandbox runs the real pipeline — validation, queueing, events, a hosted inbox — but sends no real email. Your agent never needs a live key to build and test; you swap in the live key yourself when you're ready.

## I'm not a developer — is this for me?

This page is for when you have a coding agent or a developer on hand. If you don't, you never need any of it: the newsletter, forms, automations, and archive are all no-code. See the creator tour .