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

# Finishing Touches overview

> One-click agentic actions that polish and extend your pull requests or merge requests: fix review findings, resolve merge conflicts, generate unit tests, simplify code, run any custom recipes.

export const Hint = ({type, children, headline, tip, href, cta}) => {
  const TIPS = {
    learnings: {
      headline: "Learnings",
      tip: "Review preferences CodeRabbit learns from your chat conversations and applies automatically to future reviews.",
      cta: "Learn about Learnings",
      href: "/knowledge-base/learnings",
      content: "Learnings"
    },
    walkthrough: {
      headline: "PR Walkthrough",
      tip: "A structured comment posted by CodeRabbit at the top of every pull request, summarizing changes, sequence diagrams, review effort, and more.",
      cta: "Learn about PR Walkthroughs",
      href: "/pr-reviews/walkthroughs",
      content: "Walkthrough"
    },
    "finishing-touches": {
      headline: "Finishing Touches",
      tip: "Post-review agentic actions (Autofix, writing docstrings or unit tests, and more) you trigger from a PR comment or a checkbox in the Walkthrough.",
      cta: "See all Finishing Touches",
      href: "/finishing-touches",
      content: "Finishing Touches"
    },
    "coding-plan": {
      headline: "Coding Plan",
      tip: "A detailed, codebase-aware implementation plan CodeRabbit generates from an issue or description, ready to hand off to any coding agent.",
      cta: "Learn about Coding Plans",
      href: "/plan",
      content: "Coding Plan"
    },
    "knowledge-base": {
      headline: "Knowledge Base",
      tip: "The collected context sources CodeRabbit draws on during reviews: Learnings, Code Guidelines, issue trackers, connected MCP servers, and cross-repo analysis.",
      cta: "Explore the Knowledge Base",
      href: "/knowledge-base",
      content: "Knowledge Base"
    },
    "path-instructions": {
      headline: "Path Instructions",
      tip: "Custom review rules that only apply to files matching a glob pattern, e.g. 'src/controllers/**'.",
      cta: "Configure path instructions",
      href: "/configuration/path-instructions",
      content: "Path Instructions"
    },
    scope: {
      headline: "Scope",
      tip: "A named set of repositories, connections, and spend limits that controls what CodeRabbit Agent can access in a given Slack conversation.",
      cta: "Learn about Scopes",
      href: "/slack-agent/scopes",
      content: "Scope"
    }
  };
  const defaults = TIPS[type] || ({});
  return <Tooltip headline={headline ?? defaults.headline} tip={tip ?? defaults.tip} cta={cta ?? defaults.cta} href={href ?? defaults.href}>
      {children ?? defaults.content}
    </Tooltip>;
};

export const ProPlusPlanBadge = ({tip = "This feature is available as part of the Pro+ plan and Enterprise plan. Please refer to our pricing page for more information about our plans and features.", title = "Pro+ Plan", cta = "Read more", href = "https://coderabbit.ai/pricing", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="shield-plus" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const ProPlanBadge = ({tip = "This feature is available as part of the Pro, Pro+ and Enterprise plans. Please refer to our pricing page for more information about our plans and features.", title = "Pro Plan", cta = "Read more", href = "https://coderabbit.ai/pricing", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="shield-check" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const GitLabBadge = ({tip = "This feature is available on GitLab.", title = "GitLab", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="gitlab" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const GitHubBadge = ({tip = "This feature is available on GitHub and GitHub Enterprise.", title = "GitHub", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="github" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const AllPlatformsBadge = ({tip = "This feature is available on all supported platforms: GitHub, GitLab, Azure DevOps, and Bitbucket.", title = "All Platforms", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="globe" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

<ProPlanBadge />

<ProPlusPlanBadge />

Finishing Touches are a set of post-review actions that CodeRabbit can perform on your behalf. After a review completes, you can trigger a finishing touch by posting a command in the review conversation and, on supported GitHub flows, by checking a box in the Walkthrough comment. CodeRabbit runs the action in a sandboxed environment and delivers the output as a commit or a follow-up pull request, depending on the action and platform.

Look for the **✨ Finishing Touches** section in the CodeRabbit <Hint type="walkthrough" /> comment; it lists every action available for the current review. If a specific Finishing Touch is not present, it might not be available on your platform or included in your plan (some Touches require <ProPlusPlanBadge />).

## Available finishing touches

<CardGroup cols={1}>
  <Card icon="wrench" href="/finishing-touches/autofix" horizontal>
    ### Autofix{"  "}<GitHubBadge /> <GitLabBadge /> | <ProPlanBadge />

    Automatically implement fixes for unresolved CodeRabbit review findings.
    Push a commit to your branch or open a stacked pull request.
  </Card>

  <Card icon="book" href="/finishing-touches/docstrings" horizontal>
    ### Generate docstrings{"  "}<AllPlatformsBadge /> | <ProPlanBadge />

    Scan your PR for functions missing documentation and generate format-aware
    docstrings delivered as a separate PR. Supports 18+ languages.
  </Card>

  <Card icon="git-merge" href="/finishing-touches/resolve-merge-conflict" horizontal>
    ### Resolve merge conflicts{"  "}<GitHubBadge /> <GitLabBadge /> | <ProPlusPlanBadge />

    Detect and resolve merge conflicts by analyzing the intent behind both sets
    of changes, then commit the result as a proper merge commit.
  </Card>

  <Card icon="test-tube" href="/finishing-touches/unit-test-generation" horizontal>
    ### Generate unit tests{"  "}<GitHubBadge /> | <ProPlusPlanBadge />

    Analyze your code changes and produce comprehensive unit tests, including
    edge cases and error conditions, using your project's existing frameworks.
  </Card>

  <Card icon="sparkles" href="/finishing-touches/simplify" horizontal>
    ### Simplify code{"  "}<GitHubBadge /> | <ProPlusPlanBadge />

    Review your changed code for opportunities to simplify, improve reuse,
    quality, and efficiency, then apply targeted improvements automatically.
  </Card>

  <Card icon="scroll" href="/finishing-touches/custom-finishing-touches" horizontal>
    ### Custom recipes{"  "}<GitHubBadge /> | <ProPlusPlanBadge />

    Define reusable, named recipes in your config that encode your team's
    repeated tasks: import ordering, type tightening, changelog entries, and more.
  </Card>
</CardGroup>

## Platform support

| Platform     | Available finishing touches                           |
| ------------ | ----------------------------------------------------- |
| GitHub       | Full support                                          |
| GitLab       | Autofix, Resolve merge conflicts, Generate docstrings |
| Azure DevOps | Generate docstrings                                   |
| Bitbucket    | Generate docstrings                                   |

## How to trigger

Every finishing touch can be triggered in two ways:

| Method             | How                                                                                        | Where                   |
| ------------------ | ------------------------------------------------------------------------------------------ | ----------------------- |
| **Review comment** | Comment a command like `@coderabbitai generate docstrings`                                 | All supported platforms |
| **Checkbox**       | Check the box in the **✨ Finishing Touches** section of the CodeRabbit Walkthrough comment | GitHub PRs              |

See each feature page for the exact commands and platform support details.

## Quick reference

| Finishing touch         | Command                             | Output                                   |
| ----------------------- | ----------------------------------- | ---------------------------------------- |
| Generate docstrings     | `@coderabbitai generate docstrings` | New pull request with docstrings         |
| Generate unit tests     | `@coderabbitai generate unit tests` | Pull request or commit on branch         |
| Simplify code           | `@coderabbitai simplify`            | New pull request or commit on branch     |
| Autofix                 | `@coderabbitai autofix`             | Commit on branch or stacked pull request |
| Custom recipes          | `@coderabbitai run <recipe name>`   | Commit on branch or stacked pull request |
| Resolve merge conflicts | `@coderabbitai fix merge conflict`  | Merge commit on branch                   |

## What's next

<CardGroup cols={1}>
  <Card title="Autofix" href="/finishing-touches/autofix" icon="wrench" horizontal>
    Automatically implement fixes for unresolved review findings and push them as a commit or stacked pull request
  </Card>

  <Card title="Custom recipes" href="/finishing-touches/custom-finishing-touches" icon="scroll" horizontal>
    Define reusable, named recipes that encode your team's repeated tasks into one-click agentic actions
  </Card>

  <Card title="Resolve merge conflicts" href="/finishing-touches/resolve-merge-conflict" icon="git-merge" horizontal>
    Let CodeRabbit analyze the intent behind conflicting changes and commit a clean resolution to your branch
  </Card>
</CardGroup>