> ## 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"
    },
    "coderabbit-review": {
      headline: "CodeRabbit Review",
      tip: "An improved code inspection interface that reorganizes a pull request from a flat file list into a structured, layer-by-layer walkthrough with range-specific summaries and diagrams.",
      cta: "Learn about CodeRabbit Review",
      href: "/pr-reviews/coderabbit-review",
      content: "CodeRabbit Review"
    },
    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"
    },
    "coderabbit-agent": {
      headline: "CodeRabbit Agent for Slack",
      tip: "An AI agent built into Slack that investigates issues, generates implementation plans, and opens pull requests right from the Slack threads.",
      cta: "Explore CodeRabbit Agent",
      href: "/slack-agent",
      content: "CodeRabbit Agent"
    },
    "configuration-inheritance": {
      headline: "Configuration Inheritance",
      tip: "A setting that merges configuration values across multiple levels — repository YAML, central YAML, and UI settings — instead of using only the highest-priority source.",
      cta: "Learn about Configuration Inheritance",
      href: "/configuration/configuration-inheritance",
      content: "Configuration Inheritance"
    }
  };
  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 OpenBetaBadge = ({tip = "This feature is currently in open beta. We are actively improving it based on your feedback. If you encounter any issues or have suggestions, please share them on our Discord community or visit the support page.", title = "Open Beta", cta = "Contact support", href = "/support", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="badge-alert" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

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

export const AzureBadge = ({tip = "This feature is available on Azure DevOps.", title = "Azure", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="microsoft" 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 /> <AzureBadge /> <BitbucketBadge title="Bitbucket Cloud" tip="This feature is available on Bitbucket Cloud." /> | <ProPlanBadge />

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

  <Card icon="list-checks" href="/finishing-touches/fix-ci" horizontal>
    ### Fix CI failures{"  "}<GitHubBadge /> | <ProPlusPlanBadge /> <OpenBetaBadge />

    Investigate failing CI checks and open a stacked pull request with the fixes.
  </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 /> <GitLabBadge /> | <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 /> <GitLabBadge /> | <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                | Autofix, Fix CI failures, Generate docstrings, Resolve merge conflicts, Generate unit tests, Simplify code, Custom recipes |
| GitLab                | Autofix, Generate docstrings, Resolve merge conflicts, Generate unit tests, Custom recipes                                 |
| Azure DevOps          | Autofix, Generate docstrings                                                                                               |
| Bitbucket Cloud       | Autofix, Generate docstrings                                                                                               |
| Bitbucket Data Center | Generate docstrings                                                                                                        |

## How to trigger

Available triggers depend on the feature and platform:

| Method             | How                                                                                        | Where                                                        |
| ------------------ | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
| **Review comment** | Comment a command like `@coderabbitai generate docstrings`                                 | Supported command-capable platforms for that Finishing Touch |
| **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         | Trigger                                                | Output                                                                                 |
| ----------------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------- |
| Generate docstrings     | `@coderabbitai generate docstrings`                    | New pull request with docstrings                                                       |
| Generate unit tests     | `@coderabbitai generate unit tests` or GitHub checkbox | Pull request or commit on branch                                                       |
| Simplify code           | GitHub checkbox                                        | New pull request or commit on branch                                                   |
| Autofix                 | `@coderabbitai autofix`                                | Commit on branch or stacked pull request                                               |
| Fix CI failures         | `@coderabbitai fix-ci`                                 | Stacked pull request with fixes                                                        |
| Custom recipes          | `@coderabbitai run <recipe name>` or GitHub checkbox   | Stacked pull request by default; direct commit when the recipe explicitly asks for one |
| 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>