AI વડે બનેલી એપમાં Git કેવી રીતે વાપરવું

AI વડે બનેલી એપમાં Git વાપરવા માટે, પ્રોજેક્ટને Git repository સાથે જોડો, દરેક કામના ફેરફાર પછી commit કરો, એક લીટીમાં સમજાવતો સંદેશો લખો, અને .gitignore વડે secrets બહાર રાખો. જોખમી કામ માટે branch વાપરો, જો બીજું કોઈ code બદલ્યું હોય તો ફરી prompt આપતા પહેલાં pull કરો, અને જ્યારે AI કંઈક તોડે, ત્યારે ગૂંચવાયેલી સ્થિતિ પર નવો prompt આપવાને બદલે છેલ્લા સારા commit પર પાછા જાઓ.

Git એ version control છે: તમારા codeની દરેક સાચવેલી આવૃત્તિનો ઇતિહાસ. GitHub એ એક વેબસાઇટ છે જે Git repositories ઑનલાઇન સંગ્રહે છે. જો આ શબ્દો નવા હોય, તો GitHub શું છે થી શરૂઆત કરો. આ guide એ આદતો વિશે છે જે Git ને ઉપયોગી બનાવે છે જ્યારે મોટાભાગનો code AI લખતી હોય.

AI સાથે Git વધુ મહત્વનું કેમ છે

AI એક જ વારમાં વીસ ફાઇલો બદલી શકે છે. એ ઝડપી છે, અને તેનો અર્થ એ પણ કે એક prompt ગઈ કાલે તમે ચકાસેલું કંઈક ચુપચાપ તોડી શકે છે. Git તમને આપે છે:

• પાછા જવાનો રસ્તો. કોઈ પણ commit કરેલી આવૃત્તિ પાછી લાવી શકાય છે.
• શું બદલાયું તેનો રેકોર્ડ. કોઈ prompt ને કઈ ફાઇલો અને કઈ લીટીઓ સ્પર્શી તે બરાબર જોઈ શકો છો.
• Builder ની બહાર એક નકલ. તમારો code એવી જગ્યાએ રહે છે જેના પર તમારું નિયંત્રણ છે.
• પ્રમાણભૂત હેન્ડઓવર. કોઈ પણ developer, host અથવા tool Git repository પરથી કામ કરી શકે છે.

પગલું 1: Repository જોડો

GitHub અથવા એવી કોઈ સેવા પર repository બનાવો (સામાન્ય રીતે private), અને તમારા પ્રોજેક્ટને તેની સાથે જોડો. Git ને સપોર્ટ કરતા મોટાભાગના AI app builders આ કામ settings પેજ પરના "Connect GitHub" બટન દ્વારા કરે છે. જો તમારા builder માં ન હોય, તો તમે code export કરીને જાતે push કરી શકો છો, અથવા એક વાર developer ને સેટઅપ કરવા કહી શકો છો.

પહેલું push કરતા પહેલાં, ખાતરી કરો કે repository એવી વસ્તુઓને અવગણે જે તેમાં ન હોવી જોઈએ:

.gitignore ફાઇલ તપાસો. ખાતરી કરો કે તે .env ફાઇલો, node_modules, build output folders અને secrets ધરાવતી કોઈ પણ ફાઇલને બાકાત રાખે છે. તમે શું ઉમેર્યું તે મને કહો.

પગલું 2: દરેક કામના ફેરફાર પછી commit કરો

Commit એ સંદેશા સાથેનો સાચવેલો snapshot છે. જે આદત સૌથી મહત્વની છે: કંઈક કામ કરે ત્યારે commit કરો, આગલી વસ્તુ માંગતા પહેલાં.

1. એક ફેરફાર માટે prompt આપો.
2. Preview માં તપાસો.
3. જો કામ કરે, તો સંદેશા સાથે commit (અથવા sync) કરો.
4. પછી આગળ વધો.

નાના commits નો અર્થ છે કે કંઈક તૂટે ત્યારે તમે જાણો છો કે કયા ફેરફારે તે તોડ્યું, અને તેને undo કરવાથી બીજું કામ નષ્ટ થતું નથી.

પગલું 3: એવા સંદેશા લખો જે પછીથી વાંચી શકાય

સારો સંદેશો શું બદલાયું અને શા માટે તે એક લીટીમાં કહે છે:

• સારું: Add CSV export to the orders page
• સારું: Fix booking form rejecting times after 6pm
• ઉપયોગી નથી: update, changes, fix stuff

તમે AI ને તે લખવા કહી શકો છો:

છેલ્લા commit પછીના ફેરફારોનો એક લીટીમાં સારાંશ આપો, ક્રિયાપદથી શરૂ કરો, 70 અક્ષરથી ઓછા.

પગલું 4: જોખમી કામ માટે branches વાપરો

Branch એ કામની એક અલગ લીટી છે. તમે branch પર કંઈક અજમાવી શકો છો, અને જો તે કામ ન કરે, તો મુખ્ય આવૃત્તિને સ્પર્શ્યા વિના તેને છોડી શકો છો.

Branch ક્યારે વાપરવી:

• ફેરફાર મોટો હોય (redesign, નવો payment flow, database ફેરફાર).
• બીજું કોઈ એ જ એપ પર કામ કરતું હોય.
• લાઇવ થાય તે પહેલાં તમે કોઈ પાસે ફેરફારની સમીક્ષા કરાવવા માંગો.

જ્યારે કામ પૂરું અને ચકાસાયેલું હોય, ત્યારે તે મુખ્ય branch માં merge થાય છે. GitHub પર આ સામાન્ય રીતે pull request દ્વારા થાય છે, એક પેજ જે સમીક્ષા માટે ફેરફારો બતાવે છે. જો તમારું builder માત્ર એક branch sync કરે, તો developer GitHub બાજુએ branches સંભાળી શકે છે.

પગલું 5: સલામત રીતે undo કરો

જ્યારે કોઈ prompt એપ તોડે, ત્યારે તેની ઉપર પાંચ વધુ prompts આપવાની ઇચ્છાને રોકો. છેલ્લી સારી આવૃત્તિ પર પાછા જાઓ અને વધુ સ્પષ્ટ prompt અજમાવો.

• Builder માં: જો તેમાં હોય તો તેનું checkpoint અથવા restore feature વાપરો.
• Git માં: git revert એક નવો commit બનાવે છે જે જૂના commit ને ઉલટાવે છે, અને ઇતિહાસ અકબંધ રાખે છે. જે code બીજાઓએ pull કર્યો હોય તેના માટે આ સલામત પસંદગી છે.
• શેર કરેલી branch પર git push --force ટાળો, સિવાય કે તમને બરાબર ખબર હોય કે શા માટે. તે બધાના માટે ઇતિહાસ ફરીથી લખે છે.

ખાતરી ન હોય તો પૂછો:

છેલ્લા ફેરફારે login પેજ તોડ્યું. પાછલા commit ની સરખામણીમાં તે કઈ ફાઇલો બદલે છે તે બતાવો, અને દરેક ફેરફારે શું કર્યું તે સમજાવો. હજુ કંઈ બદલશો નહીં.

પગલું 6: Prompt આપતા પહેલાં pull કરો

જો developer અથવા બીજું કોઈ tool GitHub પર code બદલે, તો AI builder તે જાણતું નથી જ્યાં સુધી તમે તે ફેરફારો pull ન કરો. જૂના code પર prompt આપવાથી conflicts અને કામ ખોવાઈ શકે છે.

• દરેક session ની શરૂઆતમાં pull કરો.
• નક્કી કરો કોણ શું બદલે છે, અને એક જ સમયે બંને બાજુએ એક જ ફાઇલો બદલવાનું ટાળો.
• જો તમને merge conflict મળે (એક જ લીટીઓ પર બે ફેરફારો), તો developer અથવા AI ને તેને ઉકેલવા અને પસંદગી સમજાવવા કહો.

ઉદાહરણ prompts

શરૂ કરતા પહેલાં: મારા છેલ્લા session પછી repository માં શું બદલાયું? commits નો સારાંશ આપો.

આગલો ફેરફાર એકલો કરો: દરેક invoice માં "Duplicate" બટન ઉમેરો. બીજું કંઈ બદલશો નહીં, જેથી હું તેને અલગ commit કરી શકું.

તપાસો કે કોઈ API keys, passwords કે .env ફાઇલો Git માં tracked નથી, જૂના commits સહિત. ફક્ત ફાઇલોનાં નામ જણાવો, કિંમતો નહીં.

સામાન્ય ભૂલો

• Secrets commit કરવા. એકવાર key Git ઇતિહાસમાં આવી જાય પછી તે ખુલ્લી પડી જાય છે, ફાઇલ ડિલીટ કર્યા પછી પણ. તેને rotate કરો.
• અઠવાડિયામાં એક વિશાળ commit. તમે એક ફેરફાર undo કરી શકતા નથી તે બધાને undo કર્યા વિના.
• "update" જેવા સંદેશા. ઇતિહાસ શું તૂટ્યું તે શોધવા માટે નકામો બને છે.
• જૂના code પર prompt આપવો. જ્યારે બીજું કોઈ સંપાદન કરતું હોય ત્યારે પહેલાં pull કરો.
• ભૂલ સુધારવા force-push કરવું. તે બીજાઓનું કામ ભૂંસી શકે છે. તેના બદલે revert કરો.
• node_modules commit કરવું. તે ખૂબ મોટું છે અને lock file પરથી પણ ફરીથી બની જાય છે.

Checklist

• પ્રોજેક્ટ private repository સાથે જોડાયેલો છે.
• .gitignore .env, node_modules, build output અને secrets ને બાકાત રાખે છે.
• હું દરેક કામના ફેરફાર પછી commit કરું છું.
• Commit સંદેશા એક લીટીમાં કહે છે કે શું બદલાયું.
• મોટા કે જોખમી ફેરફારો branch પર જાય છે અને તેની સમીક્ષા થાય છે.
• જ્યારે બીજું કોઈ code બદલે ત્યારે હું prompt આપતા પહેલાં pull કરું છું.
• હું checkpoints અથવા git revert વડે undo કરું છું, force-push નહીં.
• જે key ક્યારેય commit થઈ હોય તે rotate કરવામાં આવી છે.

Mythex પર Git

Mythex દરેક સફળ agent turn પછી git checkpoint સાચવે છે, અને આ બિંદુ પર પાછા જાઓ તે પ્રોજેક્ટને તે બિંદુ પર રોલ બેક કરે છે — જે પગલું 5 માં વર્ણવેલ builder-બાજુનો undo છે. જુઓ Iterate without rebuilding.

Pro પર, GitHub sync પ્રોજેક્ટ settings માંથી repository જોડે છે જેથી તમે તેની સામે push અને pull કરી શકો, અને export પ્રોજેક્ટ ડાઉનલોડ કરે છે જેમાંથી secrets અને node_modules બાકાત હોય છે. જુઓ GitHub, export, and import. પ્રોજેક્ટ developer ને સોંપતા પહેલાં GitHub જોડવાથી હેન્ડઓવર ઘણો સરળ બને છે — જુઓ AI વડે બનેલી એપ પર developer સાથે કેવી રીતે કામ કરવું અને AI વડે બનેલી એપ કેવી રીતે export કરીને self-host કરવી.

પ્રશ્નો