Claude Code સ્વચાલિત પ્રોગ્રામિંગના વાસ્તવિક કેસ પર આધારિત, કેટલીક પ્રોમ્પ્ટ ટેકનિક્સ શેર કરું છું

આ લેખ, એક વાસ્તવિક કેસ દ્વારા, તમને Claude Code ના વાસ્તવિક ઉપયોગના કેસ વિશે શેર કરશે. શેર કરતા પહેલા, ચાલો એક નાનો સર્વે કરીએ
મૂળ જરૂરિયાત: એક માનનીય ચુકવણી કરનાર યુઝર હતો, જે ઇચ્છતો હતો કે હું લેખમાં, લેખનો બદલાયેલ સમય ઉમેરું
આ જરૂરિયાત પહેલી નજરમાં, અમલમાં લાવવી થોડી મુશ્કેલ લાગે છે. કારણ કે મારી વેબસાઇટના લેખો, ડેટાબેઝમાં સંગ્રહિત નથી, બધા next.js ના SSG નો ઉપયોગ કરીને બનાવવામાં આવ્યા છે. તેમાં અપડેટ સમય હોતો જ નથી.
અહીં એક ટેકનિક છે: સમસ્યા હલ કરતી વખતે, આપણે મૂળ જરૂરિયાત સીધી Claude Code ને ન આપીએ, નીચેના કારણોસર
1. મૂળ જરૂરિયાત પ્રમાણમાં અસ્પષ્ટ છે, તે ખોટી સમજણ પેદા કરી શકે છે, અને જો એકવાર તે ખોટી સમજે તો, છેલ્લે તે તમને સમય ઉમેરી શકે છે, પરંતુ આ સમય વિશ્વસનીય ન પણ હોઈ શકે
2. Claude Code નો Token વપરાશ ખરેખર ખૂબ મોંઘો છે, તેથી, અસ્પષ્ટ જરૂરિયાત અર્થહીન રીતે મોટી સંખ્યામાં Token નો વપરાશ કરાવી શકે છે
તેથી, આપણે મૂળ જરૂરિયાતને એકવાર વિભાજિત કરવી પડશે, મેં પહેલા deepseek માં સલાહ લીધી, deepseek મને બે ઉકેલ આપ્યા
1. ફાઇલ બિલ્ડ સમય, દરેક વખતે build કરતી વખતે, આપણે ફાઇલનો બિલ્ડ સમય મેળવવાની જરૂર છે, પરંતુ turbopack ની પેકેજિંગ રણનીતિ થોડી અલગ છે, તે દરેક વખતે બિલ્ડ કરતી વખતે, ફાઇલનો hash મૂલ્ય બદલાય છે, આ બિલ્ડ સમય વિશ્વસનીય ન પણ હોઈ શકે
2. git સબમિટ સમય, મને લાગ્યું કે, આ વધુ વિશ્વસનીય હોવો જોઈએ
ઉકેલની દિશા મળ્યા પછી, મારી પાસે આ સરળ પ્રોમ્પ્ટ હતી: git સબમિટ સમય દરેક .mdx લેખના શીર્ષકમાં કમ્પાઇલ કરો
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 (
{children}
);
}પરંતુ વાસ્તવિક સ્થિતિ એ છે કે, મારે જે પરિણામ જોઈએ છે તે આ છે, ચલાવવાનું પરિણામ સંપૂર્ણપણે સમાન છે.
import MdxLayout from 'components/mdx-layout';
export default function Article({ children }: any) {
return (
{children}
);
}અને પછી આ સમયે, મેં પ્રોમ્પ્ટ પર એક ખાડો ખાધો
મેં ફરીથી પ્રોમ્પ્ટ ઇનપુટ કરી: ઉપરના જેવી જ રીતે છોડવામાં આવેલી 171 ફાઇલોને રિફેક્ટર કરો
મારી આ અભિવ્યક્તિ, ધ્યાનથી વિચારીએ તો તેમાં થોડી અસ્પષ્ટતા છે. કારણ કે Claude Code મને પહેલેથી જ એક સૂચનાત્મક ઉકેલ આપી ચૂક્યું છે, પરંતુ હું આ ઉકેલ સ્વીકારતો નથી, મારો હેતુ હતો કે, સુધારેલી સેંકડો ફાઇલો જેવી યોજના વડે છોડવામાં આવેલી ફાઇલોને સુધારવી, પરંતુ એક્ઝિક્યુશન દરમિયાન, તેને આ રીતે સમજવામાં આવ્યું: ઉપર તે મને સૂચવેલી યોજના
આ અસ્પષ્ટતાને કારણે, તે મારી ન ઇચ્છેલી યોજના અનુસાર 20 મિનિટ સુધી એક્ઝિક્યુટ કરવા લાગ્યો, વચ્ચે 2 વાર ભૂલો સ્વયં સુધારવામાં આવી, મારા token ને ઝડપથી ખાઈ ગયો, બે અસ્પષ્ટતાઓ એકબીજા સાથે લડવા લાગી અને ભૂલો થઈ.
છેલ્લે મારે ફરીથી આ એક્ઝિક્યુશન છોડવું પડ્યું, મારો અર્થ સ્પષ્ટ કરવો પડ્યો.
સારાંશ
1. પ્રોમ્પ્ટમાં, પ્રમાણમાં સ્થિર અને સચોટ ઉકેલો શામેલ હોવા જોઈએ, AI ને જેટલું ઓછું વિચારવું પડે તેટલું સારું, આથી ભ્રમણાનો દર ઘટશે.
2. જરૂરિયાતના પ્રોમ્પ્ટમાં કોઈ અસ્પષ્ટતા ન હોવી જોઈએ, અસ્પષ્ટતા ભૂલો તરફ દોરી શકે છે, ભલે Claude Code છેલ્લે સુધારી શકે, પરંતુ આથી મોટી સંખ્યામાં token નો વપરાશ થશે. અને LLM પ્રેડિક્શન મિકેનિઝમ પર આધારિત પરિણામો આપે છે, પ્રારંભિક ખોટી સમજણ, અસ્પષ્ટતા વગેરે, પછીના દરેક પગલાને ખોટી દિશામાં દૂર લઈ જશે, અને તે તાર્કિક સ્વ-સુસંગતતાનો પ્રયાસ પણ કરશે, અસ્તિત્વમાં ન હોય તેવી વસ્તુઓ જનરેટ કરશે, જેથી સમસ્યાઓ વધતી જશે, અને ડેવલપરની સમીક્ષાની મુશ્કેલી પણ વધશે, જો તમે તેના ભ્રમણામાં ફસાઈ જશો, તો ગંભીર પરિણામો આવશે
3. કુદરતી ભાષાની બંધનક્ષમતા કોડ જેટલી સચોટ નથી, પ્રોમ્પ્ટમાં, ફાઇલ નામ, કોડ વેરીએબલ, કોડ વિશિષ્ટ શબ્દો, વ્યાવસાયિક શબ્દો વગેરે શામેલ કરવાથી Cluade Code ના ભ્રમણામાં ઘણો ઘટાડો થશે





