Managing cherry-picks across multiple branches is one of the more tedious aspects of maintaining a large project like U-Boot. When you need to backport dozens of commits from an upstream branch while handling merge commits, resolving conflicts, and creating merge requests, the process can consume hours of developer time.
Today we’re introducing pickman, a new tool in the U-Boot Concept tree that automates cherry-pick workflows using AI assistance. Pickman combines database tracking, GitLab integration, and the Claude Agent SDK to transform what was once a manual, error-prone process into a streamlined, largely automated workflow.
The Problem
U-Boot maintainers regularly need to cherry-pick commits from upstream branches (like us/next) to integration branches. This involves:
- Identifying which commits haven’t been cherry-picked yet
- Handling merge commits that group related changes
- Resolving conflicts when commits don’t apply cleanly
- Creating merge requests for review
- Tracking which commits have been processed
- Responding to review comments on merge requests
With hundreds of commits to process, this becomes a significant time investment. Pickman aims to reduce this burden dramatically.
How Pickman Works
Database Tracking
Pickman maintains a local SQLite database (.pickman.db) that tracks:
- Source branches being monitored
- The last cherry-picked commit for each source
- Individual commit status (pending, applied, conflict, skipped)
- Merge requests created and their status
- Processed review comments
This persistent state allows pickman to resume work across sessions and avoid re-processing commits that have already been handled.
AI-Powered Cherry-Picking
The core innovation in pickman is its use of the Claude Agent SDK to handle the actual cherry-pick operations. When you run pickman apply, the tool:
- Identifies the next set of commits to cherry-pick (typically grouped by merge commit)
- Creates a new branch for the work
- Invokes Claude to perform the cherry-picks
- Claude handles any conflicts that arise, using its understanding of the codebase
- Records the results in the database
- Optionally pushes and creates a GitLab merge request
The AI agent can resolve many common conflicts automatically, understanding context like renamed files, moved code, and API changes. When it encounters something it can’t resolve, it reports the issue clearly.
GitLab Integration
Pickman integrates directly with GitLab to:
- Push branches and create merge requests automatically
- Monitor MR status (open, merged, closed)
- Fetch and process review comments
- Update the database when MRs are merged
This creates a closed loop where pickman can operate continuously, creating an MR, waiting for it to be reviewed and merged, then moving on to the next batch of commits.
Getting Started
Prerequisites
# Install the Claude Agent SDK
pip install claude-agent-sdk
# Install the GitLab API library
pip install python-gitlab
# Set up your GitLab token (or use ~/.config/pickman.conf)
export GITLAB_TOKEN="your-token-here"
Basic Usage
# Add a source branch to track
pickman add-source us/next abc123def
# See what commits are pending
pickman next-set us/next
# Apply the next batch of commits
pickman apply us/next --push
# Check comments on open merge requests, taking action as needed
pickman review --remote ci
# Run continuously until stopped
pickman poll us/next --interval 300
Key Commands
| Command | Description |
|---|---|
add-source | Register a new source branch to track |
compare | Show differences between branches |
next-set | Preview the next commits to be cherry-picked |
apply | Cherry-pick commits using Claude |
step | Process merged MRs and create new ones |
poll | Run step continuously at an interval |
review | Check MRs and handle review comments |
count-merges | Show how many merges remain to process |
The Workflow in Practice
A typical workflow using pickman looks like this:
# Initial setup - track the upstream branch starting from a known commit
$ pickman add-source us/next e7f94bcbcb0
# See how much work there is
$ pickman count-merges us/next
Found 47 merge commits to process
# Preview what's coming next
$ pickman next-set us/next
Next 3 commits to cherry-pick from us/next:
- a1b2c3d: arm: Fix cache alignment issue
- d4e5f6a: drivers: gpio: Add new driver
- b7c8d9e: Merge "ARM improvements"
# Let pickman handle it
$ pickman apply us/next --push --remote ci --target master
Creating branch cherry-a1b2c3d...
Cherry-picking 3 commits...
Pushing to ci...
Creating merge request...
MR created: https://gitlab.com/project/-/merge_requests/123
# Later, process any review comments and continue
$ pickman poll us/next --remote ci --interval 300
The Human Review Loop
While pickman automates much of the cherry-pick process, human oversight remains central to the workflow. The tool is designed to work alongside maintainers, not replace them. Here’s how the review cycle works:
1. MR Creation
When pickman creates a merge request, it includes a detailed description with the source branch, list of commits, and a conversation log showing how Claude handled the cherry-picks. This gives reviewers full visibility into what happened.
2. Human Review
Maintainers review the MR just like any other contribution. They can:
- Examine the diff to verify the cherry-pick is correct
- Check that conflicts were resolved appropriately
- Request changes by leaving comments on specific lines
- Ask questions about why certain decisions were made
3. Automated Comment Handling
When reviewers leave comments, pickman’s review command detects them and invokes Claude to address the feedback:
$ pickman review --remote ci
Found 1 open pickman MR(s):
!123: [pickman] arm: Fix cache alignment issue
Processing comments for MR !123...
Comment from maintainer: "This variable name should match the upstream style"
Addressing comment...
Pushing updated branch...
Claude reads the comment, understands the requested change, modifies the code accordingly, and pushes an updated branch. The merge-request notes are updated with the new transcript. The database tracks which comments have been processed to avoid duplicate work.
4. Iteration
The review cycle can repeat multiple times. Each time a reviewer adds new comments, running pickman review or pickman poll will detect and address them. This continues until the reviewer is satisfied with the changes.
5. Approval and Merge
Once the maintainer is happy with the MR, he or she approves and merges it through GitLab’s normal interface. Pickman detects the merged status on its next step or poll cycle:
$ pickman step us/next --remote ci --target master
Checking for merged MRs...
MR !123 has been merged - updating database
Source us/next: abc123 -> def456
Creating next MR...
Cherry-picking commits from def456...
MR created: https://gitlab.com/project/-/merge_requests/124
The database is updated to record the new “last processed” commit, and pickman automatically moves on to the next batch of commits.
The Continuous Loop
With pickman poll, this entire cycle runs continuously:
$ pickman poll us/next --remote ci --target master --interval 300
Polling every 300 seconds (Ctrl+C to stop)...
[09:00] Checking for merged MRs... none found
[09:00] Checking for review comments... none found
[09:00] Open MR !123 pending review
[09:00] Sleeping 300 seconds...
[09:05] Checking for merged MRs... none found
[09:05] Checking for review comments... 2 new comments on !123
[09:05] Addressing comments...
[09:05] Pushed updates to MR !123
[09:05] Sleeping 300 seconds...
[09:10] Checking for merged MRs... !123 merged!
[09:10] Updated database: us/next now at def456
[09:10] Creating new MR for next commits...
[09:10] MR !124 created
[09:10] Sleeping 300 seconds...
The maintainer simply reviews each MR as it appears, adds comments when needed, and merges when satisfied. Pickman handles everything else automatically, creating a smooth continuous integration pipeline for cherry-picks. If manual intervention is needed, you can typically just make some edits and push an update to the branch.
Handling Merge Commits
One of pickman’s key features is intelligent handling of merge commits. Rather than cherry-picking merge commits directly (which often fails), pickman identifies the individual commits within a merge and processes them as a group. This ensures that related changes stay together in a single merge request.
The tool follows the first-parent chain to identify merge boundaries, which matches the typical workflow of merging topic branches into the main development branch.
History Tracking
Pickman maintains a .pickman-history file in the repo that records each cherry-pick operation, including:
- Date and source branch
- Branch name created
- List of commits processed
- The full conversation log with Claude
This provides an audit trail and helps with debugging when things don’t go as expected.
Future Directions
Pickman is an experimental tool. We will use the next few months to refine it and learn how best to envolve it.
Try It Out
Pickman is available in the U-Boot Concept tree under tools/pickman/. To run the tests:
$ ./tools/pickman/pickman test
We welcome feedback and contributions. If you maintain a branch that requires regular cherry-picks from upstream, give pickman a try and let us know how it works for your workflow.
Pickman was developed with significant assistance from Claude (Anthropic’s AI assistant) for both the implementation and the cherry-pick automation itself.
