Claude Code ఆధారంగా ఒక నిజమైన ఆటోమేటెడ్ ప్రోగ్రామింగ్ కేసు ద్వారా కొన్ని ప్రాంప్ట్ టెక్నిక్లను షేర్ చేస్తున్నాను

ఈ వ్యాసంలో, ఒక నిజమైన కేసు ద్వారా, Claude Code యొక్క నిజమైన ఉపయోగ కేసును మీకు షేర్ చేస్తున్నాను. షేర్ చేయడానికి ముందు, ఒక చిన్న సర్వే చేద్దాం

అసలు అవసరం: ఒక గౌరవనీయమైన చెల్లింపు వినియోగదారు, వ్యాసాల్లో వ్యాసం మార్పు సమయాన్ని జోడించాలని నా నుండి కోరాడు

ఈ అవసరం మొదటి చూపులో, అమలు చేయడం కొంచెం కష్టంగా ఉంది. ఎందుకంటే నా వెబ్సైట్ వ్యాసాలు, డేటాబేస్లో నిల్వ చేయబడవు, అన్నీ next.js యొక్క SSG ఉపయోగించి నిర్మించబడ్డాయి. దానికి నవీకరణ సమయం అసలు లేదు.

ఇక్కడ ఒక టెక్నిక్ ఏమిటంటే: సమస్యను పరిష్కరించేటప్పుడు, మేము అసలు అవసరాన్ని నేరుగా Claude Codeకి ఫీడ్ చేయకూడదు, కింది కారణాల వల్ల

1. అసలు అవసరం సాపేక్షంగా అస్పష్టంగా ఉంటుంది, అది తప్పుగా అర్థం చేసుకోవచ్చు, ఒకవేళ అది తప్పుగా అర్థం చేసుకుంటే, చివరికి అది మీకు ఒక సమయాన్ని జోడించినా, ఈ సమయం నమ్మదగినది కాకపోవచ్చు

2. Claude Code యొక్క టోకెన్ వినియోగం నిజంగా చాలా ఖరీదైనది, కాబట్టి, అస్పష్టమైన అవసరాలు పెద్ద మొత్తంలో టోకెన్లను అర్థంలేని విధంగా వినియోగించడానికి దారి తీయవచ్చు

అందువల్ల, మేము అసలు అవసరాన్ని ఒకసారి విడదీయాలి, నేను ముందుగా deepseekలో సంప్రదించాను, deepseek నాకు రెండు పథకాలను ఇచ్చింది

1. ఫైల్ నిర్మాణ సమయం, ప్రతి build సమయంలో, మనం ఫైల్ నిర్మాణ సమయాన్ని పొందాలి, కానీ turbopack యొక్క ప్యాకేజింగ్ వ్యూహం కొంచెం భిన్నంగా ఉంటుంది, ఇది ప్రతి నిర్మాణ సమయంలో, ఫైల్ యొక్క hash విలువ మారుతుంది, ఈ నిర్మాణ సమయం నమ్మదగినది కాకపోవచ్చు

2. git సమర్పణ సమయం, నేను ఆలోచించినప్పుడు, ఇది చాలా నమ్మదగినదిగా ఉండాలి

సుమారుగా పరిష్కార దిశ ఉన్న తర్వాత, నాకు ఈ సరళమైన ప్రాంప్ట్ ఉంది: ప్రతి .mdx వ్యాసం శీర్షికలో git సమర్పణ సమయాన్ని కంపైల్ చేయండి

Claude Code చాలా నమ్మదగినది, ప్రాంప్ట్ పదాలు ఖచ్చితంగా ఉంటే, మొత్తంమీద ఎలాంటి లోపాలు లేవు, అది వెంటనే అమలు చేయడం ప్రారంభించింది

7 డాలర్లు నా కోటాను ఖర్చు చేసిన తర్వాత, 20 నిమిషాలు పట్టింది, చివరికి అమలు విజయవంతమైంది.

అనుకున్నట్లుగా లేకపోతే, అనుకోని సంఘటన జరిగింది, అది 171 ఫైళ్ల మార్పును దాటవేసింది.

ఇక్కడ చాలా ఇబ్బంది ఏమిటంటే, వాస్తవానికి ఇక్కడ దాటవేయబడిన ఫైళ్లు, కేవలం అదనపు pass పారామీటర్ మాత్రమే పంపబడ్డాయి, మిగతా అన్నీ పూర్తిగా ఒకే విధంగా ఉన్నాయి

<PostLayout pass>...

కానీ అది మార్పులేనిది, ఈ అదనపు పారామీటర్ను పంపడం, పూర్తిగా భిన్నమైన కస్టమ్ కాంపోనెంట్గా నిర్వచించింది. ఆపై దాన్ని ప్రాసెస్ చేయకుండా దాటవేసింది ～ ～

import Layout from 'components/post-layout';
import { getGitFileInfo } from '@/utils/git-info';
export default function Article({ children }: any) {
  const gitInfo = getGitFileInfo('src/app/మీ మార్గం/page.mdx');
  return (
    <Layout gitInfo={gitInfo || undefined}>
      {children}
    </Layout>
  );
}

కానీ నిజమైన పరిస్థితి ఏమిటంటే, నాకు కావలసిన ఫలితం ఇలా ఉండాలి, రన్ చేసిన ఫలితం పూర్తిగా ఒకే విధంగా ఉండాలి.

import MdxLayout from 'components/mdx-layout';
export default function Article({ children }: any) {
  return (
    <MdxLayout pass filePath="src/app/r19base/(4.compiler)/23.compilerlower/page.mdx">
      {children}
    </MdxLayout>
  );
}

ఆపై ఈ సమయంలో, నేను ప్రాంప్ట్ పదాలపై ఒక గుంతలో పడ్డాను

నేను మళ్లీ ప్రాంప్ట్ పదాలను ఇన్పుట్ చేసాను: దాటవేయబడిన 171 ఫైళ్లను పైన ఉన్న విధంగానే రీఫ్యాక్టర్ చేయండి

నా ఈ వ్యక్తీకరణ, జాగ్రత్తగా ఆలోచించినప్పుడు దానికి కొంత అస్పష్టత ఉంది. ఎందుకంటే Claude Code ఇప్పటికే నాకు ఒక సూచన పథకాన్ని ఇచ్చింది, కానీ నేను ఈ పథకాన్ని అంగీకరించలేదు, నా ఉద్దేశ్యం ఏమిటంటే, మార్చబడిన వందల ఫైళ్ల వలె ఉన్న పథకంతో దాటవేయబడిన ఫైళ్లను మార్చడం, కానీ అమలు ప్రక్రియలో, అది దానిని ఇలా అర్థం చేసుకుంది: పైన అది నాకు సూచించిన ఆ పథకం

ఈ కొంచెం అస్పష్టత, నేను కోరుకోని పథకం ప్రకారం అది 20 నిమిషాలు అమలు చేయడానికి దారి తీసింది, మధ్యలో 2 సార్లు లోపాలు స్వీయ-సరిదిద్దుకోవడం కూడా జరిగింది, అది నా టోకెన్లను గట్టిగా మింగడం ప్రారంభించింది, రెండు రకాల అస్పష్టతలు పోరాడటం ప్రారంభించాయి, ఇది లోపాలకు దారి తీసింది.

చివరికి నేను మళ్లీ ఈ అమలును విరమించుకోవలసి వచ్చింది, నా అర్థాన్ని మళ్లీ స్పష్టం చేయాల్సి వచ్చింది.

సారాంశం

1. ప్రాంప్ట్ పదాలలో, సాపేక్షంగా స్థిరమైన మరియు ఖచ్చితమైన పరిష్కార పథకం ఉండటం మంచిది, AI తక్కువ ఆలోచించేలా చేయండి, ఇది భ్రమ రేటును తగ్గించడంలో సహాయపడుతుంది.

2. అవసరాల ప్రాంప్ట్ పదాలలో ఎప్పటికీ అస్పష్టత ఉండకూడదు, అస్పష్టత లోపాలకు దారి తీయవచ్చు, Claude Code చివరికి సరిదిద్దుకోవచ్చు అయినా, ఇది పెద్ద మొత్తంలో టోకెన్ వినియోగానికి కారణమవుతుంది. మరియు LLM అంచనా యంత్రాంగంపై ఆధారపడి ఫలితాలను ఉత్పత్తి చేస్తుంది కాబట్టి, ప్రారంభ దశలో తప్పుగా అర్థం చేసుకోవడం, అస్పష్టత మొదలైనవి, తదుపరి ప్రతి దశలో తప్పు దిశలో మరింత దూరం వెళ్లడానికి దారి తీస్తాయి, మరియు అది తార్కిక స్వీయ-స్థిరత్వాన్ని ప్రయత్నించడం కూడా చేస్తుంది, ఉనికిలో లేని విషయాలను రూపొందించడం, ఎంత వ్రాస్తే అంత సమస్యలు పెరుగుతాయి, మరియు డెవలపర్ యొక్క సమీక్షా కష్టాన్ని కూడా పెంచుతాయి, మీరు దాని భ్రమలతో మోసపోతే, అది తీవ్రమైన పరిణామాలకు దారి తీయవచ్చు

3. సహజ భాష యొక్క నిర్బంధ శక్తి కోడ్ ఖచ్చితత్వం లాగా ఉండదు, ప్రాంప్ట్ పదాలలో, ఫైల్ పేరు, కోడ్ వేరియబుల్, కోడ్ ప్రత్యేక పదాలు, సాంకేతిక పదాలు మొదలైనవి ఉండటం, Cluade Code యొక్క భ్రమలను గణనీయంగా తగ్గిస్తుంది