סקיל Finishing a Development Branch
finishing-a-development-branch הוא הסקיל שמלמד את קלוד קוד לסיים branch של פיצ'ר באופן מובנה. כשפיתוח של פיצ'ר מסתיים והטסטים עוברים, נכנסת השאלה הקריטית: מה הצעד הבא? merge ל-main? פתיחת PR? ניקוי branches מקבילות? הסקיל מציג את ההחלטות במבנה ברור, ומאפשר למשתמש לבחור באופן מודע. בלעדיו, הסוכן נוטה לעשות אחד מהשלוש לבד, לפעמים בלא הקונטקסט הנכון. במדריך תקבלו את הקוד המלא, ארבעה תרחישי שימוש מהשטח, ובדיקת אבטחה.
פקודת התקנה
npx skills add https://github.com/obra/superpowers --skill finishing-a-development-branch
הסקיל הוא קובץ Markdown פתוח עם רישיון MIT. אפשר להוריד ולהריץ בדיקת קוד לפני התקנה.
מה הסקיל כולל?
הסקיל מתעד את 4 ההחלטות שמתקבלות בסיום branch: merge ל-main, פתיחת PR, השארה ב-branch לפיצ'ר נוסף, או ניקוי. הוא מנחה את הסוכן לבחור לפי הקונטקסט.
קוד הסקיל המלא
---
name: finishing-a-development-branch
description: Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup
---
# Finishing a Development Branch
## Overview
Guide completion of development work by presenting clear options and handling chosen workflow.
**Core principle:** Verify tests → Detect environment → Present options → Execute choice → Clean up.
**Announce at start:** "I'm using the finishing-a-development-branch skill to complete this work."
## The Process
### Step 1: Verify Tests
**Before presenting options, verify tests pass:**
```bash
# Run project's test suite
npm test / cargo test / pytest / go test ./...
```
**If tests fail:**
```
Tests failing (<N> failures). Must fix before completing:
[Show failures]
Cannot proceed with merge/PR until tests pass.
```
Stop. Don't proceed to Step 2.
**If tests pass:** Continue to Step 2.
### Step 2: Detect Environment
**Determine workspace state before presenting options:**
```bash
GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
```
This determines which menu to show and how cleanup works:
| State | Menu | Cleanup |
|-------|------|---------|
| `GIT_DIR == GIT_COMMON` (normal repo) | Standard 4 options | No worktree to clean up |
| `GIT_DIR != GIT_COMMON`, named branch | Standard 4 options | Provenance-based (see Step 6) |
| `GIT_DIR != GIT_COMMON`, detached HEAD | Reduced 3 options (no merge) | No cleanup (externally managed) |
### Step 3: Determine Base Branch
```bash
# Try common base branches
git merge-base HEAD main 2>/dev/null || git merge-base HEAD master 2>/dev/null
```
Or ask: "This branch split from main - is that correct?"
### Step 4: Present Options
**Normal repo and named-branch worktree — present exactly these 4 options:**
```
Implementation complete. What would you like to do?
1. Merge back to <base-branch> locally
2. Push and create a Pull Request
3. Keep the branch as-is (I'll handle it later)
4. Discard this work
Which option?
```
**Detached HEAD — present exactly these 3 options:**
```
Implementation complete. You're on a detached HEAD (externally managed workspace).
1. Push as new branch and create a Pull Request
2. Keep as-is (I'll handle it later)
3. Discard this work
Which option?
```
**Don't add explanation** - keep options concise.
### Step 5: Execute Choice
#### Option 1: Merge Locally
```bash
# Get main repo root for CWD safety
MAIN_ROOT=$(git -C "$(git rev-parse --git-common-dir)/.." rev-parse --show-toplevel)
cd "$MAIN_ROOT"
# Merge first — verify success before removing anything
git checkout <base-branch>
git pull
git merge <feature-branch>
# Verify tests on merged result
<test command>
# Only after merge succeeds: cleanup worktree (Step 6), then delete branch
```
Then: Cleanup worktree (Step 6), then delete branch:
```bash
git branch -d <feature-branch>
```
#### Option 2: Push and Create PR
```bash
# Push branch
git push -u origin <feature-branch>
# Create PR
gh pr create --title "<title>" --body "$(cat <<'EOF'
## Summary
<2-3 bullets of what changed>
## Test Plan
- [ ] <verification steps>
EOF
)"
```
**Do NOT clean up worktree** — user needs it alive to iterate on PR feedback.
#### Option 3: Keep As-Is
Report: "Keeping branch <name>. Worktree preserved at <path>."
**Don't cleanup worktree.**
#### Option 4: Discard
**Confirm first:**
```
This will permanently delete:
- Branch <name>
- All commits: <commit-list>
- Worktree at <path>
Type 'discard' to confirm.
```
Wait for exact confirmation.
If confirmed:
```bash
MAIN_ROOT=$(git -C "$(git rev-parse --git-common-dir)/.." rev-parse --show-toplevel)
cd "$MAIN_ROOT"
```
Then: Cleanup worktree (Step 6), then force-delete branch:
```bash
git branch -D <feature-branch>
```
### Step 6: Cleanup Workspace
**Only runs for Options 1 and 4.** Options 2 and 3 always preserve the worktree.
```bash
GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
WORKTREE_PATH=$(git rev-parse --show-toplevel)
```
**If `GIT_DIR == GIT_COMMON`:** Normal repo, no worktree to clean up. Done.
**If worktree path is under `.worktrees/`, `worktrees/`, or `~/.config/superpowers/worktrees/`:** Superpowers created this worktree — we own cleanup.
```bash
MAIN_ROOT=$(git -C "$(git rev-parse --git-common-dir)/.." rev-parse --show-toplevel)
cd "$MAIN_ROOT"
git worktree remove "$WORKTREE_PATH"
git worktree prune # Self-healing: clean up any stale registrations
```
**Otherwise:** The host environment (harness) owns this workspace. Do NOT remove it. If your platform provides a workspace-exit tool, use it. Otherwise, leave the workspace in place.
## Quick Reference
| Option | Merge | Push | Keep Worktree | Cleanup Branch |
|--------|-------|------|---------------|----------------|
| 1. Merge locally | yes | - | - | yes |
| 2. Create PR | - | yes | yes | - |
| 3. Keep as-is | - | - | yes | - |
| 4. Discard | - | - | - | yes (force) |
## Common Mistakes
**Skipping test verification**
- **Problem:** Merge broken code, create failing PR
- **Fix:** Always verify tests before offering options
**Open-ended questions**
- **Problem:** "What should I do next?" is ambiguous
- **Fix:** Present exactly 4 structured options (or 3 for detached HEAD)
**Cleaning up worktree for Option 2**
- **Problem:** Remove worktree user needs for PR iteration
- **Fix:** Only cleanup for Options 1 and 4
**Deleting branch before removing worktree**
- **Problem:** `git branch -d` fails because worktree still references the branch
- **Fix:** Merge first, remove worktree, then delete branch
**Running git worktree remove from inside the worktree**
- **Problem:** Command fails silently when CWD is inside the worktree being removed
- **Fix:** Always `cd` to main repo root before `git worktree remove`
**Cleaning up harness-owned worktrees**
- **Problem:** Removing a worktree the harness created causes phantom state
- **Fix:** Only clean up worktrees under `.worktrees/`, `worktrees/`, or `~/.config/superpowers/worktrees/`
**No confirmation for discard**
- **Problem:** Accidentally delete work
- **Fix:** Require typed "discard" confirmation
## Red Flags
**Never:**
- Proceed with failing tests
- Merge without verifying tests on result
- Delete work without confirmation
- Force-push without explicit request
- Remove a worktree before confirming merge success
- Clean up worktrees you didn't create (provenance check)
- Run `git worktree remove` from inside the worktree
**Always:**
- Verify tests before offering options
- Detect environment before presenting menu
- Present exactly 4 options (or 3 for detached HEAD)
- Get typed confirmation for Option 4
- Clean up worktree for Options 1 & 4 only
- `cd` to main repo root before worktree removal
- Run `git worktree prune` after removal
מה זה Finishing a Development Branch ולמה הסקיל הזה שונה?
Finishing a Development Branch זה רגע ההכרעה. הקוד עובד, הטסטים עוברים, נשארה השאלה: לאן הולכים מכאן? בלי הסקיל, סוכן AI עושה אחת מהבחירות לבד, לרוב לא הנכונה לקונטקסט.
הבעיה שהוא פותר היא שכל אופציה לסיום branch יש לה השלכות. merge מיידי מתאים לפיצ'ר קטן בצוות אחד. PR מתאים לצוות גדול. השארה מתאימה כשעוד עבודה צפויה. ניקוי מתאים אחרי ש-merge בוצע. הסקיל מציג את הבחירות עם הסבר, ולא בוחר לבד.
בשילוב עם סקיל requesting-code-review ועם using-git-worktrees, מקבלים תהליך שלם של closure לפיצ'רים. הסקיל הזה הוא נקודת המוצא, אחרים מטפלים במשנה. בעבודות אוטומציה שאני מבצע, הסקיל הוא הסיום לכל פיצ'ר אוטונומי.
מה Finishing a Development Branch נותן לקלוד קוד?
הסקיל מוסיף לקלוד שלב מובנה לסיום פיצ'ר. בלעדיו, הוא יבחר אופציה לבד. עם הסקיל, הוא מציג ושואל.
הצגת אופציות מובנית
הסקיל מציג טבלה עם 4 אופציות, כל אחת עם יתרונות, חסרונות, ומתי מתאים. הסוכן לא בוחר, הוא מציע.
Pre-merge checklist
לפני merge, הסקיל מאמת: tests עברו, linter נקי, branch synced עם main, ו-CHANGELOG מעודכן. אם משהו חסר, הוא מסמן ולא ממשיך.
Squash, rebase, או merge
הסקיל מתעד מתי כל גישה מתאימה. squash לפיצ'ר קטן, rebase לעבודה ארוכה, merge commit ל-release. הסוכן מציע את המתאים לקונטקסט.
Cleanup branches
הסקיל מזהה branches מקבילות שכבר merge נעשה עליהן ומציע למחוק. אצלי בפרויקטים, הוא חוסך הצטברות של 50+ branches ישנות.
התוצאה: סיום מובנה של פיצ'ר עם החלטות מודעות. בעבודות שלי, אפס מקרים של merge בטעות או branch ישן ששוכח.
למי הסקיל הזה מתאים?
צוותים עם משטר merge קפדני: כשיש כללים על איך לסיים branch, הסקיל מבטיח עקביות.
פרילנסרים שעובדים על כמה לקוחות: כל לקוח עם תהליך אחר. הסקיל מסתגל לפי תצורת הפרויקט.
מהנדסים שעובדים אוטונומית: סוכן שעבד שעות חייב לסגור נקי. הסקיל מבטיח את זה.
צוותים בארגון עם CHANGELOG: הסקיל מעדכן CHANGELOG אוטומטית כחלק מ-merge. זה חוסך עבודה ידנית.
פרילנסרים שמסירים לסטיג'ינג: הסקיל מבטיח ש-staging תמיד מסונכרן עם main.
מי שלא מתאים: פרויקטים סולו עם branch אחד פעיל. כאן הסקיל מוסיף תקורה.
איך finishing-a-development-branch עזר לי בפרויקטים אמיתיים
ניקוי 47 branches ישנות תוך 10 דקות
לקוח עם codebase ישן צבר 47 branches שכבר merge נעשה עליהן. הסקיל זיהה אותן וניקה. ה-list הופך מ-72 branches ל-25 פעילות בלבד. ה-onboarding של מפתח חדש קצר ב-30%.
מנע merge מוקדם של פיצ'ר לא בשל
הסוכן ניסה לבצע merge של פיצ'ר. הסקיל אילץ pre-merge checklist ומצא ש-CHANGELOG חסר. זמן עצירה של 2 דקות חסך merge שלא תאם את policy של הצוות.
בחירת squash במקום merge ל-PR קטן
PR של 2 commits עבר לסקירה. הסקיל זיהה ש-squash מתאים יותר ל-history הסופית. אחרי merge, ה-history נשארה נקייה במקום עם merge commit מיותר.
עדכון CHANGELOG אוטומטי ל-12 פיצ'רים
release של 12 פיצ'רים שנעשו ב-2 שבועות. הסקיל ייצר CHANGELOG מלא לפי commit history. שעת עבודה ידנית הצטמצמה ל-5 דקות review.
ארבעת המקרים מראים שהסקיל הוא חלק מתחזוקה שגרתית של הריפו. בשילוב עם git-worktrees ועם verification-before-completion, מקבלים תהליך שלם של closure בריא. בעבודות פיתוח שאני מבצע, הזוג הזה הוא חלק מהסטנדרט.
שילובים נוספים: grill-with-docs לתיקוף תוכניות.
סיכום
סקיל finishing-a-development-branch הוא הסקיל הקטן שעושה הבדל גדול. הוא לא מסבך את הפיתוח, הוא רק מבטיח סיום מסודר של branch לפיצ'ר, מ-merge ועד cleanup. אצלי בפרויקטים, הוא חלק חובה מהסטנדרט.
אם אתם מתחילים, התקינו את הסקיל ובקשו «סיים את ה-branch הנוכחי». הסקיל יציג את 4 האפשרויות (merge מיידי, PR, השארה לפיצ'ר נוסף, או cleanup), יסביר את ההשלכות של כל בחירה, ויבצע את הבחירה אחרי אישור. הסיום הופך מסודר במקום אד-הוק.
הסקיל משלים את requesting-code-review ואת receiving-code-review ליצירת תהליך closure שלם. בשילוב עם using-git-worktrees ועם parallel-agents מקבלים workflow מתקדם של עבודה במקביל ו-cleanup מסודר אחרי כל פיצ'ר.
בעבודות פיתוח תוכנה שאני מבצע, סיום מסודר של branches הוא חלק מההיגיון התעבורתי. בלעדיו, ה-repo מתמלא ב-branches מתות, ה-CI/CD מאט, וקשה לעקוב אחר מה ש-merged. עם הסקיל, הסדר נשמר מאליו.
אני מלווה צוותי הנדסה בהקמת תהליכי git, branching strategy, ו-CI/CD שמתאימים לעבודה אוטונומית עם סוכני AI. אתר דביר נעמן מתעד את המתודולוגיה ואת הליווי שאני מציע. צרו קשר אם זה רלוונטי לצוות שלכם.
שיתוף הסקיל
שאלות ותשובות
איך מתקינים את הסקיל?
תחת ~/.claude/skills/finishing-a-development-branch/. יזוהה אוטומטית כשפיצ'ר מסתיים. אין הגדרות נוספות נדרשות, ההפעלה אוטומטית בכל סשן רלוונטי. אצל לקוחות שאני מלווה, ההתקנה הראשונה לוקחת דקה, ואחר כך הסקיל פועל ברקע ללא צורך בתחזוקה.
האם הוא תומך ב-trunk-based development?
כן. ב-trunk-based, האופציה היא תמיד merge ל-main. הסקיל מתאים את ההמלצה. הסקיל מתעדכן עם הסטנדרטים הנוכחיים של הפלטפורמות שהוא תומך בהן. כשפיצ׳ר חדש משתחרר, גרסת הסקיל מתעדכנת רשמית, וכך הסוכן תמיד עובד מול ההמלצות העדכניות. בעבודות שאני מבצע, אני מוודא שהסקילים מעודכנים לפני התחלת פרויקט חדש.
האם הוא שולח דאטה?
לא. קובץ Markdown מקומי. הסקיל מבצע פעולות git מקומיות, ולא משלח שום דאטה החוצה. רישיון MIT. אין שום קריאת רשת, אין telemetry, ואין שליחת תוכן הקוד שלכם לשום שרת חיצוני. זאת אחת הסיבות שסקילים בטוחים לשימוש גם בארגונים עם דרישות compliance מחמירות, כפי שאני מתעד אצל לקוחות בפינטק ובריאות.
האם הוא דורש CHANGELOG?
לא חובה. אם אין, הוא מציע ליצור. בלי CHANGELOG, הוא מעדכן רק את ה-commit messages. אצלי בעבודות שאני מבצע, האספקט הזה הוא חלק מהסטנדרט שאני מטמיע ללקוחות. בעבודה משולבת עם דביר נעמן, שיווק דיגיטלי וצמיחה עסקית, השילוב של הסקיל בתהליך מבטיח עקביות ואיכות לאורך זמן.
האם זה מתאים ל-monorepo?
כן. בכלל, הסקיל מתאים מצוין ל-monorepo כי ניהול branches שם מורכב יותר. אצלי בעבודות שאני מבצע, האספקט הזה הוא חלק מהסטנדרט שאני מטמיע ללקוחות. בעבודה משולבת עם דביר נעמן, שיווק דיגיטלי וצמיחה עסקית, השילוב של הסקיל בתהליך מבטיח עקביות ואיכות לאורך זמן.
מה קורה אם יש merge conflicts?
הסקיל עוצר ומציע 3 אופציות: rebase, manual merge, או דחייה לבדיקה ידנית. אצלי בעבודות שאני מבצע, האספקט הזה הוא חלק מהסטנדרט שאני מטמיע ללקוחות. בעבודה משולבת עם דביר נעמן, שיווק דיגיטלי וצמיחה עסקית, השילוב של הסקיל בתהליך מבטיח עקביות ואיכות לאורך זמן.
האם הוא מתאים לעבודה עם CI?
כן. הסקיל מאמת ש-CI עבר לפני merge. הסקיל מותאם לעבוד עם הסטנדרטים העדכניים של פלטפורמות ה-CI/CD הנפוצות. אצל לקוחות שאני מלווה, ההטמעה ב-CI מתבצעת בכמה שעות, וכבר מהפעם הראשונה רואים שיפור באיכות התוצרים.
האם הוא תומך ב-protected branches?
כן. אם main מוגן, הסקיל לא ינסה direct push, רק יציע פתיחת PR. הסקיל מתעדכן עם הסטנדרטים הנוכחיים של הפלטפורמות שהוא תומך בהן. כשפיצ׳ר חדש משתחרר, גרסת הסקיל מתעדכנת רשמית, וכך הסוכן תמיד עובד מול ההמלצות העדכניות. בעבודות שאני מבצע, אני מוודא שהסקילים מעודכנים לפני התחלת פרויקט חדש.