సాఫ్ట్‌వేర్ బృందాల కోసం ఆర్టిఫిషియల్ ఇంటెలిజెన్స్: వర్కింగ్ మోడల్ మరియు పరిమితులు

లాభాలు:

• కోడింగ్ అసిస్టెంట్ లాంగ్వేజ్ మోడల్‌గా ఎలా పనిచేస్తుందో మరియు టోకెన్, కాంటెక్స్ట్ విండో, భ్రాంతి భావనలను వివరించే సామర్థ్యం
• మెంటల్ మ్యాప్‌తో AI బలంగా మరియు బలహీనంగా ఉన్న సాఫ్ట్‌వేర్ టాస్క్‌లను వేరు చేయగల సామర్థ్యం
• వారి స్వంత పనులకు ప్రతిపాదించడం-ఉత్పత్తి చేయడం-ధృవీకరించడం యొక్క ప్రాథమిక పని చక్రాన్ని వర్తింపజేయగల సామర్థ్యం

సాఫ్ట్‌వేర్ డెవలపర్‌ల రోజు చాలా అరుదుగా "మొదటి నుండి కోడ్ రాయడం" కోసం వెచ్చిస్తారు. నిజ సమయం; వేరొకరు వ్రాసిన కోడ్‌ను చదవడం, బగ్‌ను పునరుత్పత్తి చేయడానికి ప్రయత్నించడం, లాగ్‌ను స్కాన్ చేయడం (అప్లికేషన్ నడుస్తున్నప్పుడు రూపొందించిన లాగ్ లైన్‌లు), పరీక్షలు రాయడం, PR రాయడం (పుల్ రిక్వెస్ట్ - టీమ్ రివ్యూ కోసం కోడ్ మార్పు సమర్పించబడే విలీన అభ్యర్థన) వివరణ మరియు డాక్యుమెంటేషన్‌ను నవీకరించడం. ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ (AI) అనేది దాదాపుగా ఈ కనిపించని ఉద్యోగాలన్నింటినీ తాకగల స్పీడ్ గుణకం. కానీ దానిని సురక్షితంగా ఉపయోగించడం కోసం మొదటి షరతు ఏమిటంటే అది ఏది మరియు ఏది కాదు అని సరిగ్గా అర్థం చేసుకోవడం.

ఈ యూనిట్‌లో, మేము మొదట సాదా భాషలో కోడింగ్ అసిస్టెంట్ యొక్క అంతర్లీన సాంకేతికతను వివరిస్తాము; అప్పుడు మేము మోడల్ యొక్క బలాలు మరియు బలహీనతల యొక్క మానసిక పటాన్ని సృష్టిస్తాము; చివరగా, మేము మొత్తం మాడ్యూల్ అంతటా ఉపయోగించే ప్రాథమిక పని క్రమశిక్షణను ఏర్పాటు చేస్తాము: ప్రతిపాదించండి, ఉత్పత్తి చేయండి, ధృవీకరించండి. ఈ మూడు దశలు తదుపరి పదకొండు యూనిట్లకు వెన్నెముక.

గమనిక: ఈ మాడ్యూల్ సాధారణ శిక్షణ. సెక్యూరిటీ-క్రిటికల్ సాఫ్ట్‌వేర్‌లో (చెల్లింపు ప్రాసెసింగ్, హెల్త్‌కేర్, ప్రామాణీకరణ, క్రిటికల్ ఇన్‌ఫ్రాస్ట్రక్చర్) AI అవుట్‌పుట్ అర్హత కలిగిన ఇంజనీర్ ద్వారా సమీక్ష మరియు ఆమోదానికి ప్రత్యామ్నాయం కాదు. AI ఒక సహాయకుడు; సంతకం చేసినవాడు ఇంజనీర్.

కోడింగ్ అసిస్టెంట్ నిజానికి ఏమి చేస్తుంది?

చాలా కోడింగ్ అసిస్టెంట్‌లు పెద్ద భాషా నమూనాపై నిర్మించబడ్డాయి (LLM- AI భారీ మొత్తంలో టెక్స్ట్ మరియు కోడ్‌పై శిక్షణ పొందింది, ఇది తదుపరి అత్యంత సంభావ్య "చంక్"ని అంచనా వేస్తుంది). మోడల్ కోడ్‌ను మానవుడిలా "అర్థం చేసుకోదు"; ఇది భారీ ఉదాహరణల నుండి నేర్చుకునే నమూనాల ఆధారంగా మీరు ఇచ్చిన సందర్భం యొక్క కొనసాగింపును ఉత్పత్తి చేస్తుంది. ఈ సాధారణ మెకానిజం ఆచరణలో ఆశ్చర్యకరంగా నిష్ణాత ఫలితాలను ఇస్తుంది - ఎందుకంటే చాలా సాఫ్ట్‌వేర్ పునరావృతమయ్యే నమూనాలను కలిగి ఉంటుంది: HTTP అభ్యర్థన, లూప్, శూన్య తనిఖీ, పరీక్ష నమూనా.

ఇక్కడ మూడు పదాలు కీలకం. టోకెన్ అనేది టెక్స్ట్‌ను విభజించడం ద్వారా మోడల్ ప్రాసెస్ చేసే అతి చిన్న యూనిట్; ఇది దాదాపు కొన్ని అక్షరాలు లేదా పదం యొక్క భాగం. కాంటెక్స్ట్ విండో అనేది మోడల్ ఒకేసారి "చూడగల" టోకెన్ల మొత్తం; మీ కోడ్, దోష సందేశం మరియు సూచన ఈ విండోలో తప్పక సరిపోతాయి. ప్రాంప్ట్ అంటే మీరు మోడల్‌కి ఇచ్చే అన్ని సూచనలు మరియు సందర్భాలు. మీరు పొందే అవుట్‌పుట్ నాణ్యత నేరుగా ఈ రెండింటిపై ఆధారపడి ఉంటుంది: మీరు మోడల్‌కు మెరుగైన సందర్భం మరియు స్పష్టమైన సూచనలను ఇస్తే, మీరు మంచి ఫలితాన్ని పొందుతారు. చెడు ఇన్‌పుట్ స్మార్ట్ మోడల్ అయినప్పటికీ చెడు అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది — సాఫ్ట్‌వేర్ యొక్క క్లాసిక్ “గార్బేజ్ ఇన్, గార్బేజ్ అవుట్” నియమం AIకి కూడా వర్తిస్తుంది.

బలాలు మరియు బలహీనతల మ్యాప్

AIని సరైన ఉద్యోగాలకు మళ్లించడానికి, అది ఎక్కడ ప్రకాశిస్తుందో మరియు ఎక్కడ పొరపాట్లు చేస్తుందో తెలుసుకోవడం అవసరం. ఈ మ్యాప్‌ను గుర్తుంచుకోవడం వల్ల మీరు ప్రతి తదుపరి మిషన్‌తో ఆశ్చర్యపోతారు, "నేను ఈ ఉద్యోగాన్ని AIకి అవుట్‌సోర్స్ చేయాలా లేదా నేనే చేయాలా?" ఇది సెకన్లలో ప్రశ్నకు సమాధానం ఇవ్వడానికి మిమ్మల్ని అనుమతిస్తుంది.

దీని బలాలు: బాయిలర్‌ప్లేట్ కోడ్‌ని రూపొందించడం, ఒక భాష నుండి మరొక భాషకు అనువదించడం, సాధారణ వ్యక్తీకరణ (రీజెక్స్) రాయడం, ఒక ఫంక్షన్‌ను వివరించడం, పరీక్ష అస్థిపంజరాన్ని సృష్టించడం, దోష సందేశాన్ని వివరించడం, డాక్యుమెంటేషన్‌ను రూపొందించడం, వేరియబుల్/ఫంక్షన్ పేర్లను సూచించడం మరియు చిన్న రీఫ్యాక్టరింగ్‌లు (కోడ్ యొక్క ప్రవర్తనను మార్చకుండా దాని నిర్మాణాన్ని మెరుగుపరచడం).

బలహీనతలు: మీ కంపెనీ-నిర్దిష్ట వ్యాపార నియమాలను తెలుసుకోవడం, మీ మొత్తం కోడ్ బేస్‌ను గుర్తుంచుకోవడం, వాస్తవానికి కోడ్‌ను అమలు చేయడం మరియు ధృవీకరించడం, తాజా లైబ్రరీ వెర్షన్‌లను ఖచ్చితంగా తెలుసుకోవడం, భద్రతా లోపాలను వంద శాతం హామీతో గుర్తించడం. అత్యంత ప్రమాదకరమైన విషయం భ్రాంతి: మోడల్ ఉనికిలో లేని ఫంక్షన్, లైబ్రరీ లేదా API (అప్లికేషన్‌ల మధ్య డేటా మార్పిడిని ప్రారంభించే ఇంటర్‌ఫేస్)ను చాలా నమ్మదగిన భాషలో కనిపెట్టింది. ఈ ప్రమాదాన్ని వాస్తవానికి మీ ప్రయోజనం కోసం మార్చవచ్చు, ఎందుకంటే కోడ్, సాదా వచనం వలె కాకుండా, అది "పని చేస్తుందో" అని పరీక్షించవచ్చు - ధృవీకరణ దశను దాటవేయవద్దు.

మిషన్ రకం

AI పాత్ర

మనిషి పాత్ర

బాయిలర్‌ప్లేట్/అస్థిపంజరాన్ని ఉత్పత్తి చేయండి

డ్రాఫ్ట్ ఉత్పత్తి చేస్తుంది

అనుకూలతలు, సమీక్షలు

కోడ్ వివరణ

శీఘ్ర సారాంశాన్ని అందిస్తుంది

కోడ్‌లోని కీలక భాగాన్ని ధృవీకరిస్తుంది

పరీక్షలు రాయడం

కేసు సూచిస్తుంది

కవరేజ్ మరియు ఖచ్చితత్వాన్ని నిర్ధారిస్తుంది

సెక్యూరిటీ-క్రిటికల్ లాజిక్

సహాయక ఆలోచన

నిర్ణయం మరియు బాధ్యత పూర్తిగా మనుషులదే.

API/లైబ్రరీ వినియోగం

నమూనాను రూపొందిస్తుంది

ఉనికి మరియు సంస్కరణను ధృవీకరిస్తుంది

నిర్మాణ నిర్ణయం

ఎంపికల రకాలు

సందర్భాన్ని తెలుసుకుని ఎంచుకుని సమర్థిస్తాడు

దశల వారీగా: ప్రాథమిక పని చక్రం

1. విధిని స్పష్టం చేయండి. మీరు ఒక వాక్యంలో మీకు కావలసినది వ్రాయలేకపోతే, మోడల్ కూడా కాదు. అంతకుముందు అనిశ్చితి ఇన్‌పుట్‌లోకి ప్రవేశిస్తే, అది అవుట్‌పుట్‌లో అంతగా పెరుగుతుంది.
2. సందర్భం ఇవ్వండి. ప్రాంప్ట్‌కు సంబంధిత కోడ్, పూర్తి ఎర్రర్ మెసేజ్, భాష/ఫ్రేమ్‌వర్క్ వెర్షన్ మరియు పరిమితులను జోడించండి. "దీన్ని పరిష్కరించండి" అని చెప్పకండి, "Python 3.11, FastAPI 0.110; ఈ ఫంక్షన్ 500 ఎర్రర్‌ను ఇస్తుంది, అభ్యర్థన శరీరం ఖాళీగా ఉన్నప్పుడు అది పేలుతుంది" అని చెప్పండి.
3. విధింపు పాత్ర మరియు ఆకృతి. "మీరు సీనియర్ గో డెవలపర్; కేవలం కోడ్ మరియు రెండు వాక్యాల హేతుబద్ధతను ఇవ్వండి" వంటి ఫ్రేమ్‌వర్క్ అవుట్‌పుట్‌ను ఫోకస్ చేస్తుంది.
4. చిన్నది అడగండి. ఒక పెద్ద అభ్యర్థన కాకుండా దశలుగా విభజించండి; ప్రతి దశను విడిగా ధృవీకరించండి. ప్రధాన మార్పులు ప్రమాదకరమైనవి ఎందుకంటే అవి ధృవీకరించడం కష్టం మరియు లోపాలను దాచడానికి అవకాశం ఉంది.
5. ధృవీకరించండి. దీన్ని అమలు చేయండి, పరీక్షించండి, దృశ్యమానంగా చదవండి. ధృవీకరించని AI కోడ్ "స్కెచ్", "పరిష్కారం" కాదు. ఇది చక్రం యొక్క అత్యంత చర్చించలేని దశ.

మూడు మినీ కేసులు

కేస్ 1 - సమయం ఆదా చేయడం నిజమైనది కానీ నిరాడంబరంగా ఉంటుంది. ఒక బృందం AIతో కొత్త CRUD (క్రియేట్-రీడ్-అప్‌డేట్-డిలీట్) ముగింపు పాయింట్‌లను అస్థిపంజరం చేసినప్పుడు, మొదటి డ్రాఫ్ట్ సమయం సుమారు 40 నిమిషాల నుండి 8 నిమిషాలకు పడిపోయింది. అయితే, సమీక్ష మరియు పరీక్షతో, మొత్తం సమయం 25 నిమిషాలు; కాబట్టి నిజమైన లాభం 40 నుండి 25 వరకు, దాదాపు 38%. "మేము 10 రెట్లు వేగవంతం చేసాము" అనే అంచనాకు బదులుగా కొలవబడిన ఈ రేటు స్థిరమైన లాభం.

కేసు 2 - భ్రాంతి చాలా ఖరీదైనది. ఒక డెవలపర్ AI-సూచించిన requests.get_json() కాల్‌ని ధృవీకరణ లేకుండా ఉపయోగించారు; అటువంటి పద్ధతి లేదు (ఖచ్చితంగా response.json()). కోడ్ కంపైల్ కానప్పుడు 20 నిమిషాలు పోయాయి. ఒక సాధారణ "ఈ పద్ధతి నిజంగా ఉందా?" ధృవీకరణ నష్టాన్ని రీసెట్ చేస్తుంది.

కేస్ 3 - మంచి సందర్భం అవుట్‌పుట్‌ను రెట్టింపు చేస్తుంది. అదే బగ్ కోసం, ఒక డెవలపర్ కేవలం "నాకు ఎర్రర్ వస్తోంది" అని రాశారు మరియు మరొకరు పూర్తి స్టాక్ ట్రేస్, వెర్షన్ మరియు ఇన్‌పుట్ నమూనాను జోడించారు. రెండోది మొదటి ప్రయత్నంలోనే సరైన పరిష్కారాన్ని పొందింది; మొదటిది మూడు మలుపులు గడిపింది. వ్యత్యాసం మోడల్‌లో కాదు, ఇన్‌పుట్‌లో ఉంది.

నాలుగు కాపీ చేయగల టెంప్లేట్లు

సాధారణ ప్రయోజన, శక్తివంతమైన ప్రారంభ ప్రాంప్ట్:

పాత్ర: మీరు అనుభవజ్ఞుడైన {{language}} డెవలపర్. టాస్క్: {{what_want}}సందర్భం:- ఫ్రేమ్‌వర్క్/వెర్షన్: {{framework_and_version}}- పరిమితులు: {{performance, style, dependent rules}}నియమాలు:- ఉనికిలో లేని లైబ్రరీ/ఫంక్షన్‌ని ఉపయోగించవద్దు; మీకు ఖచ్చితంగా తెలియకుంటే, దానిని "ధృవీకరించు"గా గుర్తించండి. - ముందుగా, ఒక చిన్న ప్లాన్, తర్వాత కోడ్, తర్వాత 2 జస్టిఫికేషన్ వాక్యాలు ఇవ్వండి. - పరీక్షించదగిన, వర్కింగ్ కోడ్‌ని ఉత్పత్తి చేయండి.

అనిశ్చితిని తిరిగి మోడల్‌లోకి ఫిల్టర్ చేయడానికి:

దిగువ టాస్క్‌ను పరిష్కరించే ముందు, మీరు ప్రశ్నలుగా తప్పిపోయిన లేదా అస్పష్టంగా ఉన్న కనీసం 3 పాయింట్‌లను జాబితా చేయండి. నేను ప్రత్యుత్తరం ఇచ్చే ముందు కోడ్ రాయవద్దు. టాస్క్: {{task}}

అవుట్‌పుట్‌ని స్వీయ-తనిఖీ చేసుకోవడానికి:

మీరు ఈ క్రింది కోడ్‌ని రూపొందించారు. ఇప్పుడు మీ పాత్రను మార్చండి మరియు ఈ కోడ్‌ను విమర్శించండి:- పని చేయని 3 కేసులను (ఎడ్జ్ కేస్‌లు) జాబితా చేయండి.- మీరు రూపొందించగలిగే ఏవైనా APIలు/ఫంక్షన్‌లు ఉన్నాయా? మార్క్.- సరిదిద్దబడిన సంస్కరణను ఇవ్వండి.కోడ్:{{code}}

నిర్ణయాన్ని ఎంపికలుగా విభజించడానికి:

{{సమస్య}} కోసం 2-3 పరిష్కార విధానాలను సూచించండి. ప్రతిదానికి: సంక్షిప్త వివరణ, ప్లస్/మైనస్, ఎప్పుడు ఎంచుకోవాలి. పట్టిక రూపంలో ఇవ్వండి. నా కోసం ఎన్నుకోవద్దు; కేవలం ఎంపికను స్పష్టం చేయండి.

బలహీనమైన ప్రాంప్ట్ / బలమైన ప్రాంప్ట్

బలహీనం: "ఈ కోడ్‌లోని బగ్‌ను పరిష్కరించండి." (ఏ లోపం? ఏ భాష? ఆశించిన ప్రవర్తన ఏమిటి?)

బలమైనది: "Python 3.11 / FastAPI 0.110. అభ్యర్థన భాగం ఖాళీగా వచ్చినప్పుడు క్రింది ముగింపు స్థానం KeyErrorతో 500ని అందిస్తుంది; నేను 400 మరియు అర్ధవంతమైన సందేశాన్ని ఖాళీ శరీరంపై తిరిగి ఇవ్వాలనుకుంటున్నాను. ముందుగా కారణాన్ని వివరించండి, ఆపై సరిదిద్దబడిన ఫంక్షన్‌ను ఇవ్వండి, ఆపై ఈ దృశ్యం కోసం ఒక పరీక్ష రాయండి. [కోడ్]"

శక్తివంతమైన వెర్షన్; ఇది భాష, సంస్కరణ, వాస్తవ లోపం, ఆశించిన ప్రవర్తన మరియు అవుట్‌పుట్ ఆకృతిని అందిస్తుంది. మోడల్ ఇకపై అంచనా వేయాల్సిన అవసరం లేదు.

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

• ధృవీకరణ లేకుండా విశ్వసించడం. అత్యంత సాధారణ మరియు అత్యంత ఖరీదైన తప్పు. కోడ్ కంపైల్ చేయబడి పరీక్షించబడే వరకు "పరిష్కారం" అని చెప్పకండి.
• సందర్భం లేకుండా ప్రశ్నలు అడుగుతున్నారు. సంస్కరణ, ఎర్రర్ టెక్స్ట్ మరియు పరిమితులు లేని సమాధానం సాధారణమైనది మరియు తరచుగా తప్పుగా ఉంటుంది.
• ఒక పెద్ద అభ్యర్థన. 300-లైన్ ఉత్పత్తిని ఒకేసారి అభ్యర్థించలేకపోవడం మరియు సమీక్షించడం తప్పులు కనిపించకుండా చేస్తుంది.
• మోడల్ యొక్క ఆత్మవిశ్వాసాన్ని రుజువుగా తప్పుబడుతోంది. AI నమ్మకంగా తప్పు చెప్పగలదు; టోన్ ఖచ్చితత్వానికి సూచిక కాదు.
• కంపెనీ రహస్యాన్ని యాదృచ్ఛికంగా అతికించడం. ప్రైవేట్ కీలు, కస్టమర్ డేటా లేదా ప్రైవేట్ సోర్స్ కోడ్ ఆమోదించబడని సాధనాల్లోకి ప్రవేశించకూడదు (మేము ఈ అంశాన్ని యూనిట్ 10లో పరిశీలిస్తాము).

చిట్కా: ప్రతి AI అవుట్‌పుట్‌ను "ఇది డ్రాఫ్ట్"గా పరిగణించండి. ఈ ఒక్క మానసిక అలవాటు మాడ్యూల్ అంతటా మీరు చూసే చాలా ప్రమాదాలను తొలగిస్తుంది.

సారాంశంలో

కోడింగ్ అసిస్టెంట్ అనేది తదుపరి అత్యంత సంభావ్య భాగాన్ని అంచనా వేసే భాషా నమూనా; ఇది కోడ్‌ను అర్థం చేసుకోదు, ఇది నమూనాలను ఉత్పత్తి చేస్తుంది. అందుకే అతను పునరావృతమయ్యే, సూత్రబద్ధమైన ఉద్యోగాలలో బలంగా ఉన్నాడు; మీ సందర్భానికి నిర్దిష్ట ధృవీకరణ అవసరమయ్యే పని కోసం దీన్ని జాగ్రత్తగా ఉపయోగించాలి. అతిపెద్ద ప్రమాదం భ్రాంతి, మరియు ఏకైక విరుగుడు ధృవీకరణ. మొత్తం మాడ్యూల్‌లో మేము అనుసరించే క్రమశిక్షణ స్పష్టంగా ఉంది: పనిని స్పష్టం చేయండి, సందర్భం ఇవ్వండి, చిన్నది అడగండి, ప్రతి డెలివరీని ధృవీకరించండి.

అప్లికేషన్ టాస్క్

మీరు గత వారంలో చేసిన మూడు సాఫ్ట్‌వేర్ టాస్క్‌లను వ్రాసుకోండి (ఉదా. బగ్ ఫిక్స్, టెస్ట్, README అప్‌డేట్). ప్రతి దాని కోసం "బలాలు మరియు బలహీనతల మ్యాప్" చూడండి మరియు మీరు AI దీన్ని చేస్తే మీ మరియు AI పాత్ర ఏమిటో ఒక వాక్యంలో వివరించండి. ఆపై పైన ఉన్న "ప్రారంభ ప్రాంప్ట్" టెంప్లేట్‌తో ఈ టాస్క్‌లలో ఒకదానిని AIకి అందించండి మరియు అవుట్‌పుట్‌ను అమలు చేసి ధృవీకరించండి; మీరు ఎన్ని నిమిషాలు సేవ్ చేసారో మరియు ఎన్ని తప్పులను సరిదిద్దాలో గమనించండి.

చెక్లిస్ట్

• [ ] LLM కోడ్ "అర్థం చేసుకోవడం" కాకుండా నమూనాలను ఉత్పత్తి చేస్తుందని నేను గ్రహించాను.
• [ ] నేను టోకెన్, కాంటెక్స్ట్ విండో మరియు ప్రాంప్ట్ యొక్క భావనలను ఒక వాక్యంలో వివరించగలను.
• [ ] నేను AI బలంగా మరియు బలహీనంగా ఉన్న టాస్క్‌ల రకాల మధ్య తేడాను గుర్తించగలను.
• [ ] భ్రాంతి అంటే ఏమిటో నాకు తెలుసు మరియు ధృవీకరణ మాత్రమే విరుగుడు.
• [ ] నేను "ప్రతిపాదించండి, ఉత్పత్తి చేయండి, ధృవీకరించండి" చక్రాన్ని నా స్వంత పనికి అనుగుణంగా మార్చుకున్నాను.
• [ ] నేను ఒక నిర్దిష్ట ఉదాహరణలో బలమైన ప్రాంప్ట్ మరియు బలహీనమైన ప్రాంప్ట్ మధ్య వ్యత్యాసాన్ని చూపగలను.