Base44, GitHub ו-Claude: לעבוד נכון עם שלושתם
בנית אפליקציה ב-Base44, חיברת אותה ל-GitHub, ועכשיו אתה רוצה לעבוד עליה גם מול Claude. מעולה. רק שעכשיו יש לך שלושה מקומות שהאפליקציה חיה בהם בו-זמנית, וכל המשחק הוא לשמור שהם מסונכרנים. אין פה שום דבר מפחיד. חמש דקות קריאה ואתה מסודר.
Base44 ⇄ GitHub ⇄ המחשב שלך
GitHub ב-5 דקות (רק מה שחייבים)
GitHub זה גיבוי בענן של הקוד של האפליקציה שלך, שזוכר כל גרסה שאי פעם הייתה. כמו Google Drive, אבל לקוד, ועם כפתור "חזור אחורה" לכל רגע בהיסטוריה. אלה שש המילים היחידות שאתה באמת צריך להכיר:
main- הגרסה האמיתית והחיה של האפליקציה. מה שהמשתמשים שלך רואים. בזה לא נוגעים ישר.branch(ענף) - עותק צד בטוח לנסות בו שינויים. הצליח? שומרים. לא הצליח? זורקים, ו-main נשאר נקי. תמיד בטוח לנסות.commit- נקודת שמירה, עם משפט קצר שמסביר מה שינית. כמו "שמור", עם פתק.- Pull Request (PR) - הצעה: "הנה מה ששיניתי בענף, תאשר שזה ייכנס ל-main". זו נקודת הבדיקה שלך, והרגע היחיד שמבקשים ממך החלטה.
merge(מיזוג) - אישרת את ה-PR = השינויים נכנסים ל-main = מעכשיו זה אמיתי.pull/push-pull= להוריד את הגרסה מ-GitHub למחשב שלך.push= להעלות מהמחשב שלך ל-GitHub.
אם קל לך עם Google Docs, אתה כבר מבין הכל:
mainהוא המסמך הרשמי,branchזה "צור עותק" לשחק בו, ו-PR זה "הצעות שינוי" שמחכות ל-כן שלך.
שלושת העותקים (וזה כל המשחק)
האפליקציה שלך חיה בו-זמנית בשלושה מקומות. כל העבודה הנכונה היא רק לשמור שהשלושה מספרים אותו סיפור.
- Base44 - איפה שאתה בונה עם ה-AI.
- GitHub - הגיבוי הבטוח באמצע. ה-main הוא נקודת המפגש של כולם.
- המחשב שלך - Claude Desktop, איפה ש-Claude נוגע בקוד.
איך זה מסתנכרן בפועל:
- Base44 ⇄ GitHub - אוטומטי, לשני הכיוונים.
- GitHub ⇄ המחשב שלך - ידני! אתה זה שמושך ודוחף.
🎯 הנקודה הכי חשובה במדריך, תעצור עליה שנייה
Base44 ו-GitHub מסנכרנים את עצמם לבד. כל שינוי שאתה עושה ב-Base44 עולה ל-GitHub אוטומטית. אתה לא צריך לעשות כלום.
המחשב שלך לא מסתנכרן לבד. אף פעם. הוא לא יודע על שינוי שעשית ב-Base44 עד שאתה מושך אותו ידנית (
pull).זו התפירה היחידה שאתה צריך לנהל. תזכור אותה, ונפטרת מכל הבלבול.
איך עובדים נכון מול Claude Desktop
אתה לא מקליד אף פקודה. אתה כותב ל-Claude בעברית פשוטה מה שאתה רוצה, והוא עושה את כל המכניקה. ככה נראה סבב עבודה תקין, מההתחלה עד שזה עולה למשתמשים:
- לפני שמתחילים - תמשוך. מאז הפעם הקודמת בטח נגעת ב-Base44, והמחשב עוד לא מכיר את השינויים. תגיד ל-Claude: "עבור ל-main ותמשוך את הגרסה האחרונה מ-GitHub". עכשיו אתה מתחיל מהמקום הנכון.
- תפתח משימה עם תיבת ה-branch מסומנת. ככה Claude עובד על עותק צד, וה-main שלך לא בסכנה כל זמן העבודה.
- תן לו לעבוד, ואז תעבור על ה-PR. ה-PR מראה לך בדיוק מה השתנה, לפני ואחרי. מרוצה? תאשר (
merge) ל-main. - תדחוף חזרה ל-GitHub. "תדחוף את השינויים ל-GitHub" (
push). עכשיו GitHub מעודכן, ו-Base44 קולט את זה לבד. - תלחץ Publish ב-Base44. זה מה שמעלה את הגרסה לאוויר בשביל המשתמשים. עד שלא לחצת Publish, השינוי קיים אבל עוד לא חי אצל הלקוחות.
כלל הזהב, והטעות שכולם עושים
כלל הזהב: תמשוך לפני שאתה מתחיל, תדחוף כשאתה מסיים. כיוון אחד בכל פעם.
הטעות הכי נפוצה: לערוך ב-Base44 ובמחשב באותו זמן בלי לסנכרן. אז שני הצדדים מתפצלים, וכשתנסה לדחוף תקבל התנגשות (conflict) שצריך להתיר. הפתרון פשוט: או שאתה מסיים במחשב ודוחף, או שאתה עובד ב-Base44 ואז מושך לפני שאתה חוזר למחשב. לא שניהם במקביל.
🔒 main זה קדוש: אף פעם לא עובדים עליו ישר, תמיד על branch. אם משהו יוצא לא טוב, זורקים את הענף ו-main בכלל לא ידע שקרה משהו.
צ'ק-ליסט מהיר
לפני שמתחילים לעבוד במחשב
- עבור ל-main ותמשוך (
pull) מ-GitHub
כשפותחים משימה
- סמן את תיבת ה-branch
כשמסיימים
- עבור על ה-PR ותאשר (
merge) - תדחוף (
push) ל-GitHub - תלחץ Publish ב-Base44 כדי שזה יעלה למשתמשים
למי זה רלוונטי: המדריך מדבר על אפליקציית Base44 שמחוברת ל-GitHub (תוכנית Builder ומעלה). אם האפליקציה שלך לא מחוברת ל-GitHub, אין לך בכלל את הבלבול הזה - הכל חי רק ב-Base44, ואתה פשוט בונה ולוחץ Publish.
זהו, זה כל הסיפור. שאלה תוך כדי? תשאל את Claude "על איזה branch אני?" או "תראה לי מה עומד להשתנות" בכל רגע, והוא יראה לך לפני שנוגעים ב-main.
שאלות נפוצות
האם צריך לדעת פקודות Git כדי לעבוד על אפליקציית Base44 מול Claude?
לא. בעבודה מול Claude Desktop אתם כותבים בעברית פשוטה מה שאתם רוצים, ו-Claude מבצע את כל המכניקה של Git בעצמו. מספיק להכיר שישה מושגים כדי להבין מה קורה: main, branch, commit, Pull Request, merge, ו-pull/push. אתם מקבלים החלטה אחת בלבד, כשמאשרים את ה-Pull Request.
למה השינוי שעשיתי עדיין לא מופיע אצל המשתמשים?
כי מיזוג ל-main ודחיפה ל-GitHub מעדכנים את הקוד, אבל לא מעלים אותו לאוויר. ב-Base44 יש שלב אחרון ונפרד: לחיצה על Publish. עד שלא לחצתם עליו, השינוי קיים במערכת אבל המשתמשים שלכם עדיין רואים את הגרסה הקודמת. זו הטעות שהכי קל לפספס בסוף סבב עבודה.
מה ההבדל בין push לבין Publish ב-Base44?
אלה שני שלבים שונים לגמרי. push מעלה את הקוד מהמחשב שלכם ל-GitHub, ומשם Base44 קולט את השינוי אוטומטית. Publish הוא כפתור בתוך Base44 שמעלה את הגרסה לאוויר בשביל המשתמשים. אפשר לדחוף קוד עשר פעמים בלי ששום דבר ישתנה אצל הלקוחות, עד שלוחצים Publish.
מה עושים כשמקבלים התנגשות (conflict) בין Base44 למחשב?
התנגשות נוצרת כשעורכים את אותה אפליקציה גם ב-Base44 וגם במחשב בלי לסנכרן ביניהם, ואז שני הצדדים מתפצלים. הפתרון הוא לעבוד במקום אחד בכל פעם: או שמסיימים במחשב ודוחפים ל-GitHub, או שעובדים ב-Base44 ואז מושכים (pull) לפני שחוזרים למחשב. לא שניהם במקביל.
המדריך רלוונטי גם אם האפליקציה שלי לא מחוברת ל-GitHub?
לא, ואז החיים פשוטים יותר. חיבור ל-GitHub קיים בתוכנית Builder ומעלה, ובלעדיו האפליקציה חיה רק ב-Base44: אתם בונים עם ה-AI ולוחצים Publish, בלי pull, בלי push ובלי Pull Requests. כל הבלבול של שלושת העותקים פשוט לא קיים אצלכם.