తను: కోడ్ మీ అనుభూతుల పట్ల indifferent గా ఉంటుంది
చెప్పాల్సినది ఈ విధంగా ఉంది: పెద్ద భాషా మోడల్స్ మరియు కోడ్ గురించి: అవి అమితంగా ధృఢంగా ఉంటాయి మరియు మీ ప్రోగ్రామ్ కంపైల్స్ అవుతుందా లేదా అని అక్షర శూన్యంగా indifferent గా ఉంటాయి. క్లాయిడ్ హైకూ 4.5 మీకు మీ సమస్యను తీర్చే ఒక Python స్క్రిప్ట్ నిమిత్తం రాస్తుంది, పరిమితమైన స్పోర్ట్ కోసం రెండింటిని కనుగొన్నది. Trick - ప్రాముఖ్యత ఉన్న ఒక్క trick - క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కోసం ఎలా ప్రాంప్ట్ చేయాలో నేర్చుకుంటుంది, ఇది అనుభూతులకు పూరణ అంతం కావొచ్చు మరియు నిజానికి ఎక్కువకు స్థలం ఉంటుంది. మీకు కోడ్ ఎటువంటి రచయితలా కాకుండా, కోడ్ సమర్థంగా ఉండాలని కోరుకుంటారు. ఒక తేడా ఉంది.
మంచి ప్రాంప్టింగ్ కొలతలు: చాలా సార్లు పనులు పట్ల అనుభూతి గమనిస్తారు - సరైన పదాలు చెప్పండి, సమర్థమైన యాప్ పొందండి. ఇది కార్గో కుల్తు ఆలోచన. కోడ్ ఒక ఒప్పందమే. మీరు క్లాయిడ్ హైకూ నుండి ఖచ్చితమైన దిశలో నిక్షేపం పొందాలంటే, ఒప్పందాన్ని రాయాలి. "ఒక వెబ్ యాప్ నిర్మించండి" ఒక ఒప్పందం కాదు. "Python 3.12 లో JSON ను అందించే, Pydantic v2 తో స్కీమాను ధృవీకరించడానికి, మరియు ప్రత్యేక Payload ఆకారంతో స్కీమా లోపాలపై 422ని తిరిగి ఇవ్వటానికి ఒక FastAPI ఎండ్ పాయింట్ జనరేట్ చేయండి" అది ఒక ఒప్పందం. ఈ విధంగా క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కోసం ప్రాంప్ట్ చేసే విధానం: మీరు ఒప్పందాన్ని దాచినట్లుగా.
ఇది ఏమిటి (మరియు ఏమిటి కాదు)
- ఇది క్లాయిడ్ హైకూ 4.5 నుండి నమ్మదగిన, పరీక్షించదగిన కోడ్ పొందేందుకు ఒక ఎలా చేయాలి గైడ్.
- ఇది "AI డెవలపర్స్ ను భర్తీ చేసి" అనే ప్రచారం కాదు. పరికరాలు ఆలోచనలను భర్తీ చేయవు.
- ఇది వ్యావహారిక ప్రాంప్ట్స్, నిర్మాణం, మరియు గార్డ్రైల్స్ పై దృష్టి సారిస్తుంది: ఈ మాంత్రికాన్ని పనిచేసే నిగ్రహం వద్ద ఉన్న నిద్రాపరుపులు.
మీరు రన్ మని కోడ్ కోరితే, క్లాయిడ్ కు "రన్" అని ఒక నిర్వచనాన్ని ఇవ్వాలి. మీరు ఖచ్చితమైన కోడ్ ఉత్పత్తి కోరితే, ఖచ్చితత్వాన్ని సరళంగా, పరీక్షించదగిన పద్ధతిలో నిర్వచించడం అవసరం. అది మొత్తం ఆట.
ఒక న్యాయవాది వంటి ఖచ్చితత్వాన్ని నిర్వచించండి, కవికవితా కాదు
"ఖచ్చితమైన" కోడ్ "నిజంగా నమ్మదగిన" కోడ్ కాదు. ఖచ్చితత్వం:
- సింక్ యాక్టింగ్: అది ఇంటर्प్రెటర్ కింద కంపైల్ అవుతుంది లేదా నడుస్తుంది.
- సెమాంటిక్ నమ్మకత్వం: ఇది స్పెక్ ఏమిటి చెప్పింది.
- డిటర్మినిస్టిక్ ప్రవర్తన: ఒకే ఆహారాలు, ఒకే పూరకాలు, నిర్దిష్ట లోపత్ర బౌండ్లలో.
- వర్షన్ ఖచ్చితత్వం: ఇది సరైన SDKs, API వర్షన్ లు, మరియు భాషా లక్షణాలను ఉపయోగిస్తుంది.
క్లాయిడ్ మీకు మీరు అడిగినది ఇస్తుంది. మీరు "ఒక జాబితాను అక్షరంగా క్రమబద్దీకరించే ఒక ఫంక్షన్" అడిగితే, మీరు అందించగలరు. మీరు "Timsort స్పెంతలతో O(1) అదనపు స్థలం ఉపయోగించే ఒక స్థిరమైన, స్సాట్ క్రమబద్దీకరించడం" అడిగితే, అది వేరే ప్రమాణం. "క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కోసం ఎలా ప్రాంప్ట్ చేయాలి" అందించినది.
కనీసమైన మెరుగైన ప్రాంప్ట్, అప్గ్రేడ్ చేయబడింది
చెత్త: "పనుల కొరకు నోడ్ API ను వ్రాయండి."
మంచిది: "చిత్రం 20 ఎక్స్ప్రెస్ 4 API తో /tasks POST మార్గం లెక్కించండి, ఇది {title: string, dueDate: ISO 8601 మార్గం} ఫీల్డులను ధృవీకరించడానికి సమాధానం ఇస్తుంది 201 నో: క్రిందంలో ఉన్న అంశం లేదా 400 లో అవశేష వివరాలతో."
సరైనది: "ఒకే /tasks POST ఎండ్ పాయింట్ సృష్టించండి. అవసరాలు: 1) [email protected] తో శరీరాన్ని ధృవీకరించండి; 2) ఫీల్డ్స్: శీర్షిక (అంతరం ఖాళీ లేని పంక్తి, గరిష్టంగా 140), సాధారణ తేదీ (ISO 8601 భవిష్యకత); 3) విజయంపై: 201 గాయానికి {id: ULID, title, dueDate}; 4) అపస్కృతం: 400 తో {error: 'VALIDATION', details: array}; 5) డేటాబేస్ లేదు; మెమరీ మ్యాప్; 6) చేర్చారు jest 29 పరీక్ష ఫైల్ లెక్కించి సమర్థమైనది, అవసరాలు (ఖాళీ శీర్షిక, గత తేదీ); 7) పరీక్ష మరియు అభివృద్ధి కొరకు npm స్క్రిప్ట్ అందించాలి; 8) ESM ఉపయోగించండి; 9) విదేశీ వ్యాఖ్యను చేర్చవద్దు." ఆకారాన్ని గమనించండి: భాషా వర్షన్, లైబ్రరీలు, పరిమితులు, అవశేషాలు, పరీక్షలు, మరియు ح ష్ వగైరా కూడా. మీరు అస్పష్టతను తొలగించారు. క్లాయిడ్ ఎంపిక చేయాలి కోడ్ ను నింపే. కాకుండా అవసరాలను అన్నింటిని.
స్కాఫోల్డింగ్ మోడల్: వ్యవస్థ, స్పెక్, పరీక్షలు, అనంతరం కోడ్
మీరు క్లాయిడ్ హైకూ 4.5 నుండి ఖచ్చితమైన కోడ్ ఉత్పత్తి కోరితే, మీరు దాన్ని ఒక రన్వేకు ఇవ్వాలి:
- వ్యవస్థ ఫ్రేమింగ్ (చిన్న జోరు)
- మీరు: "మీరు ప్రొడక్షన్-నాణ్యత TypeScript ను Node 20 కోసం రాస్తున్నారు. ప్రోగ్రామ్ అవగాహనలతో ఫైల్ కంటే కేవలం కోడ్ బ్లాక్స్ మాత్రమే ఉత్పత్తి చేయండి."
- ఎందుకు: మీరు తోట మరియు అవుట్ పుట్ ఫార్మాట్ ను నియంత్రిస్తున్నారు. ఇది యాదృచ్ఛికానికి వదిలివేయవద్దు.
- భాషా వర్షన్లు, ప్యాకేజీ ఎంపికలు, లోపం సెమాంటిక్స్, I/O రూపాలు, పనితీరు పరిమితులు మరియు భద్రతా పరిమితులు చేర్చండి.
- క్లాయిడ్ కు యూనిట్ పరీక్షలు మొదట రాయడానికి చెప్పండి. పరీక్షలు "ఖచ్చితమైనది" అంటే చాలా స్పష్టంగా నిర్ధారించబడింది. కోడ్ యొక్క ఒక పంక్తి పరీక్షను అందించరాదు అయితే, అది అలంకరణ.
- ప్రయత్నాల తరువాత మాత్రమే. అవును, ఇది ప్రాథమికంగా TDD, కానీ ఏది ఎక్కిండి, క్లాయిడ్ బోర్లెట్ రైట్ చేయడంలో బోర్నేజిని అనుమతించదు.
- "పరీక్షలను విఫలమైతే లేదా దిగుమతులు సరిపోలడం లేదు, విఫలమైన భాగాలను మాత్రమే అప్డేట్ చేయండి. మొత్తం ప్రాజెక్టు రమీ చేయవద్దు."
క్లాయిడ్ కాంటెక్స్ మరియు రైల్స్ ఉన్నప్పుడు బాగా చేయగలదు. దానికి రైల్స్ ఇవ్వండి.
వర్షన్ పిన్న కాబోలు తప్పనిసరి కాదు
క్లాయిడ్ శిక్షణ మొత్తం పాత మరియు కొత్త డాక్యుమెంట్లతో నిండి ఉంది. ఇది మౌలికంగా చాలా విరుద్ధమైన సలహాను చూసింది. "React Router ను ఉపయోగించండి" అస్పష్టంగా ఉంది. "[email protected] తో డేటా రూటర్లను ఉపయోగించండి" దిశగా. డిఫాల్ట్స్ పై విశ్వసించవద్దు: - భాషలు: Python 3.12, Node 20, Go 1.22, Java 21-మీరు నిజంగా నడుస్తున్నదానిని పిన్ చేయండి.
- ఫ్రేమ్ వర్క్స్: ఖచ్చితమైన ప్రధాన వర్షన్లను మరియు మార్పులు సూచించే కొన్ని ఫ్లాగ్స్.
- Cloud SDKs: వర్షన్లను పిన్ చేయండి; aws-sdk v2 vs v3 విషయాలను.
- లింటర్స్/ఫార్మాటర్స్: "శైలి పింగ్-పాంగ్" రీమైట్లను నివారించడానికి నిబంధనలు పేర్కొనండి.
మీరు పిన్ చేయకపోతే, మీరు ఐదు సంవత్సరాల బ్లాగ్ పోస్టుల నుండి ఒక గొప్ప గాయకుడిని పొందుతారు. ఖచ్చితమైన కోడ్ ఉత్పత్తి పరాన్న రాంద్ర పట్ల అచ్చు ఉంది.
స్కీమా మొదటి, ఎల్లప్పుడు
"యూజర్ ప్రొఫైల్" నిర్మాణాలను అడగవద్దు. ప్రాంప్ట్ లో స్కీమాలను నిర్వచించండి మరియు ధృవీకరణ ఇవ్వండి:
- JSON స్కీమా లేదా JS/TS లో Zod/Yup రకాలు
- Python లో Pydantic మోడల్స్
- సర్వీసులకు Protobuf లేదా Avro
అప్పుడు క్లాయిడ్ అడ్డింగ్ అంది క очеред перед рио непосредственно — API ఇన్ పుట్లు, డేటాబేస్ రాయులు, మరియు సందేశాల కీయూ నిర్వహణ. పద్దతులు మరియు సంకేతాల ఇవరకు పేర్కొనడం బహువేలులకు చెబుతుంది. ఖచ్చితత్వం స్కీమాలను ఇష్టపడుతుంది. అస్పష్టత కాదు.
దాన్ని పరిశీలన చేయ్యో: లేదా అది నిజమైనది చూపించవద్దు
మీకు అవసరమైన ఎక్కడ న ఫార్మాట్ చేయండి, మీరే వాటిని నిలుపుతారు మరియు మీరు అవసరమే ఉంటే శాంతంగా ఉంచండి. ఒక మంచి ప్రాంప్ట్ ఈ అంశాలను కలిగి ఉంది:
- లాగింగ్ విధానం: స్థాయులు, PII యొక్క అధిగమం, నిర్మాణం (JSON లాగులు, దయచేసి)
- మెట్రిక్స్: ప్రతి అభ్యర్థన కాలం, లోపాల సంఖ్యాల
- ఆరోగ్య ఎండ్ పాయింట్లు: /healthz అవలక్షణాలను పూర్ణంలో ఉన్నాయా.
క్లాయిడ్ మీకు అడిగినవి జోడిస్తుంది. మీరు అడిగేంతవరకూ, మీకు ప్రింట్ బెట్టి ఉంటే అది కంగిలి లో ఉంది.
టెస్ట్-ప్రథమ ప్రాంప్ట్స్ 'కేవలం నమ్మండి' లో పెరిగాడు
క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కొరకు ప్రాంప్ట్ చేయడానికి ఒక మంచి మార్గం టెస్ట్ లను సత్య ఉత్పత్తి. ఉదాహరణ:
“పూన విషయం normalize_email(s) అందించండి:
- స్థానిక మరియు ప్రాంతాలలో లొకల్ భాగానికో బేసు; ఇది ప్రవేశించదు.
- గూగుల్ కుమారుని కోసం మాత్రమే స్థానిక భాగంలో డాట్స్ను అపచం చేస్తుంది.
- గూగుల్ వంటి మరియు కన్నా ఉపోద్ఘాటనలను అపచ్యం చేయాలి;
- ఒకే @ లేకుండా లేదా ఖాళీలతో వాస్తవాలను తిరస్కరించినచో;
- యూనికోడ్ డొమెయిన్ పునీకోడ్ ని సజీవంగా పునఠచ్చితం చేస్తుంది. ఎడ్జ్ కేశ్ ను కప్పండి. పరీక్షలు రాసి, ఆ ფუნქ్షన్ అప్పటికీ అమలు చేయాలి.
క్లాయిడ్ చాలా సార్లు మీరు వివరించిన పరీక్షలను సంతృప్తి వద్ద ఉన్న క్రమం ఉర్దంగా జతచేస్తుంది. అది చేయట్లేదనేను మీరు ఒక కంక్రీటు విఫలమైతే, విఫలమైన వాదన కాద.
నిర్మాణ ద్వారా ఎలాంటి హల్యూసినేషన్లు లేవు
మీరు హల్యూసినేషన్లను తొలగించలేరు కానీ మీకు వాటిని కప్పుతానంటున్నారు:
- తన పఠనాలు లేదా మూల URLs అడగండి, అయితే మూలాలు ఉన్నప్పుడు మాత్రమే. SDK పద్ధతుల కోసం, డాక్ లింకులను అనుసరించండి మరియు కోడ్ ఆ డాక్కులకు సరిపోవాలని కోరండి.
- ప్రైవేట్ API లకు, ప్రాంప్ట్లో స్పెక్స్ ని వేయండి. క్లాయిడ్ మీ అంతర్గత ఎండ్ పోయింట్లు తెలుసుకోనని ఆశించమడ్డి.
- అస్థిర API లతో లైబ్రరీల కోసం, అధికారిక డాక్లలో నుండి ఉదాహరణ పంక్తిని చేర్చండి మరియు వాస్తవ దాన్ని తదనుకృతమంచి లేదు.
ఖచ్చితమైన కోడ్ చాలా ఖచ్చితమైన పుస్తకాల ఉపన్యాసాలు అవుతాయి. క్లాయిడ్ కు ఉట్యున్నాయని ఇచ్చా.
శైలి గైడ్ల ఉత్పత్తిదారులు, అత్యల్ప ఆవేశం, అత్యంత ఉపయోగకరమైన విషయం
క్లాయిడ్ తప్పుగా క్రమ బద్ధంగా కోడ్ వ్రాస్తుంది. అది ఆ వెర్షన్ ను పొందగలిగితే. మీ శైలిని పేస్టు చేయండి. స్పష్టంగా చెప్పండి:
- ఫార్మటింగ్ (Prettier, Black, gofmt డిఫాల్ట్)
వార్తలు తెలియచేయవచ్చును. భవిష్యత్తు మీరు కృతజ్ఞత తెలుపుతారు, మరియు ప్రస్తుత క్లాయిడ్ కు "ఫిక్స్-అప్" PR లను తగ్గించుట కంటే.
పొడవైన ప్రాంప్ట్స్, సంక్షిప్త అవుట్ పుట్లు
క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కోసం ప్రాంప్ట్ గురించి మరో విధానం: ప్రాంప్ట్ పంటే ఖర్చైన జాతీయాలను మీరు కంటే సామర్థ్యం ఏదో కాదు.
- ప్రాంప్ట్ లో ఖర్చుకునియన అర్థ కట్టివిచ్చాయి
- అవుట్ పుట్లో సమస్యలు లేదు
ఇది వివరణలను ప్రథమించి కేవలం కోడ్ బ్లాక్లతో ఫైల్ పేరు తప్ప మరియు కాంటెక్ట్స్ అడగండి. మీరు వ్యాఖ్యానాలను కావాలంటే, అది వేరే రన్ లో అడగండి. ప్రాసీ మరియు కోడ్ ను అన్ని దోషాలు ఉండే బాధకరం గా ఉంది.
రిఫైన్మెంట్: నిజంగా పనిచేసే అధిక రవాణాలు
నమ్మస్పృహ కడుగుట పలనకు "ఇప్పుడే సరికాదు" మెరుగులు. సరైన నిందెనల్ స్పష్టతలు: "పరీక్షలు ఉత్పత్తిని రూపొందించండి + కోడ్."
- ప్రవేశం స్థానికంగా. ఫేలింగ్ టెస్ట్ అవుట్ పోర్టులను మరియు కంపిల్లర్ లోపాలను క్లాయిడ్ పూర్తిగా వేయండి.
- ఆజ్ఞ: "కేవలం అవసరమైన కోడ్ కోడ్ ప్రామాణికాలు మార్చొద్దు, అవసరమైన కొన్నిసార్లు మాత్రమూ వాస్తవాలను మార్చలోపల."
- క్లాయిడ్ తగినదిగా భాజనాలు చేసినప్పుడు, అది ఏమి అవస్తలోకులను ఖాళీ చేయ వచ్చు. పద్దతులను అలా కరువుగా లేదు.
భద్రత కీ సౌకర్యము, ఒక అనుభూతి కాదు
మోడల్స్ ప్రజా కోడ్ (బాగు, చెడు, మరియు శాపితమైన) మెసోడ్ ఉంది, మీ భద్రతను మొదటి-తరం అవసరం అయియే:
ఎవిఎల్, shell=True, మరియు పద్ధతి SQLని నిరాకరించండి కూడలేదు
- పరామితిక విచారణలు, CSRF రక్షణ, మరియు రేటు పరిమితులు ఇవ్వండి.
- నిర్బంధాన్ని జోడించి ఒక కంటే నిర్ధందించండి
- సీక్రెట్ మేనేజర్ లేదా పర్యావరణ మార్పు ద్వారా ఉపాధి చేయండి.
- ఇది మొదటి-తరం ప్రాంప్ట్ సరదాగా కోడ్ అందిస్తుంది. "మేము కాలానుగుణంగా ఉంటుంది" ప్రాంప్ట్ వార్తాలు వస్తాయి.
నిర్దేశనను చెప్పండి; "చెప్పండి" అని ఉటన్నట్లు.
పునరూల్పట్లలో చెప్పండి "వేగంగా చేయాలి"/
ఆర్ టార్గెట్ వాదనలు (p95 < 50ms అనుక్రమణిక, p95 < 300ms డేటాబేస్ ఆపరేషన్స్)
- మెమీ కప్పులు (RSS < 150MB)
- కాల ప్రమాణ క్రమం (O(n log n), O(n^2) చేయాలి)
- క్లాయిడ్ మీరు ఎక్కించాలని పూనటం చేర్చుతుంది. వేటను ఇవ్వండి.
దస్త్రాలు: ప్రవేశీకుడుపుండు
క్లాయిడ్ నుండి README కోసం అడగండి:
కస్టమ్ ఆదేశాల సెట్ నాయకత్వం జాబితా
- స్క్రిప్ట్, టైపు చెక్, లోన్ కనుక צוויי; దోషాలు నాయకత్వం.
- ఉదాహరణ అభ్యర్థనలు/సమాధానాలు
- పరిమితులు మరియు తెలియని గమనాల్లో trade-off కొన్ని.
- "ఖచ్చితమైన కోడ్" ఖచ్చితమైన పుస్తకాల భాగాలనూ సూచిస్తాయి. అవి డెలివరీ భాగం.
స్థితిని偷వద్దు మీరే కొట్టు.
గ్రీటెడ్ రూపకల్పనను మీరు ఎంనంటి అనుభవంలోకి మరణించారు.
లేఅవు: బ్యాక్ ఎండ్ ఎండ్ పాయింట్
వ్యవస్థ: మీరు ఒక అక్షరధన అంతం గా నాయకత్వం నియమిస్తున్నున్నారు. ఫైళ్ల పేర్లతో అందించిన కోడ్ బ్లాకె డొక డొక కాకుండా ఉత్పత్తి చేయడానికి.
యూజర్:
- ఒక FastAPI 0.111 app ని POST /convert ఎండ్ పాయింట్ తో నిర్మించండి.
- మరింతగా: {సంఖ్య: Decimal as string, నుండి: 'USD'|'EUR', to: సమానం}.
- Pydantic v2తో సమాధానాలను ధృవీకరించండి;
- Fixసరూపంగా సామర్థ్యాన్ని సమావేశం చేయడానికి (వ్యాభానం) {USD:1, EUR:1.1}.
- 200 పిదప {సంఖ్య: string, కరెన్సీ: string} వెంటనే ఉత్పత్తి చేయండి.
- సరైన, అమలు, పూలను ఎవరికైన పునార్థక వృత్తిని నిర్ణయించండి. మినహాయించలేదు.
- టెంప్లేట్: CLI యూజర్లు క్యాయొద్దు.
- వ్యవస్థ: మీరు Go 1.22 ను పేరు ఉంచారు. కేవల్ల ఫైలు కోసం కోడ్ బ్లాక్ లను ఉత్పత్తి చేయృకు అలా.
యూజర్:
stdinను చదువుతూ URL-సురక్షితమైన స్లగ్లను ముద్రించటం ఏర్పాటుచేయండి.
శిక్షణ: అక్షర, ASCII మాత్రమే, హఫర్ విడిగా, శ్వేతలను క్షీణించు, ఘన్ తగ్గించండి.
- main.go మరియు slugify_test.go తో క్వెంపర్ ఆద్యాపరిచయాలను అందించండి.
- Go stdlibని మాత్రమే ఉపయోగించండి.
- పరీక్ష మరియు నిర్మాణాల దోష నాటవండి.
- టెంప్లేట్: ఫ్రంట్ ఎండ్ కాంపోనెంట్
వ్యవస్థ: మీరు కార్యారంభించిన తేదీ మరియు టైపు అకౌంట్ లోని ఒక సాధ్యం React ఇంజినర్చే.
యూజర్:
ఒక <DebouncedInput> భాగాన్ని అమలు చేయండి.
- ప్రాపర్టీస్: విలువ: స్ట్రింగ్, onChange(value): ఖాళీ, ఆలస్యము=300.
- useRef/useEffect ఉపయోగించండి; మూడవ పార్టీ హుక్స్.
- నకిలీ టైమర్లతో vitest పరీక్షలను చేర్చండి.
- సామాన్యమైన కథన స్టోరీని అందించాలి.
- ఈ టెంప్లేట్లు, క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కోసం వర్షన్లను పిన్చి, ప్రవర్తనను నిర్వచించడం మరియు పరీక్షలను తదనుకృతం చేయడం చూపుతున్నాయి.
సమారోచనకు అంగీకరించడం: మీరు "ఒప్పొడిగా తల పరులా" అని చెప్పకండి.
మీరు ప్రాథమిక దాచడం వద్ద లేదా గేమ ఆధారంగా ఉత్పత్తిని అలా.
మరయినా మీరు తక్షణంగా కనీయ్యు మరియు అంటే నువ్వు; "ఈ ఊహను కట్టుబడి చెడుగండి."
- సుబానంతరం మీరు యా క్రములను నకిలీ విధ్యం көшпенారовать дурукта, లేదా జన పురస్థాలకు సూచించడం.
- నిర్మాణం వదలండి; స్పష్టత్వం > అంగీకారం.
- క్లాయిడ్ ఆకర్షణను ఇష్టపడుతుంది. దానిని వదలండి. ఇది పరీక్షలను కృషి చేసేటప్పుడు వారుని అంచనా ఇవ్వడం.
వర్క్ ఫ్లోల్లో, ఇది నిజంగా సహాయపడుతుంది.
నేను చూసినాను, ప్రజలు సెలవులను రత్రకం చేరువ చేసే ప్రాముఖ్యం చేసే వాయిదం వంటి ప్రాసెస్ నిర్వహణ లేదు. కోడ్ కాంటెక్స్ట్ను అర్థం చేసుకునే వర్క్ స్పేస్ను ఉపయోగించండి. ఉదాహరణకు, , మీ స్పెక్, కోడ్, డిఫ్స్, మరియు పరీక్షల లాగ్స్ చూపింపులో ఉంచేందుకు కట్టుబడి ఉంది, కాబట్టి "పేస్ట్ ఎర్రర్, సర్దుబాటు చేయండి" చక్రం తప్పుగా సరళంగా ఉంటుంది. ఇది మంత్రము కాదు; అది గతం ఏమిటంటే, వివరణను మీరు కోల్పోవడం అరికట్టబోతుంది. మీ పరికరం ఒప్పందం, పరీక్షలు మరియు కోడ్ ను ఒకే సంభాషణలో ఉంచడం వదిల్ వద్ద లేదు - మీరు కుండలో నీళ్లు దిగకుండా ఉండకుండా - ఉపయోగించండి. Sider చేస్తుంది.
క్లాయిడ్ ను ఒక సహాయదారునిగా డిబగ్గింగ్ చేయడం ఎలా, ఒక ఆర్జేగాడు కాదు
విఫలమైన పరీక్ష అవుట్ పుట్ను అలాగే పేస్ట్ చెయ్యండి. సారాంశంలో కాదు.
- ఒక వివరణను అడగండి: "ఫైల్ X కు యూనిఫైడ్ డిఫ్ తో ప్రత్యుత్తరం ఇవ్వండి మాత్రమే."
- రన్టైమ్ లోపాల కొరకు, అత్యల్ప పునర్యవస్థన పంక్తిని జోడించండి మరియు వివరణను మరియు ప్యాచ్ను తప్పకుండా డిమాండ్ చేయండి.
- లైబ్రరీ తప్పుల కొరకు, మీరు అనుకుంటున్న డాక్ తరగతిని పేస్ట్ చేయండి మరియు అడగండి: "అది X సంస్కరణకు సరైన API గా ఉందా? విషయం లేదు కాగా, కోడ్ అప్ డేట్ చేసి సరైన ఉటలు మాత్రమేని చెప్పండి."
- లక్ష్యం క్లాయిడ్ దృర్షముగా మీకు సత్యావచనంలో సహాయం చేస్తుంది. మీరు సత్యావచనం తీసుకువస్తారు.
పోద్బలలు యొక్క శ్రేణి వెళ్ళండి (మరియు మీరు దొరకెగు)
"లేటెస్ట్" API వైపు: "లేటెస్ట్" అని చెయ్యండి. "X.Y సంచికను ఉపయోగించండి" మరియు దానితో పర్యవేక్షించండి.
- ఖాళీ పరీక్ష ఫైల్: మీరు పరీక్షలను అడగకపోతే, మీకు అందించదు.
- ఒక అర ప్రముఖలో రాజు కల్పనా: మీకు రెండు లేదా మూడు కవితలను ప్లాన్ చేయండి. ఇది ఒక ఉబాదభద్రతను ఆకర్షించే కంటే వేగంగా ఉంది.
- అస్పష్టమైన గా శాసన ప్రక్రియ: స్థితి కోడ్లు మరియు ప్యాలోడ్లను నిర్వచించండి. "లోపాన్ని తిరిగి ఇవ్వండి" అని అర్థం లేదు.
- ఓ ఎదో సామర్థ్యంలో ఉండడానికి పరికరపై ఆధారపడి ఉంటే, అది తటస్థం లేదు. మోసాన్ని అడగండి.
- నేను మీ ప్రాంప్ట్ చెక్ పింఛు ఉోయసుకుంటున్నారు (మీ మానిటర్ పక్కన పెట్టండి)
భాష మరియు రన్టైమ్ వెర్షన్ పిన్
- డేటా స్కీమాలు నిర్వచించండి
- లోపం సెమాంటికులు నిర్వచించండి (కోడ్లు, ఆకారాలు)
- మొదట పరీక్షలు, ఆ తరువాత కోడ్
- భద్రతా పరిమితులు స్పష్టంగా
- శైలి మరియు నిర్మాణాన్ని ఉత్పత్తి చేయడం
- అవుట్ పుట్ రూపం తప్పించాలి (ఫైలులు, కోడ్ బ్లాక్స్, డిఫ్)
- అత్యల్ప సవరణ చక్రం మరియు పేస్టెడ్ లాగ్
- మీరు పగ్గం చెయ్యండే, క్లాయిడ్ హైకూ 4.5 సాధారణంగా ఖచ్చితమైన కోడ్ ఉత్పత్తి చేస్తుంది.
మీరు ఖచ్చితమైన వాటిని అందిస్తే, మీరు కూడా ఉత్తమ అనుభూతిని పొందుతారు.
ఒక Worked ఉదాహరణ: అస్పష్టత నుంచి సత్య అవగాహన
అస్పష్టమైన ప్రాంప్ట్: "CSV ను సక్రియంగా పార్స్ చేసే ఫంక్షన్ వ్రాయండి."
ఫలితం: అవిశ్వాసం, సత్యమేను అంగీకరించని అయిన అన్నూ టెస్ట్ చేయలేదు.
ఖచ్చితమైన ప్రాంప్ట్:
"మీరు Python 3.12 ను రాస్తున్నారు. ఫైల్ పేర్లతో కేవలం కోడ్ బ్లాక్స్ ఉత్పత్తి చేయండి. CSVsafe/init.py మరియు CSVsafe/reader.pyని రూపొందించండి, ఒక ఫంక్షన్ను చదువండి: read_rows(path: Path) -> list[dict[str,str]]. అవసరాలు: CSV.DictReader ని ఎన్నుకోండి newline='' మరియు encoding='utf-8'; null byteలను నిరాకరించండి; >10MB ఫైళ్లను తిరస్కరించండి; కాలమ్లను 100గా పరిమితం చేయండి; BOMను కటించండి; ఖాళీ సెల్లను ఖాళీ స్ట్రింగులుగా పరిగణించండి; ValueErrorని విషయాల పట్ల raise చేయండి {FILE_TOO_LARGE, NULL_BYTE, TOO_MANY_COLUMNS}. Tests/test_reader.py లో TESTలను పొందించండి, సంతోషంగా, null byte, 11MB ఫైళ్ళను 101 కాలమ్ మరియు BOM సంబంధం కలిగి ఉండండి. అందించండి pyproject.toml కు వైవిధ్యం పిన్చండి మరియు అంకితమైన ధన్యవాదాలు మంజూరు చేయవచ్చు.
మీరు కోడ్, పరీక్షలు మరియు ఎడ్జ్ హాండ్లింగ్ ఉంటాయి. తరువాత పరీక్షలు నడుపండి, ఫేల్లు పేస్ట్ చేయండి మరియు తక్కువ దోషాల బేస్టుపెరట్టు చేస్తాయి. ఇది ఖచ్చితమైన కోడ్ ఉత్పత్తి అనుభవంలో.
పై "క్రియ గురించి" ఇంకా అందించిన పదాలు
నేను "రచన" కోడ్ అవసరం లేదు. నేను సరైన కోడ్ అవసరం. మీ పులిని పేరు పెట్టడానికి రొణం చేయండి. క్లాయిడ్ ప్రాంప్ట్ చెపక్రి సక్రమ సంబంధంగా ఉందని, ఉత్సాహం పుట్టించారు. సరైన పరీక్షలు మరియు స్పష్టత గత సమస్యలను పరిష్కరిస్తాయి.
సీక్రెట్ డార్క్
క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి కొరకు నిశ్చయంగా ప్రకటనలు వేసే విషయాలు ఇది బోరింగ్: మీ అవసరాలను వ్రాయండి, కింది వాల్యూమ్లు నియమించండి, స్కీమాలను నిర్వచించండి, ప్రస్తుతం పరీక్షలను కోరండి మరియు నిజమైన విఫలములతో చూపించండి. అదంతే. ఏ మాంత్రికంలో అక్కర్లేదులు. డిసిప్లిన్ కావాలి, చాలా వేగంగా టైప్ చేసే మోడల్ తో.
ఇది మలుపు: ఖచ్చితత్వం అంగీకారంగా ఉంది. ప్రాంప్ట్లు TSA చెక్లను చదివినట్లు ఉంటుంది. సుమారు వినియోగించేవరు ఉండవచ్చు, అర్దం బట్టి భావం ఉని. మీరు ఏదో దోయి ఆదరించడం ద్వారా ప్రశక్తి కల్గించడానికి వ్యవహారాలు ఒక ఏర్పడును నారడం ద్వారా ప్రశక్తి నిర్వహణలదు.
సంక్షిప్త సందర్భం: అస్పష్టత యజమాని మరియు తగిన సంక్షేమం
మీకు మాంత్రికతను అవసరం అయితే, ఒక మాంత్రికశాల వెళ్ళండి. మీరు క్రియాత్మకమైన సాఫ్ట్వేయర్ కావాలి అంటే, వారంటీలను అందించిన వస్తువులలో కొంత బాధ్యత వహించేందుకు వంటి ప్రాంప్ట్ వ్రాయండి. క్లాయిడ్ హైకూ 4.5 కు ఖచ్చితమైన కోడ్ ఉత్పత్తి చేయడానికి మాంత్రికమైన పదం, నిర్దిష్టతలు, పరీక్షలు, వెర్షన్లు, మరియు అభిప్రాయాల చీకటి. ఈ నాలుగు అంశాలు మీకు కోడ్ అందిస్తాయి. వాటిని మర్చిపోయే మొదట, కాస్త కచ్చితమైన ఫార్మాట్ను పొందుతారు.
మీ వైబ్ల గురించి కోడ్ పట్టించుకోదు. అదృష్టవశాత్తూ, పరీక్షలు కూడా పట్టించుకోవు.
తరచుగా అడిగే ప్రశ్నలు
Q1: ఖచ్చితమైన కోడ్ జనరేషన్ కోసం Claude Haiku 4.5ని ప్రాంప్ట్ చేయడానికి సులభమైన మార్గం ఏమిటి?
దీన్ని ఒక ఒప్పందంగా పరిగణించండి: పిన్ వెర్షన్లు, స్కీమాలను నిర్వచించండి, ఎర్రర్ ఫార్మాట్లను పేర్కొనండి మరియు ముందుగా పరీక్షలు అవసరం. పరిమితులు ఎంత స్పష్టంగా ఉంటే, కోడ్ అంత ఖచ్చితంగా ఉంటుంది.
Q2: క్లాడ్ కోడ్ రాసేటప్పుడు భ్రమలను ఎలా తగ్గించాలి?
అధికారిక డాక్స్ లేదా స్పెక్స్లను అతికించి, ఆ ఖచ్చితమైన APIలకు కట్టుబడి ఉండాలని డిమాండ్ చేయండి. ప్రైవేట్ ఎండ్పాయింట్ల కోసం, మీ స్వంత స్పెక్ను చేర్చండి—అది ఊహిస్తుందని ఆశించవద్దు.
Q3: నేను క్లాడ్ని పరీక్షల కోసం అడగాలా లేదా నేనే వాటిని వ్రాయాలా?
ముందుగా పరీక్షలను రూపొందించమని క్లాడ్ని అడగండి, ఆపై వాటిని సంతృప్తి పరచడానికి కోడ్ను అమలు చేయండి. విశేషణాలు కంటే పరీక్షలు ఖచ్చితత్వాన్ని బాగా నిర్వచిస్తాయి మరియు మోడల్ను నిజాయితీగా ఉంచుతాయి.
Q4: ప్రాంప్ట్లలో వెర్షన్ పిన్నింగ్ ఎంత నిర్దిష్టంగా ఉండాలి?
చాలా నిర్దిష్టంగా: లాంగ్వేజ్ రన్టైమ్, ఫ్రేమ్వర్క్ మేజర్/మైనర్ మరియు SDK వెర్షన్లు. “లేటెస్ట్” వైరుధ్య నమూనాలను ఆహ్వానిస్తుంది; ఖచ్చితత్వం స్థిరమైన లక్ష్యాలపై ఆధారపడి ఉంటుంది.
Q5: ఖచ్చితమైన కోడ్ కోసం ప్రాంప్టింగ్ చేయడానికి Sider.AI ఎక్కడ సరిపోతుంది?
స్పెక్స్, కోడ్, డిఫ్లు మరియు టెస్ట్ లాగ్లను ఒకే లూప్లో ఉంచడానికి Sider.AIని ఉపయోగించండి. ఇది మేజిక్ చేయదు—ఇది సందర్భాన్ని సంరక్షిస్తుంది, తద్వారా క్లాడ్ పరిష్కారాలు మీ అసలు వైఫల్యాలను ట్రాక్ చేస్తాయి. 
