కంప్యూటర్ ఇంజినీరింగ్‌లో ఆర్టిఫిషియల్ ఇంటెలిజెన్స్ మరియు వెరిఫికేషన్ డిసిప్లిన్ పరిచయం

లాభాలు:

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

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

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

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

ఏ వ్యాపారాలలో AI యాక్సిలరేటర్ ఉంది, ఏ వ్యాపారాలలో ఇది ప్రమాదకరం?

సాఫ్ట్‌వేర్ ఉద్యోగాలు ఫలితాల పరంగా ద్విముఖ స్పెక్ట్రమ్‌లో వస్తాయి. ఒక చివర రివర్సిబుల్, తక్కువ-రిస్క్ ప్రిపరేషన్ పని; మరొక చివర, ఉత్పత్తి వాతావరణంలోకి ప్రవేశించే కష్టతరమైన పనులు ఉన్నాయి మరియు డేటా నష్టం, భద్రతా లోపాలు లేదా అంతరాయాలకు కారణం కావచ్చు. ఈ స్పెక్ట్రమ్‌లో మీరు ఎక్కడ ఉన్నారనే దానిపై ఆధారపడి AI విలువ మారుతుంది.

వ్యాపార రకం

AI సహకారం

ఇంజనీర్ పాత్ర

కోడ్ అస్థిపంజరం / బాయిలర్‌ప్లేట్

పునరావృత నిర్మాణం యొక్క వేగవంతమైన తరం

లాజిక్ మరియు అంచు స్థితి నియంత్రణ

డీబగ్గింగ్

పరికల్పన మరియు సాధ్యమయ్యే కారణాల జాబితా

పునరుత్పత్తి మరియు మూల కారణం నిర్ధారణ

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

పరీక్ష డ్రాఫ్ట్ మరియు దృష్టాంత సృష్టి

అర్థవంతమైన నిశ్చయత మరియు పరిధిని తనిఖీ చేయడం

రీఫ్యాక్టరింగ్

రీఫ్యాక్టరింగ్ ప్రతిపాదన

పరీక్ష ద్వారా ప్రవర్తనను నిర్వహించడం

డాక్యుమెంటేషన్

మొదటి డ్రాఫ్ట్ మరియు నిర్మాణం

కోడ్‌కు వ్యతిరేకంగా సరైన తనిఖీ

ఆర్కిటెక్చరల్/సెక్యూరిటీ నిర్ణయం

ఎంపికలు మరియు లాభాలు మరియు నష్టాల జాబితా

తుది నిర్ణయం మరియు బాధ్యత

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

హెచ్చరిక: AI నిష్ణాతులు మరియు నమ్మకమైన కోడ్‌ను ఉత్పత్తి చేస్తుంది. పటిమ అనేది ఖచ్చితత్వానికి హామీ కాదు. భాషా నమూనా వాస్తవానికి ఉనికిలో లేని ఫంక్షన్ పేరు, తప్పు పారామీటర్ సీక్వెన్స్ లేదా అసురక్షిత నమూనాను కూడా విశ్వసనీయంగా ఉత్పత్తి చేయగలదు. సాఫ్ట్‌వేర్‌లో, ఇది కాగితంపై ఉండదు; ఇది కంపైల్ చేస్తుంది, నడుస్తుంది మరియు ఉత్పత్తిలో పేలుతుంది.

ఇంజనీర్‌కు వదిలివేయవలసిన నిర్ణయాలు

కొన్ని నిర్ణయాలు పూర్తిగా స్వయంచాలకంగా ఉండకూడదు; సాంకేతిక, చట్టపరమైన మరియు నైతిక ప్రమాదాలను కలిగి ఉంటుంది:

• ఉత్పత్తికి ఆమోదం: ఉత్పత్తికి కోడ్ విడుదల మరియు దీనికి బాధ్యత.
• భద్రత మరియు నిర్మాణం: ప్రామాణీకరణ, అధికారం, ఎన్‌క్రిప్షన్ మరియు డేటా మోడల్ వంటి ఖరీదైన నిర్ణయాలు.
• లైసెన్స్ మరియు కాపీరైట్: వాణిజ్య ఉత్పత్తిలో ఉత్పత్తి చేయబడిన కోడ్ యొక్క వినియోగం మరియు లైసెన్స్ సమ్మతి.
• రహస్య డేటాతో పని చేయడం: కస్టమర్ డేటా, సోర్స్ కోడ్ రహస్యాలు మరియు గుర్తింపు సమాచారంతో లావాదేవీలు.

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

ధృవీకరణ క్రమశిక్షణ: మూడు-పొరల నియంత్రణ

AI అవుట్‌పుట్‌ను గుడ్డిగా కాకుండా సీనియర్ సమీక్షకుడిలా ఉపయోగించడానికి మూడు లేయర్‌ల నియంత్రణను వర్తింపజేయండి. ఇది మాడ్యూల్ అంతటా మేము పునరావృతం చేసే ప్రాథమిక రిఫ్లెక్స్.

1. కంపైలేషన్ మరియు స్టాటిక్ చెకింగ్: కోడ్ వాస్తవానికి కంపైల్/రన్ అవుతుందా? టైప్ ఎర్రర్‌లు, ఉపయోగించని వేరియబుల్స్, ఉనికిలో లేని APIలు ఉన్నాయా? స్టాటిక్ అనాలిసిస్ టూల్ (కోడ్‌ను రన్ చేయకుండా పరిశీలించే సాధనం) ఏమి చెబుతుంది?
2. స్వతంత్ర పునరుత్పత్తి (పరీక్ష): చిన్న, తెలిసిన ఇన్‌పుట్‌లతో కోడ్‌ని అమలు చేయండి మరియు మీరు ఆశించిన అవుట్‌పుట్‌ను పొందారో లేదో చూడండి. అంచు కేసులను ప్రయత్నించండి (శూన్య, సున్నా, ప్రతికూల, భారీ).
3. మూల ధృవీకరణ: AI ఉపయోగించే ప్రతి API, లైబ్రరీ వెర్షన్ మరియు భాషా ఫీచర్ అధికారిక డాక్యుమెంటేషన్ నుండి ధృవీకరించబడాలి.

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

మీ స్వంత కోడ్ ప్రాంప్ట్‌ను విమర్శించండి: "మిమ్మల్ని నియమించుకున్న సీనియర్ ఇంజనీర్ లాగా మీరు ఇప్పుడే వ్రాసిన కోడ్‌ను విమర్శనాత్మకంగా చూడండి. ఈ మూడు శీర్షికల క్రింద నిర్దిష్ట అంశాలను ఇవ్వండి: (1) లాజిక్/ఎడ్జ్ కేస్ ఎర్రర్‌లు, (2) సెక్యూరిటీ రిస్క్‌లు, (3) పనితీరు లేదా రీడబిలిటీ సమస్యలు. ప్రతి అంశానికి, 'ఎందుకు సమస్య ఉంది' అని వ్రాయండి మరియు 'సమస్యను కనుగొనలేకపోయాను' అని చెప్పండి. దానిని అలంకరించడానికి ప్రయత్నించండి."

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

బలహీనం:"నాకు వినియోగదారు ప్రామాణీకరణ ఫంక్షన్‌ను వ్రాయండి."(ఫలితం: ఏ భాష, ఏ నియమం, ఏ దోష ప్రవర్తన అస్పష్టంగా ఉంది; సాధారణ కోడ్, తరచుగా అసురక్షిత లేదా సందర్భోచితంగా ఉంటుంది.)STRONG:"పైథాన్ 3.11 కోసం ఇమెయిల్ ధ్రువీకరణ ఫంక్షన్‌ను వ్రాయండి. ఇన్‌పుట్: స్ట్రింగ్. అవుట్‌పుట్: చెల్లుబాటు అయితే, తప్పు, లేకపోతే మూలాధారం అవసరం లేదు, రూల్స్ అవసరం లేదు. ఫంక్షన్ అనుబంధం బ్లాక్‌కి దిగువన ఉన్న 5-నమూనా పరీక్షను ఉపయోగించవద్దు: చెల్లుబాటు అయ్యేది, ఖాళీ లేదు, డబుల్ '@', ఖాళీలు మాత్రమే ఉన్నాయి.

వ్యత్యాసం సందర్భంలో ఉంది. శక్తివంతమైన ప్రాంప్ట్; ఇది భాష, సంస్కరణ, ఇన్‌పుట్-అవుట్‌పుట్ ఒప్పందం, పరిమితులు మరియు పరీక్ష అంచనాలను కలిగి ఉంటుంది. ఈ ఒక్క క్రమశిక్షణ భ్రాంతులు మరియు అసురక్షిత కోడ్ ప్రమాదాన్ని బాగా తగ్గిస్తుంది.

మినీ కేసులు

కేసు 1 — కల్పిత పద్ధతి. డేట్ లైబ్రరీలో date.addBusinessDays(5) అనే పద్ధతి ఉందని డెవలపర్ AI నుండి వింటాడు మరియు అది నమ్మకంగా వివరించబడింది. డాక్యుమెంటేషన్‌ని చూస్తే, అలాంటి పద్ధతి లేదని అతను చూస్తాడు, సరైన మార్గం మాన్యువల్ లూప్. 10 నిమిషాల వెరిఫికేషన్‌తో ఉత్పత్తిలోకి వెళ్లే ముందు భ్రాంతి క్యాప్చర్ చేయబడుతుంది.

కేస్ 2 - ఎడ్జ్ స్టేట్ నష్టం. AI "సగటును లెక్కించు" ఫంక్షన్‌ను ఉత్పత్తి చేస్తుంది; 1,000 వరుసల డేటాతో పరీక్షించినప్పుడు ఇది పని చేస్తుంది. అయితే, జాబితా ఖాళీగా ఉన్నప్పుడు, అది సున్నా లోపం ద్వారా విభజనను ఇస్తుంది. ఇంజనీర్ ఖాళీ ఇన్‌పుట్ పరీక్షను జోడించినందున, అది ప్రత్యక్ష ప్రసారం కావడానికి ముందే అతను ఎర్రర్‌ను చూసి సరిచేస్తాడు. సింగిల్ ఎడ్జ్ కండిషన్ టెస్ట్ ఉదయం 3 గంటలకు ఉత్పత్తి అలారాన్ని నిరోధిస్తుంది.

కేసు 3 - గోప్యతా ప్రమాదం. ఒక నిపుణుడు వాస్తవ డేటాబేస్ కనెక్షన్ స్ట్రింగ్ మరియు API కీతో ఫైల్‌ను పబ్లిక్ టూల్‌లో అతికించబోతున్నారు. సంస్థ యొక్క విధానాన్ని గుర్తుంచుకుంటుంది; ఇది రహస్యాలను <REDACTED>తో భర్తీ చేస్తుంది, కోడ్‌ను ప్రతినిధి ఉదాహరణగా తగ్గించి, దాని కోసం అడుగుతుంది. అందువలన, అతను 5 నిమిషాల్లో సహాయం పొందుతాడు, కానీ అతని గుర్తింపు సమాచారం బయటకు రాదు.

రహస్య కోడ్ మరియు గుర్తింపు సమాచారంతో పని చేసే సూత్రం

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

అనామక ప్రాంప్ట్ నమూనా: "క్రింది ఫంక్షన్‌లో లోపం ఉంది. నేను వాస్తవ వ్యాపార తర్కం మరియు దాచిన స్థిరాంకాలను ప్రాతినిధ్య విలువలతో భర్తీ చేసాను (API కీ, పట్టిక పేర్లు, ఫీల్డ్ పేర్లు జెనరిక్). సమస్య: నాకు ఇన్‌పుట్ Xలో Y లోపం వచ్చింది. ఈ ప్రతినిధి కోడ్‌లో లాజిక్ లోపాన్ని కనుగొని, సరిదిద్దబడిన సంస్కరణను వివరించండి. [ప్రతినిధి కోడ్]"

చిట్కా: అనుమానం ఉంటే, ఈ పరీక్షను నిర్వహించండి: "నేను దీన్ని ఫోరమ్‌లో పబ్లిక్‌గా వ్రాసినట్లయితే నా సంస్థకు ఇబ్బంది కలుగుతుందా?" సమాధానం అస్పష్టంగా ఉన్నప్పటికీ, ముందుగా దాన్ని క్లియర్ చేయండి. తర్వాత లీక్‌ని వెంబడించడం కంటే రీసెట్ చేయడం ఎల్లప్పుడూ చౌకగా ఉంటుంది.

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

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

సారాంశంలో

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

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

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

చెక్లిస్ట్

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