ભૂમિકા: કોડને તમારી લાગણીઓની ફિકર નથી
વિશાળ ભાષા મોડલ્સ અને કોડની વાત એમ છે કે તેઓ આશ્ચર્યજનક રીતે આત્મવિશ્વાસ સાથે ભલે તમારું પ્રોગ્રામ કમ્પાઈલ થાય કે નહીં તે બાબતમાં નિર્લિપ્ત હોય છે. Claude Haiku 4.5 તમારી સમસ્યાનું સમાધાન કરતી Python સ્ક્રિપ્ટ હંમેશા લખી શકે છે, અને રમતમાં માટે બે વધુ કોડ પણ બનાવી શકે છે. الأساسي તરિકો — જે એકમાત્ર મહત્વનો છે —Claude Haiku 4.5 ને સ્પષ્ટ અને ટેકી કોડ બનાવવા માટે પ્રોમ્પ્ટ કેવી રીતે કરવો તે શીખી લેવા છે, જેમાં લાગણીઓ માટે કોઇ જગ્યા ના હોય અને સાચાઈ માટે પૂર્ણ જગ્યા રહે. તમને કોડ જેવો લાગે એવો પ્રોઝ ન જોઈએ, તમારે એવા કોડ જોઈએ જે કોડ જેવો વર્તે. આમાં ભેદ છે.
લોકો પ્રોમ્પ્ટિંગને રહસ્યમય મંત્રપાઠ જેવી રીતે માને છે—જરૂરી શબ્દો કહો, અને સંપૂર્ણ એપ મળે. આ એક ખોટી કલ્પના છે. કોડ એક કરાર છે. જો Claude Haiku પાસેથી ચોકકસતા માંગવી હોય, તો તમારે કરાર લખવો પડશે. “વેબ એપ બાંધો” એ કરાર નથી. “Python 3.12 માં FastAPI એન્ડપોઈન્ટ જનરેટ કરો જે JSON સ્વીકારે, Pydantic v2 સાથે સ્કીમા વેલિડેટ કરે અને 422 સ્કીમા ભૂલો ઉપર સ્પષ્ટ પેલોડ ફોર્મેટ સાથે રિટર્ન કરે” એ કરાર છે. આ જ Claude Haiku 4.5 માટે ચોક્કસ કોડ જનરેશન માટે યોગ્ય પ્રોમ્પ્ટ છે.
આ શું છે (અને શું નથી)
- Claude Haiku 4.5 પાસેથી વિશ્વસનીય અને ટેસ્ટલાયક કોડ મેળવવા માટેનું હાઉ-ટુ માર્ગદર્શન છે.
- આ ‘AI ડેવલપર્સની જગ્યાએ આવશે’ પર ચર્ચા નથી. સાધનો વિચારવાની જગ્યા નથી લેતા.
- પ્રેક્ટિકલ પ્રોમ્પ્ટસ, માળખા અને ગાર્ડરેઇલ્સ પર ધ્યાન આપવા માટે છે: સુસ્ત ભાગો જે જાદુ કરે છે.
જો તમને આવું કોડ જોઈએ જે ચલાય, તો Claude ને “ચાલવું” નું કાર્યાત્મક નિર્દેશન આપવું પડશે. જો ચોક્કસ કોડ જનરેશન જોઈએ, તો ચોક્કસતા સાદા અને ટેસ્ટલાયક શરતોમાં નિર્દિષ્ટ કરવી પડશે. આ સમી ત્રીકી છે.
ચોક્કસતા ને કવિની જેમ ન કરીને વકીલની જેમ વ્યાખ્યાયિત કરો
“ચોક્કસ” કોડ એ “પ્રામાણિક લાગે” એવો કોડ નથી. ચોક્કસતા આ છે:
- સિન્ટૅક્સિક માન્યતા: તે કમ્પાઈલ થાય અથવા ઈન્ટરપ્રેટર હેઠળ ચાલે.
- સેમાન્ટિક વફાદારી: તે સ્પેસિફિકેશન મુજબ કાર્ય કરે.
- ડિટર્મિનિસ્ટિક વર્તન: સમાન ઇનપુટ માટે સમાન આઉટપુટ, નિર્ધારિત ભૂલ સીમાઓ હેઠળ.
- વાર્શન યોગ્યતા: યોગ્ય SDK, API સંસ્કરણો અને ભાષા ફીચર્સ વાપરે.
Claude તમને જે પૂછો એ આપે. જો “લિસ્ટ સૉર્ટ કરવાની ફંક્શન” પૂછો તો તે કદાચ આપે. પણ “ટિમસોર્ટ સેમેન્ટિક્સના અજમાયા O(1) સ્ટેબલ, ઇન-પ્લેસ સૉર્ટ” એ આખું અલગ કરાર છે. ‘Claude Haiku 4.5 માટે ચોક્કસ કોડ જનરેશન કેવી રીતે પ્રોમ્પ્ટ કરવું’ એPromisesને પ્રોમ્પ્ટમાં લખવાથી શરૂ થાય છે.
મિનિમમ વિયેબલ પ્રોમ્પ્ટ, અપગ્રેડ થયેલ
ખરાબ: “ટાસ્કસ માટે Node API લખો.”
સારી: “Node 20 Express 4 API લખો જેમાં /tasks POST રાઉટ હોય જે {title: string, dueDate: ISO 8601} ફીલ્ડ્સને વેલિડેટ કરે અને 201 સ્ટેટસ સાથે ઓબ્જેક્ટ અથવા 400 ભૂલ વિગત સાથે જવાબ આપે.”
સહી: “Node 20 Express 4 સર્વર સાથે એક /tasks POST એન્ડપોઈન્ટ જનરેટ કરો. આવશ્યકતાઓ: 1) [email protected] વડે બોડી વેલિડેટ કરવી; 2) ફીલ્ડ્સ: title (ખાલી ન હોય ત્યાં સુધી સ્ટ્રિંગ, મહત્તમ 140 અક્ષર), dueDate (ISO 8601 ભાવિ તારીખ); 3) સફળતામાં 201 સાથે {id: ULID, title, dueDate} રિટર્ન કરો; 4) અમાન્યમાં 400 સાથે {error: 'VALIDATION', details: એરે} રિટર્ન કરો; 5) ડેટાબેસ નહિ, મેમરીમાં Map ઉપયોગ કરો; 6) Jest 29 ટેસ્ટ ફાઈલ સામેલ કરવી જે માન્ય, અમાન્ય (ખાલી ટાઇટલ, ભૂતકાળી તારીખ) કેઝ આવરી લે; 7) npm સ્ક્રિપ્ટસ માટે ટેસ્ટ અને ડેવ; 8) ESM વાપરો; 9) અનાવશ્યક ટિપ્પણીઓ નહીં.” આ ફોર્મેટ નોંધો: ભાષા સંસ્કરણ, લાયબ્રેરીઝ, મર્યાદાઓ, આઉટપુટ્સ, ભૂલો, પરીક્ષણો, અને પેકેજ સ્ટრუქტure. તમે તમામ અજંજળ દૂર કરી છે. Claude નું કાર્ય છે કોડ લખવું, આવશ્યકતાઓ નહિ.
સ્કાફોલ્ડિંગ પેટર્ન: સિસ્ટમ, સ્પેસ, ટેસ્ટ, પછી કોડ
Claude Haiku 4.5 પાસેથી ચોક્કસ કોડ મેળવવા માટે તેને એક રનવે આપો:
- સિસ્ટમ ફ્લેમિંગ (ટૂંકું લેશ)
- તમે: “તમે Node 20 માટે પ્રોડક્શન-ગુણવત્તાવાળો TypeScript લખી રહ્યાં છો. માત્ર ફાઈલનેમ સાથે કોડ બ્લોક્સ જ આપો.”
- કારણ: તમે ટોન અને આઉટપુટ ફોર્મેટ નિયંત્રિત કરો છો. એ બાબતે તક ના છોડો.
- ભાષા સંસ્કરણો, પેકેજ પસંદગીઓ, ભૂલ અર્થશાસ્ત્ર, I/O ફોર્મેટ, પ્રદર્શન સીમા અને સુરક્ષા મર્યાદાઓ શામેલ કરો.
- Claude ને પહેલા યુનિટ ટેસ્ટ લખવા કહો. ટેસ્ટ ‘ચોક્કસતા’ વધુ સારૂં વર્ણવે છે. જો કોડનું કોઈ રેખા ટેસ્ટમાં કામ ન કરે તો તે ફક્ત શણગાર છે.
- ફક્ત પરીક્ષણો પછી. હા, આ TDD ની જેમ છે, પણ રોબોટ સાથે જે ક્યારેય બોર ન થાય.
- “જો ટેસ્ટ ફેઇલ થાય અથવા આયાતમાં ગેરમાર્ગદર્શિત હોય, તો ફક્ત ખોટા ભાગ જ સુધારો. આખો પ્રોજેક્ટ ફરી લખશો નહી.”
Claude તે દરમિયાનcontext અને માર્ગદર્શિકા મળે ત્યારે સારા પરિણામ આપે. તેનાથી માર્ગદર્શન આપો.
સંસ્કરણ પિનિંગ વિકલ્પ નથી
Claude નું ટ્રેનિંગ ડેટા જુના અને નવા દસ્તાવેજોથી ભરેલું છે. તેનો મતલબ તે ઘણા વિવાદાસ્પદ સલાહો જોઈ ચૂકી છે. “React Router વાપરો” ધારણારહિત છે. “[email protected] સાથે ડેટા રાઉટર્સ વાપરો” ઉદ્દેશ છે. ડિફૉલ્ટ્સ પર ભરોસો ના રાખો: - ભાષાઓ: Python 3.12, Node 20, Go 1.22, Java 21 વગેરે પિન કરો.
- ફ્રેમવર્ક: ચોક્કસ મુખ્ય સંસ્કરણો અને કોઈ બ્રેકિંગ ફ્લેગ્સ સ્પષ્ટ કરો.
- ક્લાઉડ SDKs: સંસ્કરણો પિન કરો; aws-sdk v2 વિ. v3 મહત્વનું છે.
- લિન્ટર્સ/ફોર્મેટર્સ: નિયમો નિર્ધારિત કરો કે જેથી શૈલીનું ڪنફ્યૂઝન ન થાય.
જો તમે પિન ન કરો તો તમને 5 વર્ષ જૂના બ્લોગ પોસ્ટ્સના ચલિત સંગ્રહ મળશે. ચોક્કસ કોડ જનરેશન જૂની યાદોને ગુંચવું નથી જંતુ.
સકીમા પ્રથમ, હંમેશા
કદાચ “ઉપયોગકર્તા પ્રોફાઇલ” માળખું ન પૂછો. પ્રોમ્પ્ટમાં સ્કીમા નિર્ધારિત કરો અને વેલિડેશન અનિવાર્ય બનાવો:
- JS/TS માં JSON સકીમા અથવા Zod/Yup પ્રકારો
- Python માં Pydantic મોડલો
- સেৱાઓ માટે Protobuf અથવા Avro
Claude એન્ડપોઈન્ટ્સ (API ઈનપુટ), ડેટાબેઝ લખાણો, અને મેસેજ ક્યુઝ પર સ્કીમા અમલમાં લાવવાની ખાતરી કરવે. સ્પષ્ટ ભૂલ પેલોડ અને કોડ માંગો. ચોક્કસતા સ્કીમાને પ્રેમ કરે છે, ભ્રમને નહિ.
તેને જોવાય તેવું બનાવો, નહી તો તે રિયલ નથી માનો
Claude ને લોકિંગ, મેટ્રિક્સ, અને ટ્રેસ ઉમેરવા કહો જ્યાં જરૂર હોય, અને જ્યાં ન હોય ત્યાં શાંતિ રાખવા કહો. સારો પ્રોમ્પ્ટમાં શા સમાવેશ થાય:
- લોગિંગ નીતિ: સ્તર, PII લુકાવવું, રચના (જેમ કે JSON લોગ્સ)
- મેટ્રિક્સ: દરેક વિનંતિનો સમય, ભૂલ ગણતરીઓ
- હેલ્થ એન્ડપોઈન્ટ્સ: /healthz જ્યાં નિર્ભરતાઓ સક્રિય હોવાંનું પુરાવા મળે
Claude તમારી માંગ મુજબ જ ઉમેરશે. માંગ ન કરી તો તમને માત્ર પ્રિન્ટ સ્ટેટમેન્ટ મળશે—જોઈએ તો.
ટેસ્ટ-પ્રથમ પ્રોમ્પ્ટ્સ 'મહત્વનું માન' કરતા વધારે સારાં
Claude Haiku 4.5 માટે ચોક્કસ કોડ જનરેટ કરવા ટેસ્ટને સચ્ચાઈ માપદંડ બનાવવો એક સારી રીત છે. ઉદાહરણ:
“ફંક્શન normalize_email(s) માટે pytest ટેસ્ટ લખો જે:
- લોકલ અને ડોમેન ભાગોને નાનું કરે;
- gmail.com માટે માત્ર લોકલ પાર્ટમાંથી ડોટ્સ હટાવે;
- gmail.com માટે જ સબએડ્રેસ (+ટેગ) હટાવે;
- એક પણ @ વગર અથવા જગ્યા સાથે ઈનપુટ નમડે;
- યુનિકોડ ડોમેન પ્યુનિકોડ 그대로 રાખે.
એજ કેઝ આવરી લેજો. ટેસ્ટ લખ્યા પછી તે ફંક્શન અમલમાં લાવો.”
જ્યારે Claude ટેસ્ટોથી સંતૃપ્ત થવા માટે મજબૂર થાય છે ત્યારે તે વધારે યોગ્ય કોડ લખે છે. ન થાય તો તમારી પાસે સ્પષ્ટ નિષ્ફળતા છે, લાગણીઓનો મતભેદ નહિ.
ડિઝાઇન મુજબ હલ્યુસિનેશન્સની આડકતરી
હલ્યુસિનેશન્સ સંપૂર્ણ દૂર ન કરી શકો, પણ તેમને મર્યાદિત કરી શકો:
- જ્યારે સ્ત્રોતો હાજર હોય ત્યારે જ અકલ્પિતના સ્રોત-લિંક કે URL માંગો. SDK પદ્ધતિઓ માટે દસ્તાવેજ લિંક માંગો અને કોડ તે દસ્તાવેજ મુજબ હોવો આવશ્યક છે.
- પ્રાઇવેટ API માટે સ્પેસ પ્રોમ્પ્ટમાં નકલ કરો. Claude પર તમારા આંતરિક એન્ડપોઇન્ટ અંગે ભરોસો ન કરો.
- જ્યાં API જટિલ હોય ત્યાં અધિકૃત દસ્તાવેજમાંથી ઉદાહરણ નકલ કરો અને Claude ને અનુસરવા કહો.
ચોક્કસ કોડ મોટા ભાગે ચોક્કસ સંદર્ભો હોય છે. Claude ને આ સંદર્ભો આપો.
શૈલી માર્ગદર્શિકા: સૌથી ઓછું રોમાંચક, સૌથી ઉપયોગી વસ્તુ
Claude કોડ તે શૈલીમાં લખે છે જે તે સમજે. આ ફેરફાર માટે કારણ બની શકે. તમારી શૈલી માર્ગદર્શિકા નકલ કરો. આપો:
- ફોર્મેટિંગ (Prettier, Black, gofmt ડિફોલ્ટ)
અત્યાર સુધી અધૂરા નિર્ણયો માટે ટૂંકી ટિપ્પણી પણ માંગો. ભવિષ્યનો તમારું આભાર માનીશે અને વર્તમાન Claude ઓછા સુધારણા PR મોકલશે.
લંબા પ્રોમ્પ્ટ્સ, નાનું આઉટપુટ
Claude Haiku 4.5 માટે ચોક્કસ કોડ જનરેશન કેવી રીતે પ્રોમ્પ્ટ કરવો તે આવું વિચારવાની બીજી રીત: તમારા શબ્દો પસંદ કરીને પ્રોમ્પ્ટ માટે ખર્ચ કરો, આઉટપુટ માટે નહિ. તમે જોઈએ છો:
- પ્રોમ્પ્ટમાં સંપૂર્ણ મર્યાદાઓ
- આઉટપુટમાં ઓછું અનાવશ્યક વર્ણન
તેને સમજાવો કે સમજો આપવાનું બંધ રાખી ને ફક્ત ફાઈલનેમ સાથે કોડ બ્લોક્સ જ આપે અને ટૂંકું README આપે. જો ટિપ્પણી જોઈએ તો અલગ રન માંગો. પ્રોઝ અને કોડને मिलाimplement કરવાથી બગ્સ અનુભવાય છે.
સુધારણા: ટકાઉ લૂપ જે ખરેખર કામ કરે
ભરોસાપાત્ર કોડ માટે ઝડપી રસ્તો ‘પહેલીવારમાં સાચું કરવું’ નથી. તે ટૂંકા, સુધારણા લૂપ છે:
- સ્થાનિક રીતે ચલાવો. Claude માં ખોટા ટેસ્ટ આઉટપુટ અને કંપાઈલર ભૂલો એડ કરો.
- સૂચના: “ફક્ત જરૂરી રેખાઓ બદલો; ફંક્શન સહીચરજો નહીં જયાં સુધી જરૂરી ન હોય.”
- લીલો હાલત સુધી પુનરાવર્તન કરો.
Claude ખોટા ભાગ જાણવા પર સરસ ડિફ અનુરૂપ આપે છે. નિષ્ફળતા લોગ્સ પેસ્ટ કરો. તજ્ઞા ચીડથી દૂર રહો.
સુરક્ષા ફીચર છે, પોસ્ટસ્ક્રિપ્ટ નથી
મોડલ્સ જાહેર કોડથી ટ્રેન થયેલ હોવાથી (સારું, ખરાબ અને ગંદુ), સુરક્ષાને પ્રથમ દરજ્જાની આવશ્યકતા બનાવવી:
- eval, shell=True, અને સ્ટ્રિંગલી-ટાઇપ્ડ SQL સ્પષ્ટ મનાઈ કરો
- પેરામેટરાઇઝ્ડ ક્વેરીઝ, CSRF પ્રોટેક્શન અને રેટ લિમિટિંગ જરૂરિયાત બનાવો
- ડિપેન્ડન્સી પિનિંગ અને લૉકફાઇલ માંગો
- સિક્રેટસ માટે એન્વાયર્નમેન્ટ વેરિયેબલ્સ અથવા સિક્રેટ મેનેજર ઉપયોગની માંગણી કરો
પહેલા થી સુરક્ષિત પ્રોમ્પ્ટ સલામત કોડ આપે. ‘પછી પેચ કરીશું’ પ્રકારનો પ્રોમ્પ્ટ ગંભીર સમસ્યાઓ લાવે.
કાર્યક્ષમતા: 'વેગન' શું છે તે કહો
“તે ઝડપથી કરો” નો અર્થ “કેવી રીતે પણ” નહી. તેનો અર્થ ચોક્કસ માત્રકો આપી શકાય:
- લેટન્સી લક્ષ્યો (p95 < 50 મિલીસેકન્ડ મેમોરીમાં, p95 < 300DB ઓપરેશનો માટે)
- મેમરી સંમતિઓ (RSS < 150MB)
- ટાઇમ જટિલતા (O(n log n) હોવી જોઈએ, O(n^2) નહી)
Claude તમારા માટે બજેટ પ્રમાણે અલ્ગોરિથમ પસંદ કરશે. તેને બજેટ આપો.
દસ્તાવેજીકરણ: અજાણ લોકોને onboard કરવા માટે પૂરતું
Claudeને README માં સામેલ કરવા કહો:
- સેટઅપ સૂચનાઓ સાથે ચોક્કસ સંસ્કરણો
- ટેસ્ટ, લિન્ટ, ટાઈપચેક, રન માટે કમાન્ડ્સ
- મર્યાદાઓ અને જાણીતાં ટ્રેડ-ઓફ્સ
‘ચોક્કસ કોડ’ એ ચોક્કસ દસ્તાવેજ પણ હોવો જોઈએ. તે વિતરણમાંનો ભાગ છે.
ફિક્સ કરી શકો તેવા પ્રોમ્પ્ટ ટેમ્પ્લેટ્સ
ટેમ્પ્લેટ: બેકએન્ડ એન્ડપોઈન્ટ
સિસ્ટમ: તમે નિખારેલી Python 3.12 એન્જિનિયર છો. ફક્ત ફાઈલનેમ અને કોડ બ્લોક્સ જ આપો.
યુઝર:
- POST /convert એન્ડપોઈન્ટવાળી FastAPI 0.111 એપ બનાવો.
- વિનંતી: {amount: Decimal તરીકે string, from: 'USD'|'EUR', to: તે જ}.
- પાઇડેન્ટિક v2 વડે વેલિડેટ કરો; સ્કીમા ભૂલો પર 422 આકારમાં જવાબ આપो.
- પ્યૂર ફંક્શન convert(amount, from, to) વાપરો નક્કી દર {USD:1, EUR:1.1} સાથે.
- સફળતા પર {amount: string, currency: string} સાથે 200 રિટર્ન કરો.
- pytest ટેસ્ટ શામેલ કરો જેમાં માન્ય, અમાન્ય (ખોટો ડેસિમલ, અજાણ્યું કોડ), અને કિનારાના કેઝ આવરી લે.
- pyproject.toml સાથે ડિપેન્ડન્સી પિન કરો; ruff અને mypy કૉન્ફિગ સામેલ કરો.
- કોઈ નેટવર્ક કોલ ન કરો, ટિપ્પણી ન કરો.
ટેમ્પ્લેટ: CLI યુટિલિટી
સિસ્ટમ: તમે Go 1.22 લખી રહ્યાં છો. ફક્ત ફાઈલનેમ અને કોડ બ્લોક્સ જ આપો.
યુઝર:
- stdin વાંચતું અને URL-સેફ સ્લગ્સ પ્રિન્ટ કરતું slugify નામનું CLI બનાવો.
- નિયમો: નાનું લખવું, ASCII માત્ર, હાયફન વિભાજકો, વ્હાઈટસ્પેસ ખેડવું, પંક્ચ્યુએશન કાપવું.
- મેઇન.go અને slugify_test.go ટેબલ ટેસ્ટ સાથે આપો.
- ફકત Go સ્ટાન્ડર્ડ લાઇબ્રેરી વાપરો.
- Makefile સમાવેશ કરો જેમાં ટેસ્ટ અને બિલ્ડ ટાર્ગેટ્સ હોય.
ટેમ્પ્લેટ: ફ્રન્ટએન્ડ કંપોનન્ટ
સિસ્ટમ: તમે પ્રગમેટિક React એન્જિનિયર છો જે React 18 + TypeScript માટે લખો છો.
યુઝર:
- <DebouncedInput> કંપોનન્ટ અમલમાં લાવો.
- પ્રોપ્સ: value: string, onChange(value): void, delay=300.
- useRef/useEffect વાપરો; ત્રિજ્યાંપત્ર હૂક્સ નહિ.
- vitest સાથે નકલી ટાઈમરોવાળા ટેસ્ટ શામેલ કરો.
- નուքસાન Storybook સ્ટોરી આપો.
આ 템્પ્લેટ્સ Claude Haiku 4.5 ને ચોક્કસ કોડ જનરેશન માટે પ્રોમ્પ્ટ કરવાનાં ઉદાહરણ છે જે સંસ્કરણ પિનિંગ, વર્તન નિર્ધારણ અને ટેસ્ટ માંગે છે.
શરારત ન કરી શકે તેવું રોકવું: 'ઓપ્ટિમાઇઝ ન કરો' ક્યારે કહેવું
જો તમારે પૂર્વાગ્રહ રહિત માઇક્રો-ઓપ્ટિમાઇઝેશન્સ જોતા ન હોય, તો એ કહો:
- “સુઝજળાપણાને clevernessથી વધારે મહત્વ આપો; ટેસ્ટ માંગીએ ત્યાં સુધી બિનજરૂરી bit-twiddling નહિ.”
- “જો itrative રીતે સમજવા સરળ હોય તો recursion નહિ.”
- “મેટાપ્રોગ્રામિંગ નહિ; સ્પષ્ટ > આબ્રુદ્ધ.”
Claude મંત્રમુગ્ધ કરવા માટે પ્રેમ કરે. તેને ના દો. ટેસ્ટ પાસ કરો અને વાંચવામાં સરળ બનાવો. એ જ પૂરતું પ્રભાવશાળી છે.
Sider.AI વર્કફ્લો માં, જ્યાં તે ખરેખર મદદ કરે છે હું ઘણા લોકોને જુદાજુદા ચેટ ટેબ્સમાં પ્રોમ્પ્ટ ફરકાવતા જોઈ રહ્યો છું, જેમ કે એ ઉત્પાદનપ્રણાળી છે. એવા વર્કસ્પેસ વાપરો જેને કોડનો સંદર્ભ સમજાય. Sider.AI ઉદાહરણ રૂપ છે, જે તમારા સ્પેસ, કોડ, ડિફ્સ અને ટેસ્ટ લોગો એક સાથે જ રાખે છે, જેથી ‘એરર પેસ્ટ કરો, લાઇન સુધારો’ લૂપ તંગ બને. એ જાદૂ નથી; એ થાકેણું સ્કાફોલ્ડિંગ છે જે તમને દિશા ભૂલવા નથી દેતું. જો તમારું ટૂલ કરાર, ટેસ્ટ અને કોડ એ જ સંવાદમાં રાખે — પણ કાંફેટી જેવી બકવાસ ન કરે — તો તેને વાપરો. Sider તે કરે છે. Claude ને ઓરેકલ ન માની સાથીદાર સમજીને ડિબગ કેવી રીતે કરવું
- ખોટા ટેસ્ટ આઉટપુટને જેવો છે તે પેસ્ટ કરો. સારાંશ ન બનાવો.
- ડિફ માંગો: “ફાઈલ X સામે યુનિફાઇડ ડિફ રૂપમાં જવાબ આપો”
- રનટાઈમ બગ માટે, સૌથી નાનો પુનરુત્પાદન નામનો નમૂનો ઉમેરો અને સમજાવો સાથે પેચ માંગો.
- લાયબ્રેરી ભૂલ માટે, જે દસ્તાવેજ સૌથી યોગ્ય લાગે તેpaste કરો અને પૂછો: “કાર્ય માટે આ API સાચો છે કે નહીં? જો નહિ તો કોડ સુધારો અને યોગ્ય દસ્તાવેજ દર્શાવો.”
ેશા હેતુ Claude ને પુરાવા સાથે દલીલ કરવા માટે મજબૂર કરવી. પુરાવો તમે લાવશો.
જોઈએ પડકારોની યાદી (અને ટાળવાની રીત)
- “સর্বપ્રથમ” API ફંદો: ‘લેટેસ્ટ વાપરો’ ના કહો. ‘વર્ષન X.Y વાપરો’ કહો.
- ખાલી ટેસ્ટ ફાઇલ: તમે ટેસ્ટ ન માગો તો નહીં મળે.
- એકવારમાં બધું કરવા પ્રયત્ન કરવો ખોટું: બે-ત્રણ ટૂંકા સુધારણાં ઝડપથી ચાલે.
- અસ્પષ્ટ ભૂલ નીતિ: સ્ટેટસ કોડ અને પેલોડ નિર્ધારિત કરો. ‘ભૂલ લાવો’ એ કઈ સમજાય નહી.
- અપ્રાપ્ત ડિપેન્ડન્સી: જો કોડ કોઈ સેવા પર આધાર રાખે જેને તમે નિયંત્રિત ન કરી શકો તો તેને નકલી બનાવો (fakes માંગો).
તમારું પ્રોમ્પ્ટ ચેકલિસ્ટ (મોનીટર પાસે લटकાવો)
- ભાષા અને રનટાઈમ સંસ્કરણ પિન કર્યું હોવું
- લાઇબ્રેરી સંસ્કરણો પિન કરેલી હોવી જોઈએ
- ડેટા સ્કીમા નિર્ધારિત હોવી જોઈએ
- ભૂલ અર્થશાસ્ત્ર (કોડ, આકાર) નિર્ધારિત હોય
- સુરક્ષા મર્યાદાઓ સ્પષ્ટ હોવાં જોઈએ
- કાર્યક્ષમતા બજેટ જણાવેલ હોવા જોઈએ
- શૈલી અને માળખું નિર્ધારિત કરેલો હોઈ
- આઉટપુટ ફોર્મેટ મર્યાદિત (ફાઈલો નામ, કોડ બ્લોક્સ, ડિફ્સ)
- લઘુતમ સુધારણા લૂપ સાથે પેસ્ટ કરેલા લોગસ
જો તમે આ દસમાંથી બધાને અનુસરો તો Claude Haiku 4.5 સામાન્ય રીતે daylight હરાવતી ચોક્કસ કોડ જનરેશન આપે છે.
કાર્યાન્વિત ઉદાહરણ: અનિશચિત થી ચકાસાયેલ સુધી
અસ્પષ્ટ પ્રોમ્પ્ટ: “જાગૃત CSV સાચવવાની ફંક્શન લખો.”
પરિણામ: કદાચ યોગ્ય, શક્ય ત્રુટિ ભરેલું, નિર્દોષ નહીં.
વિશિષ્ટ પ્રોમ્પ્ટ:
“તમે Python 3.12 લખી રહ્યાં છો. ફક્ત ફાઈલનેમ સાથે કોડ બ્લોક્સ આપો.
csvsafe/init.py અને csvsafe/reader.py બનાવો જેમાં read_rows(path: Path) -> list[dict[str,str]] ફંક્શન હોય. આવશ્યકતાઓ: csv.DictReaderવાપરો newline='' અને encoding='utf-8' સાથે; નલ બાઈટ સબંધિત ફાઇલો ન અપનાવો; 10MB થી મોટાં ફાઇલો ન મૂકો; કૉલમ્સ મર્યાદિત 100; BOM કાપો; ખાલી સેલ્સને ખાલી સ્ટ્રિંગ માનો; ValueError ઉઠાવો જેમાં સંદેશા કોડ હોય {FILE_TOO_LARGE, NULL_BYTE, TOO_MANY_COLUMNS}. tests/test_reader.py માં pytest સાથે ટેસ્ટ શામેલ કરો જેમાં સારા માર્ગ, નલ બાઈટ, 11MB ફાઈલ, 101 કૉલમ, અને BOM હેન્ડલિંગ આવરી લેજો. pyproject.toml માં ડિપેન્ડન્સી પિન કરો અને બ્લેક કૉન્ફિગ આપો.”
તમે કોડ, ટેસ્ટ અને કિનારા હેન્ડલિંગ મેળવો. પછી તમે ટેસ્ટ ચલાવો, નિષ્ફળતાઓ પેસ્ટ કરો અને ન્યૂનતમ ડિફ્સ સાથે પુનરાવર્તન કરો. આ જ પ્રેક્ટિસમાં ચોક્કસ કોડ જનરેશન છે.
“રસપ્રદતા” અને અન્ય માર્કેટિંગ શબ્દો વિશે
મને ‘સર્જનાત્મક’ કોડ જોઈએ તેમ નથી. મને યોગ્ય કોડ જોઈએ. સર્જનાત્મકતા તમારા બિલાડીના નામ માટે રાખો. Claude ને પ્રોમ્પ્ટ કરતી વખતે, શ્રેષ્ઠ મર્યાદાઓ સાથે સર્જનાત્મકતા સ્વાભાવિક રીતે આવે છે. યોગ્ય ટેસ્ટ અને સ્પષ્ટ સ્પેસ ઉદ્યોગસાહસિક ઉકેલો આપે છે. ખોટા પ્રોમ્પ્ટથી ‘ઇમોજી સાથે રીન્વન કેટલા બેઝ64’ થાય. તેને લલચાવશો નહિ.
અગોપનીય રહસ્ય
Claude Haiku 4.5 માટે ચોક્કસ કોડ જનરેશન કેવી રીતે પ્રોમ્પ્ટ કરવું તે બોરિંગ છે: જરૂરિયાતો લખો, સંસ્કરણો પિન કરો, સ્કીમા નિર્ધારિત કરો, ટેસ્ટ માંગો અને વાસ્તવિક નિષ્ફળતાઓ સાથે પુનરાવર્તન કરો. એટલુંજ. કોઈ રહસ્યવાદ નથી. ગણીતીશાસ્ત્રની શિસ્ત, તે મોડલ સાથે જે ઝડપથી ટાઇપ કરે છે અને શરુઆતના લગભગ એકસરખા 15 ટેસ્ટ કેસો લખવામાં બોર ન થાય.
અને આ છે વળાંક: ચોક્કસતા અપ્રતિમ છે. જે પ્રોમ્પ્ટ્સ કામ કરે તે TSA ચેકલિસ્ટ જેવો લાગે છે. જે કોડ શિપ થાય તે માનવ જેવું લખાયેલું લાગે જેને મારી છે. તમે બંને મેળવશો જ્યારે તમે મોડલને જુનિયર એન્જિનિયર તરીકે માનો જે સ્પષ્ટ જરૂરિયાતો હેઠળ ફળીયે છે અને અનિશ્ચિત દિશાઓ હેઠળ નર્વસ થાય છે. તેને કરાર આપો. તેને ટેસ્ટ પાસ કરાવો. પછી, કદાચ, તમે તેનું વિશ્વાસ કરી શકો — સાધન માટે જેવો વિશ્વાસ, ભવિષ્યવાણી કરવા માટે નહિ.
સમાપ્તિ: વિજાર્ડરી નહિ, વોરન્ટી વધુ
જો તમારે વિજાડ્રી જોઈતી હોય તો માયાજાળ પ્રદર્શન પર જાઓ. જો સોફ્ટવેર જોઇએ જે કમ્પાઇલ થાય અને યોગ્ય વર્તન કરે, તો વોરન્ટીઝ જેવો પ્રોમ્પ્ટ લખો. Claude Haiku 4.5 માટે ચોક્કસ કોડ જનરેશન કેવી રીતે પ્રોમ્પ્ટ કરવું એ ફૂલો ભરેલ વાક્યો કે રહસ્યમય કીવર્ડ્સ વિશે નથી. તે મર્યાદાઓ, ટેસ્ટો, સંસ્કરણો અને પ્રતિસાદ લૂપ્સ વિશે છે. આ ચાર વાતો કરો, તો તમને ચાલતું કોડ મળશે. આ ન કરો, તો તમને સુંદર રીતે ફોર્મેટ કરેલ કાવ્ય પ્રકારનું કોડ મળશે.
કોડને તમારી લાગણીઓની પરવા નથી. સદ્ભાગ્યે, પરીક્ષણોને પણ નહીં.
FAQ
પ્રશ્ન 1: ચોક્કસ કોડ જનરેશન માટે Claude Haiku 4.5 ને પ્રોમ્પ્ટ કરવાનો સૌથી સરળ રસ્તો કયો છે?
તેને એક કરારની જેમ ગણો: પિન વર્ઝન, સ્કીમા વ્યાખ્યાયિત કરો, ભૂલ ફોર્મેટ સ્પષ્ટ કરો અને પહેલાં ટેસ્ટની આવશ્યકતા રાખો. જેટલા સ્પષ્ટ નિયંત્રણો, એટલો વધુ ચોક્કસ કોડ.
પ્રશ્ન 2: જ્યારે Claude કોડ લખે છે ત્યારે આભાસીકરણ (hallucinations) કેવી રીતે ઘટાડવું?
અધિકૃત દસ્તાવેજો અથવા સ્પષ્ટીકરણો પેસ્ટ કરો અને તે ચોક્કસ API નું પાલન કરવાની માંગ કરો. ખાનગી એન્ડપોઇન્ટ્સ માટે, તમારું પોતાનું સ્પષ્ટીકરણ શામેલ કરો—તે અનુમાન લગાવે તેવી અપેક્ષા રાખશો નહીં.
પ્રશ્ન 3: શું મારે Claude ને ટેસ્ટ માટે પૂછવું જોઈએ કે જાતે લખવી જોઈએ?
પહેલાં Claude ને ટેસ્ટ જનરેટ કરવા માટે કહો, પછી તેમને સંતોષવા માટે કોડ અમલમાં મૂકો. વિશેષણો કરતાં ટેસ્ટ ચોકસાઈને વધુ સારી રીતે વ્યાખ્યાયિત કરે છે અને મોડેલને પ્રમાણિક રાખે છે.
પ્રશ્ન 4: પ્રોમ્પ્ટ્સમાં વર્ઝન પિનિંગ કેટલું વિશિષ્ટ હોવું જોઈએ?
ખૂબ જ વિશિષ્ટ: ભાષા રનટાઇમ, ફ્રેમવર્ક મુખ્ય/ગૌણ અને SDK વર્ઝન. “લેટેસ્ટ” વિરોધાભાસી પેટર્નને આમંત્રણ આપે છે; ચોકસાઈ સ્થિર લક્ષ્યો પર આધાર રાખે છે.
પ્રશ્ન 5: ચોક્કસ કોડ માટે પ્રોમ્પ્ટિંગમાં Sider.AI ક્યાં બંધબેસે છે?
સ્પષ્ટીકરણો, કોડ, ડિફ્સ અને ટેસ્ટ લોગને એક લૂપમાં રાખવા માટે Sider.AI નો ઉપયોગ કરો. તે કોઈ જાદુ કરતું નથી—તે ફક્ત સંદર્ભને સાચવે છે જેથી Claude ના ફિક્સ તમારી વાસ્તવિક નિષ્ફળતાઓને ટ્રેક કરે. 
