How to fix error: could not apply abc1234... commit message in Git

First, understand which commit caused the conflict and which files are affected:

# See the current state
git status

This will show:
- That you are currently rebasing
- Which commit is being applied
- Which files have conflicts (marked as "both modified")
- Instructions on how to proceed

Example output:

interactive rebase in progress; onto def5678
Last command done (3 commands done):
   pick abc1234 Add new feature
You are currently rebasing branch 'feature' on 'def5678'.
  (fix conflicts and then run "git rebase --continue")
  (use "git rebase --skip" to skip this patch)
  (use "git rebase --abort" to check out the original branch)

Unmerged paths:
  (use "git restore --staged <file>..." to unstage)
  (use "git add <file>..." to mark resolution)
        both modified:   src/app.js

Look at the conflicting files to understand what needs to be resolved:

# See the diff of the conflicting commit
git show HEAD

# See what the incoming commit is trying to change
git show REBASE_HEAD

# Compare your changes with the target branch
git diff HEAD REBASE_HEAD

Open the conflicting files in your editor. You'll see conflict markers like:

<<<<<<< HEAD
// This is the code from the target branch (where you're rebasing onto)
const result = calculate(x, y);
=======
// This is your change from the commit being applied
const result = compute(x, y, z);
>>>>>>> abc1234 (Add new feature)

The section between <<<<<<< HEAD and ======= is the current state.
The section between ======= and >>>>>>> is your incoming change.

Edit each conflicting file to resolve the conflicts:

1. Remove the conflict markers (<<<<<<<, =======, >>>>>>>)
2. Keep the correct code - this might be one version, the other, or a combination
3. Test your changes if possible

Example resolution:

// After resolving - keep the combined logic
const result = compute(x, y, z);

For multiple files, resolve each one:

# List all conflicted files
git diff --name-only --diff-filter=U

# Use your preferred editor/IDE
code src/app.js

Many IDEs have built-in merge conflict resolution tools:
- VS Code: Shows "Accept Current", "Accept Incoming", "Accept Both" buttons
- IntelliJ/WebStorm: Has a dedicated merge conflict resolver
- Git mergetool: git mergetool opens configured merge tool

After resolving all conflicts, stage the files and continue the rebase:

# Stage the resolved files
git add src/app.js

# Or stage all resolved files at once
git add .

# Continue the rebase
git rebase --continue

If there are more commits to apply, Git will continue with the next one. You may encounter additional conflicts if later commits also have issues.

If the commit message editor opens:
Git may open your editor to confirm or modify the commit message. Save and close to proceed.

Verify the rebase completed:

git status
# Should show "nothing to commit, working tree clean"
# and you should be on your branch, not in a rebase state

If the commit's changes are no longer needed (perhaps they were already incorporated differently), you can skip it:

git rebase --skip

When to skip a commit:
- The changes in the commit are already present in the target branch
- The commit was a temporary fix that's been superseded
- The commit only makes sense in the old context

Warning: Skipping means ALL changes from that commit are discarded. Make sure you understand what you're losing.

Check what would be skipped:

# See the commit that would be skipped
git log -1 REBASE_HEAD

# See the actual changes
git show REBASE_HEAD

If the rebase is too complex or you need to approach it differently, abort:

git rebase --abort

This returns your branch to its exact state before you started the rebase. No changes are lost.

When to abort:
- The conflicts are too complex to resolve quickly
- You realize you're rebasing onto the wrong branch
- You need to prepare your branch differently first
- You want to try a different approach (like merge instead)

After aborting, consider:

# Maybe use merge instead of rebase
git merge origin/main

# Or break up your changes into smaller commits first
git reset --soft HEAD~3  # Undo last 3 commits but keep changes
# Then commit more granularly and try rebase again

Enable Git's "reuse recorded resolution" feature to automatically resolve conflicts you've fixed before:

# Enable rerere globally
git config --global rerere.enabled true

How rerere works:
1. When you resolve a conflict, Git records how you resolved it
2. If the same conflict appears again (same content on both sides), Git automatically applies your previous resolution
3. Very useful for long-running branches that get rebased repeatedly

View recorded resolutions:

# See recorded conflict resolutions
ls .git/rr-cache/

# Forget a specific resolution if it was wrong
git rerere forget <pathspec>

This is especially helpful in workflows where you frequently rebase feature branches onto an evolving main branch.