סקיל Merge Conflicts
resolving-merge-conflicts הוא סקיל לקלוד קוד שפותר קונפליקטים של מיזוג ו-rebase בגיט בצורה מסודרת ובטוחה. קונפליקט מיזוג הוא אחד הרגעים המלחיצים בפיתוח: שני שינויים נגעו באותו מקום, וצריך להחליט מה נשאר בלי לשבור כלום. הסקיל מוביל תהליך בן חמישה שלבים: הבנת המצב, מציאת המקור והכוונה של כל שינוי, פתרון כל קטע תוך שימור שתי הכוונות, הרצת הבדיקות האוטומטיות, וסיום המיזוג. הוא לעולם לא נוטש את המיזוג ולא ממציא התנהגות חדשה. בפרויקטי הפיתוח שאני מוביל, פתרון קונפליקטים נכון מונע באגים שמסתננים פנימה דרך מיזוג רשלני. במדריך תקבלו את חמשת השלבים, ארבעה תרחישי שימוש, וצ'קליסט לעבודה נכונה.
פקודת התקנה
npx skills add mattpocock/skills@resolving-merge-conflicts -g -y
ההתקנה מתבצעת דרך מנהל החבילות הרשמי של הסקילים בפקודה אחת. הסקיל הוא קובץ Markdown פתוח מהמאגר של מאט פוקוק. אפשר להוריד ולבדוק את הקוד דרך הכפתורים שבראש העמוד.
מה הסקיל כולל?
הסקיל מתעד שיטה בת חמישה שלבים לפתרון קונפליקטים: ראיית המצב, הבנת הכוונה של כל שינוי, פתרון מושכל של כל קטע, הרצת בדיקות, וסיום המיזוג.
קוד הסקיל המלא
---
name: resolving-merge-conflicts
description: "Use when you need to resolve an in-progress git merge/rebase conflict."
---
1. **See the current state** of the merge/rebase. Check git history, and the conflicting files.
2. **Find the primary sources** for each conflict. Understand deeply why each change was made, and what the original intent was. Read the commit messages, check the PRs, check original issues/tickets.
3. **Resolve each hunk.** Preserve both intents where possible. Where incompatible, pick the one matching the merge's stated goal and note the trade-off. Do **not** invent new behaviour. Always resolve; never `--abort`.
4. Discover the project's **automated checks** and run them — typically typecheck, then tests, then format. Fix anything the merge broke.
5. **Finish the merge/rebase.** Stage everything and commit. If rebasing, continue the rebase process until all commits are rebased.
מה זה resolving-merge-conflicts ולמה הסקיל הזה שונה?
resolving-merge-conflicts פותר אחד הרגעים שכל מפתח חושש מהם: קונפליקט מיזוג. כששני שינויים נגעו באותו קוד, גיט עוצר ומבקש להכריע, ופתרון חפוז עלול לאבד עבודה או להכניס באג בשקט. הסקיל מחליף את הלחץ והניחוש בתהליך מסודר שמבטיח החלטה מושכלת.
מה שמייחד אותו הוא ההתעקשות על הבנת הכוונה. לפני שהוא נוגע בקוד, הסקיל מחפש למה כל שינוי נעשה: קורא הודעות commit, בודק PRs וטיקטים, ומבין את המקור. רק אז הוא פותר כל קטע, ומשתדל לשמר את שתי הכוונות. כשהן לא תואמות, הוא בוחר לפי מטרת המיזוג ומציין את הפשרה. הוא לעולם לא ממציא התנהגות חדשה, ותמיד מסיים את המיזוג במקום לנטוש אותו. בסוף הוא מריץ את הבדיקות כדי לוודא שכלום לא נשבר.
ההבדל מורגש באמינות התוצאה. במקום מיזוג שאולי שבר משהו, מקבלים פתרון מנומק שעבר בדיקות. בשילוב עם סקיל codebase-design להבנת מבנה הקוד, ההחלטות בקונפליקט נעשות מתוך הבנה של הארכיטקטורה ולא רק של השורות.
מה resolving-merge-conflicts נותן לקלוד קוד?
הסקיל מוסיף לקלוד שיטה בטוחה לפתרון קונפליקטים: להבין את הכוונה, לשמר אותה, ולוודא שהמיזוג לא שבר כלום.
הבנת הכוונה לפני פתרון
הסקיל לא ממהר לבחור צד. הוא קורא הודעות commit, בודק PRs וטיקטים, ומבין למה כל שינוי נעשה. ההבנה הזאת היא הבסיס להחלטה נכונה, ומונעת איבוד של עבודה חשובה בגלל פתרון חפוז.
שימור שתי הכוונות
כשאפשר, הסקיל שומר על שני השינויים יחד, כי לרוב שניהם נחוצים. רק כשהם באמת מתנגשים הוא מכריע, לפי מטרת המיזוג, ומציין את הפשרה. כך הפתרון מאבד כמה שפחות ערך מכל צד.
הרצת בדיקות אוטומטיות
אחרי הפתרון, הסקיל מגלה את הבדיקות של הפרויקט ומריץ אותן, בדרך כלל typecheck, טסטים ופורמט. אם המיזוג שבר משהו, הוא מתקן. כך הקונפליקט נסגר עם ודאות שהקוד עדיין עובד, ולא רק שהוא מתקמפל.
סיום מסודר, בלי נטישה
הסקיל תמיד מסיים את המיזוג או ה-rebase, ולעולם לא נוטש אותו. הוא מסדר את הקבצים, מבצע commit, וב-rebase ממשיך עד שכל ה-commits עברו. כך לא נשארים תקועים באמצע מצב מיזוג מבלבל.
ארבע היכולות הופכות קונפליקט מרגע מלחיץ לתהליך בטוח. בעבודות שלי, פתרון מסודר של קונפליקטים מנע באגים שהיו מסתננים פנימה דרך מיזוג רשלני, וחסך שעות של חיפוש אחר כך.
למי הסקיל הזה מתאים?
מפתחים שעובדים בצוות: זה הקהל המובהק. כשכמה אנשים נוגעים באותו קוד, קונפליקטים הם בלתי נמנעים. הסקיל הופך אותם לתהליך בטוח. השילוב עם סקיל requesting-code-review מבטיח שגם הפתרון נבדק.
מובילי פיתוח: מיזוגים מורכבים של ענפים ארוכים הם נקודת סיכון. הסקיל מבטיח שכל קונפליקט נפתר מתוך הבנת הכוונה, וזה שומר על איכות הקוד גם אחרי מיזוגים גדולים.
מפתחים שעובדים עם סוכני AI: כשסוכן מבצע מיזוג, חשוב שיהיה לו תהליך ברור ובטוח. הסקיל נותן לקלוד את המשמעת לפתור קונפליקטים בלי להמציא התנהגות או לנטוש את המיזוג.
מתחזקי קוד פתוח: מיזוג תרומות מבחוץ כרוך לעיתים בקונפליקטים. הסקיל עוזר לפתור אותם תוך כיבוד הכוונה של התורם. גם בעבודות אוטומציה שלי, מיזוג מסודר של שינויים שומר על מערכת יציבה.
מפתחי סולו: גם כשעובדים לבד, rebase של ענף ארוך יוצר קונפליקטים. הסקיל מוביל אותם לפתרון בטוח בלי הלחץ של להסתבך באמצע.
מי שפחות יתאים: קונפליקט טריוויאלי של שורה אחת ברורה לא צריך תהליך מלא. הסקיל מבריק דווקא בקונפליקטים מורכבים, במיזוגים גדולים, או כשחשוב להבין למה כל שינוי נעשה.
איך resolving-merge-conflicts עזר לי בפרויקטים אמיתיים
מיזוג ענף ארוך בלי לאבד עבודה
ענף שפותח שבועיים יצר קונפליקטים רבים מול ה-main. הסקיל קרא את הודעות ה-commit של כל צד, הבין את הכוונות, ושימר את שתיהן היכן שאפשר. במקום פתרון חפוז שמאבד עבודה, המיזוג שמר על כל השינויים החשובים.
זיהוי פשרה כשהשינויים התנגשו
שני שינויים באמת התנגשו ולא יכלו לדור יחד. הסקיל הכריע לפי מטרת המיזוג, ובחר את הצד התואם, אבל ציין במפורש את הפשרה. כך ההחלטה הייתה שקופה, וידעתי בדיוק מה ויתרנו עליו ולמה.
בדיקות שתפסו שבירה במיזוג
אחרי פתרון הקונפליקטים, הסקיל הריץ את הבדיקות של הפרויקט. הן תפסו מקום שבו המיזוג שבר התנהגות, והסקיל תיקן אותו לפני הסיום. בלי השלב הזה, הבאג היה מסתנן פנימה בשקט.
rebase מורכב שהסתיים נקי
rebase של כמה commits יצר קונפליקטים בכל אחד. הסקיל פתר אותם אחד-אחד והמשיך את התהליך עד הסוף, בלי לנטוש באמצע. במקום להישאר תקוע במצב rebase מבלבל, יצאתי עם היסטוריה נקייה ומסודרת.
ארבעת המקרים מראים שהסקיל הופך קונפליקט מסיכון להזדמנות לעשות סדר. כשמבינים את הכוונה, משמרים אותה, ומריצים בדיקות, המיזוג נסגר בבטחה ובלי באגים שמסתננים פנימה.
סיכום
סקיל resolving-merge-conflicts הוא כלי מצוין לכל מי שעובד עם גיט בצוות. הוא הופך את הרגע המלחיץ של קונפליקט מיזוג לתהליך בטוח בן חמישה שלבים, שמבוסס על הבנת הכוונה, שימורה, והרצת בדיקות לפני הסיום.
אם אתם מתחילים, בפעם הבאה שתיתקעו בקונפליקט מיזוג, בקשו מקלוד לפתור אותו עם הסקיל. תנו לו להבין את הכוונות לפני שהוא מכריע. תרגישו את ההבדל בין פתרון מנומק לבין ניחוש לחוץ.
בפוסטים הבאים אמשיך לסקור סקילים שמשדרגים את הבטיחות ואיכות הפיתוח. האתר של דביר נעמן מרכז את כל הכלים, השיטות והליווי שאני מציע לעסקים שרוצים לבנות תוכנה אמינה עם בינה מלאכותית.
שיתוף הסקיל
שאלות ותשובות
מה זה בעצם הסקיל resolving-merge-conflicts?
זה סקיל לקלוד קוד שפותר קונפליקטים של מיזוג ו-rebase בגיט בצורה מסודרת. הוא מוביל תהליך בן חמישה שלבים: הבנת המצב, מציאת הכוונה של כל שינוי, פתרון כל קטע, הרצת בדיקות, וסיום המיזוג. המטרה היא פתרון בטוח שלא מאבד עבודה ולא מכניס באגים.
מה זה קונפליקט מיזוג?
קונפליקט מיזוג קורה כששני שינויים נגעו באותו חלק בקוד, וגיט לא יודע איזה מהם לשמור. הוא עוצר ומבקש ממכם להכריע. פתרון חפוז עלול לאבד עבודה או להכניס באג. הסקיל מטפל בדיוק במצב הזה, בצורה מסודרת ומבוססת הבנה.
איך מתקינים את הסקיל בקלוד קוד?
בפקודה אחת דרך מנהל החבילות הרשמי של הסקילים, כפי שמופיע בקופסת ההתקנה למעלה. הסקיל הוא קובץ Markdown פתוח מהמאגר של מאט פוקוק. כשאתם תקועים בקונפליקט מיזוג או rebase, מפעילים אותו והוא מוביל את הפתרון שלב אחר שלב.
איך הסקיל מחליט מה לשמור בקונפליקט?
קודם הוא מבין את הכוונה של כל שינוי: קורא הודעות commit, בודק PRs וטיקטים. אחר כך הוא משתדל לשמר את שתי הכוונות יחד, כי לרוב שתיהן נחוצות. רק כשהן באמת מתנגשות הוא מכריע לפי מטרת המיזוג, ומציין את הפשרה במפורש. הוא לעולם לא ממציא התנהגות חדשה.
האם הסקיל מריץ בדיקות אחרי הפתרון?
כן, וזה חלק חשוב מהתהליך. אחרי שהקונפליקטים נפתרו, הסקיל מגלה את הבדיקות האוטומטיות של הפרויקט ומריץ אותן, בדרך כלל typecheck, טסטים ופורמט. אם המיזוג שבר משהו, הוא מתקן. כך הקונפליקט נסגר עם ודאות שהקוד באמת עובד, ולא רק מתקמפל.
האם הסקיל עלול לנטוש את המיזוג אם זה מסובך?
לא. אחד הכללים שלו הוא תמיד לפתור ולעולם לא לבצע abort. גם במיזוג או rebase מורכב, הוא ממשיך עד הסוף: מסדר את הקבצים, מבצע commit, וב-rebase ממשיך עד שכל ה-commits עברו. כך לא נשארים תקועים באמצע מצב מיזוג מבלבל.
האם הסקיל מתאים גם ל-rebase ולא רק ל-merge?
כן, הוא מטפל בשניהם. גם ב-rebase, שבו הקונפליקטים מופיעים commit אחרי commit, הסקיל פותר כל אחד וממשיך את התהליך עד הסוף. כך מקבלים היסטוריה נקייה ומסודרת בלי להיתקע, בדיוק כמו במיזוג רגיל.
האם הסקיל מתאים גם למפתחים מנוסים?
בהחלט. גם מפתחים מנוסים נלחצים מקונפליקטים מורכבים או מאבדים פרטים במיזוגים גדולים. הסקיל מביא משמעת של הבנת כוונה ובדיקות, מה שמעלה את איכות הפתרון לכולם. הוא חוסך זמן ומונע באגים, גם למי שכבר מכיר גיט היטב.
