AI తో నిర్మించిన యాప్‌లో Git ఎలా ఉపయోగించాలి

AI తో నిర్మించిన యాప్‌లో Git ఉపయోగించాలంటే, ప్రాజెక్ట్‌ను Git రిపోజిటరీతో కనెక్ట్ చేయండి, పని చేసే ప్రతి మార్పు తర్వాత కమిట్ చేయండి, ఏమి మారిందో చెప్పే ఒక లైన్ సందేశం రాయండి, మరియు .gitignore ద్వారా రహస్యాలను దూరంగా ఉంచండి. రిస్కీ పనులకు బ్రాంచ్ ఉపయోగించండి, వేరొకరు కోడ్ మార్చినట్లయితే మళ్లీ ప్రాంప్ట్ చేసే ముందు పుల్ చేయండి, మరియు AI ఏదైనా విరగ్గొడితే, గందరగోళం మీద ప్రాంప్ట్ చేయకుండా చివరి మంచి కమిట్‌కు తిరిగి వెళ్లండి.

Git అంటే వెర్షన్ కంట్రోల్: మీ కోడ్ ప్రతి సేవ్ చేసిన వెర్షన్ యొక్క చరిత్ర. GitHub అనేది Git రిపోజిటరీలను ఆన్‌లైన్‌లో నిల్వ చేసే వెబ్‌సైట్. ఇవి మీకు కొత్తగా ఉంటే, GitHub అంటే ఏమిటి తో ప్రారంభించండి. ఈ గైడ్ AI ఎక్కువ కోడ్ రాస్తున్నప్పుడు Git ను ఉపయోగకరంగా చేసే అలవాట్ల గురించి.

AI తో Git ఎందుకు మరింత ముఖ్యం

AI ఒక్క టర్న్‌లో ఇరవై ఫైళ్లను మార్చగలదు. అది వేగంగా ఉంటుంది, కానీ అదే సమయంలో ఒక ప్రాంప్ట్ నిన్న మీరు పరీక్షించిన దాన్ని నిశ్శబ్దంగా విరగ్గొట్టవచ్చు. Git మీకు ఇస్తుంది:

• వెనక్కి వెళ్ళే మార్గం. కమిట్ అయిన ఏ వెర్షన్‌నైనా తిరిగి తీసుకురావచ్చు.
• ఏమి మారిందో రికార్డు. ఒక ప్రాంప్ట్ ఏ ఫైళ్లను, ఏ లైన్లను తాకిందో ఖచ్చితంగా చూడవచ్చు.
• బిల్డర్ బయట ఒక కాపీ. మీ కోడ్ మీరు నియంత్రించే చోట ఉంటుంది.
• ప్రామాణిక హ్యాండాఫ్. ఏ డెవలపర్, హోస్ట్ లేదా టూల్ అయినా Git రిపోజిటరీ నుండి పని చేయగలదు.

స్టెప్ 1: రిపోజిటరీని కనెక్ట్ చేయండి

GitHub లేదా అలాంటి సేవలో ఒక రిపోజిటరీ సృష్టించండి (సాధారణంగా ప్రైవేట్‌గా), మరియు మీ ప్రాజెక్ట్‌ను దానికి కనెక్ట్ చేయండి. Git కు మద్దతు ఇచ్చే చాలా AI యాప్ బిల్డర్లు ఇది "Connect GitHub" బటన్ ఉన్న సెట్టింగ్స్ పేజీ ద్వారా చేస్తాయి. మీది చేయకపోతే, కోడ్‌ను ఎక్స్‌పోర్ట్ చేసి మీరే పుష్ చేయవచ్చు, లేదా ఒకసారి సెటప్ చేయమని డెవలపర్‌ను అడగవచ్చు.

మొదటి పుష్‌కు ముందు, రిపోజిటరీలో ఉండకూడనివి మినహాయించబడ్డాయని నిర్ధారించుకోండి:

.gitignore ఫైల్‌ను తనిఖీ చేయండి. అది .env ఫైళ్లు, node_modules, బిల్డ్ అవుట్‌పుట్ ఫోల్డర్లు మరియు రహస్యాలు ఉన్న ఏ ఫైల్‌నైనా మినహాయిస్తుందో చూడండి. మీరు ఏమి జోడించారో చెప్పండి.

స్టెప్ 2: ప్రతి పని మార్పు తర్వాత కమిట్ చేయండి

కమిట్ అంటే సందేశంతో కూడిన సేవ్ చేసిన స్నాప్‌షాట్. ముఖ్యమైన అలవాటు ఇది: ఏదైనా పని చేసినప్పుడు, తర్వాతి పని అడగడానికి ముందు కమిట్ చేయండి.

1. ఒక మార్పు కోసం ప్రాంప్ట్ చేయండి.
2. ప్రివ్యూలో తనిఖీ చేయండి.
3. అది పని చేస్తే, ఒక సందేశంతో కమిట్ (లేదా సింక్) చేయండి.
4. తర్వాత ముందుకు సాగండి.

చిన్న కమిట్‌ల వల్ల ఏదైనా విరిగినప్పుడు, ఏ మార్పు దానికి కారణమో మీకు తెలుస్తుంది, మరియు దాన్ని వెనక్కి తీసుకుంటే మిగతా పని పోదు.

స్టెప్ 3: తర్వాత చదవగలిగే సందేశాలు రాయండి

మంచి సందేశం ఏమి మారిందో, ఎందుకు మారిందో ఒక్క లైన్‌లో చెబుతుంది:

• మంచిది: Add CSV export to the orders page
• మంచిది: Fix booking form rejecting times after 6pm
• ఉపయోగకరం కాదు: update, changes, fix stuff

సందేశాలను AI తో రాయించవచ్చు:

చివరి కమిట్ నుండి జరిగిన మార్పులను ఒక్క లైన్‌లో, క్రియాపదంతో మొదలై, 70 అక్షరాల లోపు సంగ్రహించండి.

స్టెప్ 4: రిస్కీ పనులకు బ్రాంచ్‌లు ఉపయోగించండి

బ్రాంచ్ అంటే పని యొక్క ప్రత్యేక వరుస. మీరు బ్రాంచ్‌లో ఏదైనా ప్రయత్నించవచ్చు, అది పని చేయకపోతే ప్రధాన వెర్షన్‌ను తాకకుండా వదిలేయవచ్చు.

ఈ సందర్భాల్లో బ్రాంచ్ వాడండి:

• మార్పు పెద్దది అయినప్పుడు (డిజైన్ మార్పు, కొత్త చెల్లింపు ఫ్లో, డేటాబేస్ మార్పు).
• వేరొకరు అదే యాప్‌పై పని చేస్తున్నప్పుడు.
• ప్రత్యక్షంగా వెళ్ళే ముందు ఎవరైనా మార్పును సమీక్షించాలనుకున్నప్పుడు.

పని పూర్తయి పరీక్షించిన తర్వాత, అది ప్రధాన బ్రాంచ్‌లోకి merge అవుతుంది. GitHub లో ఇది సాధారణంగా pull request ద్వారా జరుగుతుంది, అంటే మార్పులను సమీక్ష కోసం చూపే పేజీ. మీ బిల్డర్ ఒక్క బ్రాంచ్‌నే సింక్ చేస్తే, GitHub వైపు బ్రాంచ్‌లను డెవలపర్ నిర్వహించవచ్చు.

స్టెప్ 5: సురక్షితంగా వెనక్కి తీసుకోండి

ఒక ప్రాంప్ట్ యాప్‌ను విరగ్గొడితే, దానిపైనే ఇంకో ఐదు సార్లు ప్రాంప్ట్ చేయాలనే ఆశను ఆపండి. చివరి మంచి వెర్షన్‌కు వెళ్లి, స్పష్టమైన ప్రాంప్ట్‌తో మళ్లీ ప్రయత్నించండి.

• బిల్డర్‌లో: దానికి చెక్‌పాయింట్ లేదా రీస్టోర్ ఫీచర్ ఉంటే దాన్ని ఉపయోగించండి.
• Git లో: git revert పాత కమిట్‌ను రద్దు చేసే కొత్త కమిట్ సృష్టిస్తుంది, చరిత్ర చెక్కుచెదరకుండా ఉంటుంది. ఇతరులు పుల్ చేసి ఉండే కోడ్‌కు ఇది సురక్షిత మార్గం.
• షేర్ చేసిన బ్రాంచ్‌లో git push --force ఎందుకో ఖచ్చితంగా తెలిస్తే తప్ప వాడవద్దు. అది అందరి కోసం చరిత్రను తిరగరాస్తుంది.

ఖచ్చితంగా తెలియకపోతే, అడగండి:

ఇటీవలి మార్పు లాగిన్ పేజీని విరగ్గొట్టింది. మునుపటి కమిట్‌తో పోలిస్తే ఏ ఫైళ్లను మార్చిందో చూపించి, ప్రతి మార్పు ఏమి చేసిందో వివరించండి. ఇంకా ఏమీ మార్చవద్దు.

స్టెప్ 6: ప్రాంప్ట్ చేసే ముందు పుల్ చేయండి

వేరొకరు, డెవలపర్ లేదా మరో టూల్, GitHub లో కోడ్ మార్చితే, ఆ మార్పులను మీరు pull చేసే వరకు AI బిల్డర్‌కు తెలియదు. పాత కోడ్‌పై ప్రాంప్ట్ చేస్తే కాన్‌ఫ్లిక్ట్‌లు మరియు పోయిన పని వస్తాయి.

• ప్రతి సెషన్ ప్రారంభంలో పుల్ చేయండి.
• ఎవరు ఏ ఫైళ్లను ఎడిట్ చేయాలో అంగీకరించండి, మరియు రెండు వైపులు ఒకే సమయంలో ఒకే ఫైళ్లను ఎడిట్ చేయకుండా చూసుకోండి.
• merge conflict వస్తే (ఒకే లైన్లకు రెండు మార్పులు), డెవలపర్‌ను లేదా AI ని దాన్ని పరిష్కరించి ఎంపికను వివరించమని అడగండి.

ఉదాహరణ ప్రాంప్ట్‌లు

ప్రారంభించే ముందు: నా చివరి సెషన్ నుండి రిపోజిటరీలో ఏమి మారింది? కమిట్‌లను సంగ్రహించండి.

తదుపరి మార్పును ఒంటరిగా చేయండి: ప్రతి ఇన్‌వాయిస్‌కు "Duplicate" బటన్ జోడించండి. ఇంకేమీ మార్చవద్దు, తద్వారా నేను దాన్ని వేరుగా కమిట్ చేయగలను.

Git లో ఏ API కీలు, పాస్‌వర్డ్‌లు లేదా .env ఫైళ్లు ట్రాక్ అవుతున్నాయో తనిఖీ చేయండి, గత కమిట్‌లతో సహా. ఫైల్ పేర్లు మాత్రమే చెప్పండి, విలువలు కాదు.

సాధారణ తప్పులు

• రహస్యాలను కమిట్ చేయడం. ఒక కీ Git చరిత్రలో ఒకసారి ఉంటే, ఫైల్‌ను తొలగించిన తర్వాత కూడా అది బయటపడుతుంది. కీని మార్చండి.
• వారానికి ఒక పెద్ద కమిట్. ఒక మార్పును వెనక్కి తీసుకోవాలంటే అన్నింటినీ వెనక్కి తీసుకోవాల్సి వస్తుంది.
• "update" వంటి సందేశాలు. ఏది విరిగిందో కనుగొనడానికి చరిత్ర ఉపయోగపడదు.
• పాత కోడ్‌పై ప్రాంప్ట్ చేయడం. వేరొకరు ఎడిట్ చేస్తుంటే ముందుగా పుల్ చేయండి.
• తప్పు సరిచేయడానికి force-push చేయడం. అది ఇతరుల పనిని తుడిచివేయవచ్చు. బదులుగా revert చేయండి.
• node_modules ను కమిట్ చేయడం. అది చాలా పెద్దది, మరియు లాక్ ఫైల్ నుండి ఎలాగూ మళ్లీ సృష్టించబడుతుంది.

చెక్‌లిస్ట్

• ప్రాజెక్ట్ ఒక ప్రైవేట్ రిపోజిటరీకి కనెక్ట్ అయి ఉంది.
• .gitignore లో .env, node_modules, బిల్డ్ అవుట్‌పుట్ మరియు రహస్యాలు మినహాయించబడ్డాయి.
• పని చేసే ప్రతి మార్పు తర్వాత నేను కమిట్ చేస్తాను.
• కమిట్ సందేశాలు ఒక్క లైన్‌లో ఏమి మారిందో చెబుతాయి.
• పెద్ద లేదా రిస్కీ మార్పులు బ్రాంచ్‌లో ఉంటాయి మరియు సమీక్షించబడతాయి.
• వేరొకరు కోడ్ ఎడిట్ చేస్తుంటే నేను ప్రాంప్ట్ చేసే ముందు పుల్ చేస్తాను.
• చెక్‌పాయింట్లు లేదా git revert తో వెనక్కి తీసుకుంటాను, force-push కాదు.
• ఒకసారి కమిట్ అయిన ఏ కీనైనా మార్చాను.

Mythex లో Git

Mythex ప్రతి విజయవంతమైన ఏజెంట్ టర్న్ తర్వాత Git చెక్‌పాయింట్ సేవ్ చేస్తుంది, మరియు Revert to this point ప్రాజెక్ట్‌ను ఆ పాయింట్‌కు తిరిగి తీసుకువెళ్తుంది — స్టెప్ 5 లో వివరించిన బిల్డర్ వైపు వెనక్కి తీసుకునే మార్గం. Iterate without rebuilding చూడండి.

Pro లో, GitHub sync ప్రాజెక్ట్ సెట్టింగ్స్ నుండి రిపోజిటరీని కనెక్ట్ చేస్తుంది, తద్వారా మీరు దానితో పుష్ మరియు పుల్ చేయవచ్చు, మరియు export రహస్యాలు మరియు node_modules లేకుండా ప్రాజెక్ట్‌ను డౌన్‌లోడ్ చేస్తుంది. GitHub, export, and import చూడండి. డెవలపర్‌కు ప్రాజెక్ట్ ఇచ్చే ముందు GitHub కనెక్ట్ చేయడం హ్యాండాఫ్‌ను చాలా సులభం చేస్తుంది — AI తో నిర్మించిన యాప్‌పై డెవలపర్‌తో ఎలా పని చేయాలి మరియు AI తో నిర్మించిన యాప్‌ను ఎక్స్‌పోర్ట్ చేసి సొంతంగా హోస్ట్ చేయడం ఎలా చూడండి.

ప్రశ్నలు