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

# Mention Commands

> Re-run reviews, fix findings, and ask questions by mentioning @cloudthinker-ai in a merge request or pull request comment.

Mention `@cloudthinker-ai` in a merge request or pull request (MR/PR) comment to re-run a review, fix its findings, or ask about the change, all without leaving your Git provider. A **finding** is one issue the review flagged for a human to look at.

## Prerequisites

* An open MR/PR in a repository connected in [Review setup](https://docs.cloudthinker.io/guide/code-review/setup.md).
* Comment access on that MR/PR in your Git provider.

## Commands

Write the command as plain text on its own line in a comment. Type `@cloudthinker-ai` exactly, whatever your bot user is called. Your provider's autocomplete may not suggest it, and that's fine.

| Command | What it does |
| - | - |
| `@cloudthinker-ai` or `@cloudthinker-ai help` | Posts the list of commands your provider supports |
| `@cloudthinker-ai <question>` | Answers a question about this MR/PR |
| `@cloudthinker-ai review` | Starts the first review, or reviews again from the last reviewed commit. `review again`, `continue`, and `continue review` do the same |
| `@cloudthinker-ai review ultra` | Runs one deeper [Ultra review](https://docs.cloudthinker.io/guide/code-review/ultra-review.md) (beta) of the whole MR/PR. Only the MR/PR author or an assignee can start it, while Ultra is in beta in your workspace. `ultra` and `ultra review` do the same |
| `@cloudthinker-ai autofix` | Fixes every unresolved finding, of any severity, and pushes the commits to this MR/PR's source branch |
| `@cloudthinker-ai autofix stacked` | Fixes every unresolved finding on a new branch and opens a separate MR/PR for them. `autofix stacked pr` also works |

`review` and `review ultra` must be the whole line. `@cloudthinker-ai review this carefully` is treated as a question, not a command. A mention inside a code block, inline code, or a quoted reply is also never run as a command.

## Run a command

**1. Open the MR/PR on your provider**

Use the MR/PR on GitHub, GitLab, Bitbucket, Azure DevOps, or AWS CodeCommit that CloudThinker reviewed.

**2. Post the command as a new comment**

For example, to re-run a review that stopped part way:

```text theme={null}
@cloudthinker-ai review
```

**Success state:** the bot replies **CloudThinker Review Started**. When the run finishes, a new review summary comment appears on the MR/PR.

If a review stops before its summary, the bot edits its progress comment to **CloudThinker Review Did Not Finish**. Findings it already posted stay valid. Comment `@cloudthinker-ai review` to continue from the last reviewed commit. On AWS CodeCommit, push a new commit to the source branch instead.

## Ask a question

Mention the bot followed by your question:

```text theme={null}
@cloudthinker-ai does this change break any other caller of parseConfig?
@cloudthinker-ai what should I test before merging this?
```

Where you ask changes what the agent focuses on:

| Where you comment | What the agent looks at first |
| - | - |
| Reply in a finding's thread | That finding and its file, plus the rest of the MR/PR so it can check side effects |
| New top-level comment | The whole MR/PR and all its unresolved findings |

Follow-up questions in the same thread build on earlier answers.

## Push back on a finding

If you're the MR/PR author or an assignee and you think a finding is wrong, reply in that finding's thread. No mention is needed. Explain why, for example:

```text theme={null}
This is intentional. The retry is capped by the caller in client.go, so it can't loop forever.
```

CloudThinker re-checks the finding against the current code and your reply, then settles it one of three ways:

| Outcome | When | What happens |
| - | - | - |
| Withdrawn | The finding was wrong | It closes, and later reviews of the repository are told not to raise it again on unchanged code. This uses the same notes as a thumbs-down [vote](https://docs.cloudthinker.io/guide/code-review/review-workspace.md#work-the-findings): each review gets the repository's newest 20 from the last 90 days |
| Acknowledged | The code is intentional | It closes for this MR/PR, with your reason posted in the thread |
| Still open | The finding still applies | It stays open, and the bot replies with why |

Pushing back works once the review has finished, on every provider except AWS CodeCommit. Other people can still ask about a finding by mentioning the bot, but their reply doesn't settle it.

## Fix findings with autofix

Pick how you want the fixes delivered:

| Command | Where the fixes land | Use it when |
| - | - | - |
| `@cloudthinker-ai autofix` | New commits on this MR/PR's source branch | You trust the fixes and want one MR/PR to merge |
| `@cloudthinker-ai autofix stacked` | A new branch with its own MR/PR that targets this MR/PR's source branch | You want to review the fixes before they reach your branch (GitHub and GitLab only) |

**1. Post the command as a top-level comment**

```text theme={null}
@cloudthinker-ai autofix stacked
```

**2. Wait for the fix run**

CloudThinker reads each unresolved finding, whether or not it has a suggested fix, changes the code, commits, and pushes. Only one autofix runs per MR/PR at a time. A second request while one runs doesn't start another.

CloudThinker doesn't run your tests. It skips a finding that needs an architectural decision or has no clear fix. The fix run is an agent run and uses credits.

**Success state:** a commit titled `fix: autofix findings from code review of ...` appears on your source branch, or a new MR/PR opens that targets it. The commit message lists each fix under `Fixed:` and each skipped finding, with its reason, under `Skipped:`.

On GitHub and GitLab you can also type `@cloudthinker-ai autofix` as a reply inside one finding's thread. CloudThinker then fixes only that finding.

> [!WARNING]
>
> `@cloudthinker-ai autofix` pushes to your source branch without a separate approval step. CloudThinker doesn't limit it to the MR/PR author, and there's no CloudThinker setting that does: anyone who can comment can run it. On a widely shared repository, limit who can comment in your provider, and use `autofix stacked` when you want to read the changes first.

## Skip a review

Put this anywhere in the MR/PR description to stop CloudThinker reviewing that MR/PR:

```text theme={null}
@cloudthinker:ignore
```

It's case-sensitive. CloudThinker reads the description on every new event, so adding the marker skips reviews from the next push, and removing it lets the next push be reviewed. A review that's already running finishes; to end it, use **Stop review** in the [Review workspace](https://docs.cloudthinker.io/guide/code-review/review-workspace.md#re-run-fix-and-merge). To skip whole groups of MR/PRs, such as bot dependency bumps, use repository filters in [Review setup](https://docs.cloudthinker.io/guide/code-review/setup.md) instead.

## Run an Ultra review

Ultra review (beta) is a deeper review of the whole MR/PR that comments only on verified bugs. The MR/PR author or an assignee starts it with `@cloudthinker-ai review ultra`. See [Ultra review](https://docs.cloudthinker.io/guide/code-review/ultra-review.md) for what it finds, who can run it, and what to do when it is off.

## Provider support

| Provider | Top-level questions | Thread replies | `review` | `autofix` | `autofix stacked` |
| - | - | - | - | - | - |
| GitHub | Yes | Yes | Yes | Yes | Yes |
| GitLab | Yes | Yes | Yes | Yes | Yes |
| Bitbucket Cloud | Yes | Partial (1) | Yes | Partial (2) | No |
| Azure DevOps | Yes | Partial (1) | Yes | Partial (2) | No |
| AWS CodeCommit | Yes | No | No | No | No |

1. Only the MR/PR author's or an assignee's replies in a finding's thread are read. Anyone else's thread reply, a question included, gets no answer; they can ask in a top-level comment instead.
2. Top-level comments only, not inside a finding's thread.

`review` covers `review ultra` too. On AWS CodeCommit, automatic reviews still run on every new PR and on every push to its source branch. The `review` and `autofix` comment commands aren't supported there, so push a new commit to review a CodeCommit PR again.

A command your provider doesn't support is ignored without a reply.

## Troubleshooting

> [accordion] The bot didn't reply to my comment
>
> **Check:**
>
> * The mention is plain text, not inside backticks, a code block, or a quote.
> * Your provider supports the command in the [table above](#provider-support).
> * On Azure DevOps, the **Pull request commented on** service hook exists with **Resource version** set to **2.0**, as described in [Provider authentication](https://docs.cloudthinker.io/guide/code-review/provider-auth.md).
> * Your provider's webhook delivery history shows the comment event was delivered and accepted.

> [accordion] My command was answered as a question
>
> **Cause:** `review` and `review ultra` must be the whole line. **Fix:** post `@cloudthinker-ai review` with nothing after it.

> [accordion] Ultra review won't start from a comment
>
> **Cause:** only the MR/PR author or an assignee can start Ultra, and only while Ultra is available in your workspace. **Fix:** see [Ultra review troubleshooting](https://docs.cloudthinker.io/guide/code-review/ultra-review.md#troubleshooting).

> [accordion] My reply in a finding thread didn't settle the finding
>
> **Cause:** only the MR/PR author or an assignee can settle a finding by replying, and only after the review has finished. **Fix:** ask the author to reply, or mark it resolved in the Review workspace.

## Next steps

> [card] [Review workspace](https://docs.cloudthinker.io/guide/code-review/review-workspace.md)
>
> Run the same actions, plus merge, from inside CloudThinker.

> [card] [Learnings](https://docs.cloudthinker.io/guide/code-review/learnings.md)
>
> See the rules CloudThinker learns from your team's settled findings.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.