Why do that stuff manually when you have Custom Finishing Touch recipes?

Go check your pull requests real quick.

If you’re like most devs, there’s at least one PR in there that’s almost done. The feature works, the logic makes sense, tests pass locally. If someone asked whether it was finished, you’d probably say, “Yeah... pretty much.” And yet it’s still open.

Picture above courtesy of https://dev.to/linearb/dev-interrupteds-best-programmer-humor-36ck

Why? Because every team has the same recurring review comments. Enforce import ordering. Tighten TypeScript types. Apply project-specific conventions. Add missing docstrings. The list goes on.

These tasks are important, but they’re also repetitive and they’re the reason PRs sit open longer than they need to.

What if you could generate what’s missing and open a reviewable change, all from within the PR itself?

What are Finishing Touches?

Let’s do a short terminology intro before we dive into the core. Finishing Touches is a set of features that includes Custom Finishing Touch recipes. At a high-level those are one-click agentic actions that polish and extend your PRs handling the following:

• Resolving merge conflicts

• Generating unit tests

• Automatically implementing fixes for review findings

• Simplifying code

• Generating docstrings

And finally, running custom agentic code on your PRs, which this blog is all about.

Introducing: Custom Finishing Touch recipes

Every team has its own recurring cleanup patterns - things that standard linters don’t catch and that come up in review after review. Custom Finishing Touch recipes let you define reusable, named instructions that run agentic code changes against your pull requests.

They’re perfect if you:

• See the same hygiene comments across PRs.

• Enforce project-specific conventions beyond standard linters.

• Want fewer back-and-forth review cycles.

• Don’t want to slow down your developers

How it works

You can set it up in two different ways:

• Through CodeRabbit YAML File

You define recipes inside .coderabbit.yaml like this:

reviews:
  finishing_touches:
    custom:
      - name: "cleanup stale imports"
        instructions: |
          Scan the changed files for unused imports and remove them.
          Preserve imports used in type positions.
          Do not reorder existing imports; only remove stale ones.

Then you trigger it directly in a pull request:

@coderabbitai run cleanup stale imports

CodeRabbit runs the recipe and opens a new pull request with the result. You review it like any other PR.

Want to experiment before committing a recipe to your config? Run an ad hoc evaluation:

@coderabbitai evaluate custom finishing touch --name "sort imports" --instructions "Sort all import statements alphabetically within each import group in the changed files."

Same execution model, nothing persisted, which is useful for one-off tasks and testing ideas before you formalize them.

• Through CodeRabbit Web Interface

Click on Organization Settings in the left sidebar and head to Finishing touches. From there you’ll be able to add your custom recipes.

Core tips

You can define up to five recipes per repository. Recipe names are case-insensitive and you can disable a recipe without deleting it.

What actually happens behind the scenes

When you trigger a recipe, CodeRabbit does more than a simple script. It clones your repository into an isolated sandbox and provides the agent with full PR context, including the title, description, summary and objectives.

It also pulls in your global coding guidelines from reviews.path_instructions, so the agent follows the same conventions your team already agreed on.

From there, it has controlled repository access through Read, Write, Edit, Glob, Grep, and Bash tools. It executes your instructions and opens a new pull request against your branch with the proposed changes.

Nothing merges automatically or silently modifies your branch. You review the diff like any other PR and decide what ships.

Try it out

Custom Finishing Touch recipes are available on GitHub in early access for Pro plan users, with GitLab and Bitbucket support coming soon.

If your team keeps leaving the same cleanup comments in pull requests, give it a try.

Pointing out what's missing is only half the job. If the cleanup is still manual, the bottleneck is still there. We want to get rid of it.

Get started with CodeRabbit.