> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enginy.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Example Prompts

> Practical prompts and workflows for using Enginy MCP in Claude Code, Codex, Cursor, ChatGPT developer mode, and other remote MCP clients.

## What good prompts do

Good MCP prompts are specific about the outcome, the data shape, and whether the client is allowed to write.

* ask for one task at a time
* name the target object or workflow
* say whether you want read-only analysis or a write-capable plan
* request a confirmation checkpoint before any mutation
* prefer concise summaries first, then deeper detail on request

<Tip>
  If you are unsure which scope or tool family you need, start with `mcp_whoami`, then ask the client to
  explain the granted scopes before you do anything else.
</Tip>

## Read-only examples

These are safe starting points for exploration, triage, and workspace inspection.

| Goal                     | Example prompt                                                                                                  | Expected behavior                                   |
| ------------------------ | --------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| Verify access            | `Run mcp_whoami and tell me who I am, which client is connected, and which scopes are granted.`                 | Confirms the connection and current permissions     |
| Understand the workspace | `Use Enginy MCP to inspect the relevant records for this account and summarize what matters most in 5 bullets.` | Finds and summarizes data without mutating anything |
| Find likely next steps   | `Search for the most relevant contacts and companies for this account, then rank them by fit and explain why.`  | Uses read tools to gather candidates and rank them  |
| Review campaign status   | `Show me the current state of this campaign, the main blockers, and any obvious inconsistencies.`               | Pulls current state and returns an operator summary |
| Sanity-check a flow      | `Before any changes, map the data you would need to touch and list the exact tools you expect to use.`          | Produces a plan instead of making edits             |

## Write-capable examples

For anything that mutates data, instruct the client to stop before execution and ask for approval.

| Goal                  | Example prompt                                                                                                     | Required behavior                                |
| --------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------ |
| Prepare a change      | `Draft the updates needed for these contacts, but do not execute anything until I confirm the exact diff.`         | Plan first, wait for approval                    |
| Update a campaign     | `Prepare a safe campaign update plan, call out any destructive changes, and ask me before you apply them.`         | Surface the diff and require a confirmation step |
| Bulk edit records     | `Identify the records that should change, show me the proposed edits grouped by record, and wait for my sign-off.` | Group changes and pause                          |
| Write with guardrails | `If you need a write scope, explain why, show the minimum permission needed, and stop until I approve.`            | Keep the scope request minimal and explicit      |

<Warning>
  For write workflows, the best prompt is not "do it all automatically." It is "prepare the change, show me
  the diff, and wait."
</Warning>

## Prompts by client

### Claude Code

Use this when you want the assistant to inspect data first and only mutate after you approve the plan:

```text theme={null}
Use the Enginy MCP server. Start with mcp_whoami, summarize the granted scopes, then inspect the relevant data.
If any write is needed, stop and ask me to confirm the exact change set before you apply it.
```

### Codex

Codex works well when you separate discovery from execution:

```text theme={null}
Use Enginy MCP to analyze the workspace data first. Keep the answer concise, show the plan before any write,
and do not mutate records until I explicitly approve the proposed changes.
```

### Cursor

Cursor prompts should be explicit about the local flow you want:

```text theme={null}
Connect to Enginy MCP, inspect the relevant records, and return a short summary with the exact next action.
If you need to make a change, present the diff and wait for my confirmation before applying it.
```

### ChatGPT developer mode

Use the same operator pattern in ChatGPT developer mode:

```text theme={null}
Use the Enginy remote MCP server to answer from current workspace data only.
If the task requires a write, explain the minimum change set and stop until I approve it.
```

### Other remote MCP clients

For any other remote MCP client, keep the instruction simple:

```text theme={null}
Use the Enginy MCP server, read the current data first, and ask for confirmation before any write action.
```

## Prompt patterns that work well

* `First inspect, then summarize, then ask`
* `Show the minimum diff`
* `Use read-only tools unless I approve a write`
* `Explain missing scopes instead of retrying blindly`
* `If something fails, tell me the exact MCP/client reason and the next fix`

## Prompt patterns to avoid

* `Do everything automatically`
* `Fix the workspace without asking`
* `Use whatever scopes you need`
* `Keep retrying until it works`
* `Write changes and then summarize them`

## Next steps

* [MCP overview](/mcp/overview)
* [Clients & interfaces](/mcp/custom-clients)
* [Scopes and policy](/mcp/scopes)
* [Security and troubleshooting](/mcp/security-troubleshooting)
* [Claude Code setup](/mcp/claude-code)