எனது கோடிங் ஏஜென்ட் உரையாடல்களை மட்டுமே நினைவில் வைத்திருந்தது, வேலையை அல்ல

ஒரு கோடிங் ஏஜென்ட் ஒரு உரையாடல் தொடரை (thread) உயிர்ப்புடன் வைத்திருக்க முடியும், ஆனால் அப்போதும் அது எதையோ மறந்திருப்பதாகத் தோன்றலாம்.

CliGate-ஐ உருவாக்கும்போது நான் இந்தச் சிக்கலைச் சந்தித்தேன். நான் செஷன் தொடர்ச்சியை (session continuity) சரி செய்தேன், ஆனால் மீண்டும் மீண்டும் செய்யப்படும் பணிகள் மெதுவாகவே இருந்தன.

ஏஜென்ட் உரையாடலை நினைவில் வைத்திருந்தது, ஆனால் வேலையை நினைவில் கொள்ளவில்லை.

செஷன் தொடர்ச்சி ஒரு சிக்கலைத் தீர்க்கிறது. இது பின்வரும் தொடர் கட்டளைகளை (follow-up commands) அனுமதிக்கிறது:

  • continue
  • do the same for this file
  • retry that
  • explain the error

இது வேலையின் ஓட்டத்திற்கு (flow) முக்கியமானது. ஆனால், சில நாட்களுக்குப் பிறகு ஒரு பணிப்பாய்வை (workflow) மீண்டும் செய்யும்போது இது தோல்வியடைகிறது.

எந்தப் பொத்தான் வேலை செய்கிறது அல்லது எந்தப் படிநிலை பயனற்றது என்பதை ஒரு ஏஜென்ட் கற்றுக்கொண்டால், ஒரு திறந்த செஷன் மட்டும் போதுமானதல்ல. முந்தைய முறை வெற்றிகரமாக முடிந்ததற்குக் காரணம் என்ன என்பதை ஏஜென்ட் நினைவுகூர வேண்டும்.

முதல் முறை இயங்குவதே அதிகச் செலவு மிக்கது. அப்போதுதான் ஏஜென்ட் சிறிய விவரங்களைக் கண்டறிகிறது:

  • ஒரு குறிப்பிட்ட மெனுவில் ஒரு செயல் மறைந்திருக்கிறது
  • ஒரு எடிட்டர் ஒரு iframe ஆக இருக்கிறது
  • ஒரு திட்டத்திற்கு குறிப்பிட்ட பதில் பாணிகள் தேவைப்படுகின்றன
  • ஒரு சூழலின் URL, தயாரிப்புச் சூழலில் (production) இருந்து மாறுபடுகிறது

எனது திருத்தத்திற்கு முன், இந்த விவரங்கள் வெறும் மூலப் பதிவுகளாக (raw logs) மட்டுமே இருந்தன. ஏஜென்ட்டிடம் வரலாறு இருந்தது, ஆனால் மீண்டும் பயன்படுத்தக்கூடிய நினைவாற்றல் (reusable memory) இல்லை. ஒவ்வொரு முறையும் அதே உண்மைகளை அது மீண்டும் கண்டறிய வேண்டியிருந்தது. அது புத்திசாலித்தனம் அல்ல. அது ஒரே செலவை இரண்டு முறை செலுத்துவதற்குச் சமம்.

அதிக வரலாற்றைச் சேமித்து, மாடல் அதைத் தானாகப் பயன்படுத்தும் என்று எதிர்பார்ப்பது தவறான அணுகுமுறை. இது தேவையற்ற குழப்பங்களை (noise) உருவாக்குகிறது.

எனக்கு ஒரு சிறிய, மீண்டும் பயன்படுத்தக்கூடிய அடுக்கு (layer) தேவைப்பட்டது. அனைத்தையும் சேமிப்பதிலிருந்து பின்வருவனவற்றைச் சேமிப்பதிற்கு மாறினேன்:

  • procedures: சிறந்த வழிமுறைகள் மற்றும் அறியப்பட்ட பயனற்றப் படிநிலைகள்
  • facts: URLs, விதிகள் அல்லது அமைப்புகள்
  • directives: விஷயங்கள் எப்படிச் செய்யப்பட வேண்டும் என்பது பற்றிய வழிகாட்டுதல்கள்
  • references: ஆவணங்கள் (documentation) எங்கு உள்ளன என்பது பற்றிய குறிப்புகள்

இது அமைப்பை மாற்றியது. ஒரு பெரிய உரையாடல் தொகுப்பை (transcript) வாசிப்பதற்குப் பதிலாக, உதவியாளர் கோப்பு அடிப்படையிலான நினைவாற்றல் அடுக்கைப் (file-based memory layer) பயன்படுத்துகிறது.

இடைமுகங்கள் (interfaces) மாறக்கூடும் மற்றும் பொத்தான்கள் இடம் மாறக்கூடும் என்பதால், எனக்கு ஒரு முழுமையான மறுபதிப்பு (perfect replay) தேவையில்லை. எனக்கு ஒரு சுழற்சி (loop) தேவைப்பட்டது:

  • முந்தைய சிறந்த நடைமுறையை நினைவுகூர்தல்
  • முதலில் அதை முயற்சித்தல்
  • ஒவ்வொரு படிநிலையையும் சரிபார்த்தல்
  • தோல்வியடைந்தால், மீண்டும் தேடலுக்குச் செல்லுதல்
  • வெற்றிக்குப் பிறகு நினைவாற்றலைப் புதுப்பித்தல்

நிலையான விதிகளை (standing rules) செஷன் வரலாற்றிலிருந்து நான் பிரித்தேன். "தயாரிப்புத் தரவைத் (production data) தொடாதீர்கள்" போன்ற விதிகள் உரையாடல் சூழல் (conversation context) அல்ல. அவை செயல்பாட்டு விதிகள் (operating rules). அவற்றைப்பிரிப்பது உதவியாளரைத் துல்லியமாகச் செயல்பட வைக்கும் (predictable).

முடிவு: மீண்டும் மீண்டும் செய்யப்படும் பணிகள் குறுகிய காலத்திற்குள் முடிவடைந்தன. உதவியாளர் ஒரு காலியான தந்திரோபாய மாதிரியுடன் (empty tactical model) தொடங்குவதில்லை என்பதால், அது வேகமாகச் செயல்படுகிறது.

நீங்கள் கோடிங் ஏஜென்ட்களை உருவாக்குகிறீர்கள் என்றால், ஒரு உரையாடல் தொடரையும் (thread) கற்றலையும் (learning) குழப்பிக்கொள்ளாதீர்கள்.

  • ஒரு செஷன் தொடர்ச்சிக்கு உதவுகிறது.
  • நினைவாற்றல் மீண்டும் மீண்டும் செய்யப்படும் வேலைகளுக்கு உதவுகிறது.

செஷன் உரையாடலை உயிர்ப்புடன் வைத்திருக்கிறது. நினைவாற்றல் அடுக்கு பாடங்களை உயிர்ப்புடன் வைத்திருக்கிறது.

உங்கள் அமைப்பு உரையாடல் தொடரை நினைவில் கொள்கிறதா, அல்லது வெற்றிகரமான நடைமுறையை நினைவில் கொள்கிறதா?

Source: https://dev.to/codekingai/my-coding-agent-remembered-sessions-not-work-that-was-the-bug-2fig