# Merge Conflict Surgeon

> |

- **Type:** Skill
- **Install:** `agentstack add skill-latestaiagents-agent-skills-merge-conflict-surgeon`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [latestaiagents](https://agentstack.voostack.com/s/latestaiagents)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [latestaiagents](https://github.com/latestaiagents)
- **Source:** https://github.com/latestaiagents/agent-skills/tree/main/plugins/developer-toolkit/skills/git/merge-conflict-surgeon
- **Website:** https://latestaiagents.com

## Install

```sh
agentstack add skill-latestaiagents-agent-skills-merge-conflict-surgeon
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Merge Conflict Surgeon

Resolve Git merge conflicts systematically and safely.

## When to Use

- `git merge` or `git rebase` fails with conflicts
- You see conflict markers (`>>>>>>`) in files
- `git status` shows "both modified" files
- Merging feature branches into main/develop
- Rebasing a branch onto updated main

## Workflow

### Step 1: Assess the Damage

```bash
# See all conflicted files
git status

# See the full diff of conflicts
git diff --name-only --diff-filter=U
```

List all conflicted files and categorize them:
- **Simple conflicts**: Same file, different lines (auto-resolvable logic)
- **Overlap conflicts**: Same lines modified differently (needs human decision)
- **Delete/modify conflicts**: One side deleted, other modified

### Step 2: Understand Both Sides

For each conflicted file, understand:

```bash
# See what YOUR branch changed
git diff HEAD~1 -- 

# See what the OTHER branch changed
git diff MERGE_HEAD~1 -- 

# See common ancestor
git show :1:  # Base version
git show :2:  # Ours (current branch)
git show :3:  # Theirs (merging branch)
```

### Step 3: Resolve Strategically

**For simple conflicts (different functionality):**
- Keep both changes, ensure they don't break each other
- Run the code mentally or actually to verify

**For overlapping conflicts (same code, different changes):**
1. Understand the INTENT of each change
2. Determine which achieves the goal better
3. Sometimes combine logic from both
4. Never blindly pick "ours" or "theirs"

**For delete/modify conflicts:**
- If deleted intentionally (refactoring), ensure the modification isn't needed
- If deleted accidentally, restore and apply modification

### Step 4: Validate Resolution

```bash
# Mark as resolved
git add 

# Verify no remaining conflicts
git diff --check

# Run tests before completing
npm test  # or your test command

# Complete the merge
git commit  # or git rebase --continue
```

## Resolution Patterns

### Pattern 1: Sequential Changes
```
>>>>>> feature-branch
```
**Resolution:** Keep both - they're independent additions
```javascript
function processUser(user) {
  validateUser(user);
  logUserAccess(user);
```

### Pattern 2: Competing Implementations
```
 x.active).map(x => x.name);
=======
const result = items.reduce((acc, x) => x.active ? [...acc, x.name] : acc, []);
>>>>>>> feature-branch
```
**Resolution:** Choose based on readability/performance needs. The `filter().map()` is clearer.

### Pattern 3: Configuration Changes
```
>>>>>> feature-branch
```
**Resolution:** This is environment-specific. Use environment variables instead:
```javascript
const API_URL = process.env.API_URL || 'https://api.prod.example.com';
```

## Tools

```bash
# Use a merge tool (if configured)
git mergetool

# Abort if things go wrong
git merge --abort
git rebase --abort

# Accept all of one side (use carefully)
git checkout --ours     # Keep your version
git checkout --theirs   # Keep their version
```

## Common Mistakes to Avoid

- Never blindly accept "ours" or "theirs" without understanding the changes
- Don't leave conflict markers in code (>>>>>>)
- Don't skip running tests after resolution
- Don't force push to shared branches after rebase conflicts
- Don't ignore whitespace or formatting conflicts - they can hide real issues

## Emergency Recovery

```bash
# If you messed up the resolution
git checkout -m   # Restore conflict markers

# If you committed a bad resolution
git reset --soft HEAD~1  # Undo commit, keep changes
# Then resolve again

# Nuclear option: start over
git merge --abort  # or git rebase --abort
```

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [latestaiagents](https://github.com/latestaiagents)
- **Source:** [latestaiagents/agent-skills](https://github.com/latestaiagents/agent-skills)
- **License:** MIT
- **Homepage:** https://latestaiagents.com

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-latestaiagents-agent-skills-merge-conflict-surgeon
- Seller: https://agentstack.voostack.com/s/latestaiagents
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.