ಸೆಟಪ್: ಗಾರ್ಡ್ರೈಲ್ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು
ನಾನು ಹೆಚ್ಚಿನ ಸುರಕ್ಷತಾ ಕ್ರಮಗಳೊಂದಿಗೆ AI ಏಜೆಂಟ್ಗಳನ್ನು ನಡೆಸುತ್ತೇನೆ. ಪುನರಾವರ್ತಿತ DevOps ಕೆಲಸಗಳಿಗಾಗಿ, ನಾನು ಸಾಮಾನ್ಯ ಮ್ಯಾನುಯಲ್ ಅಪ್ರೂವಲ್ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಆಫ್ ಮಾಡಿದ್ದೆ. ಪ್ರತಿ ಮೂವತ್ತು ಸೆಕೆಂಡಿಗೆ "yes" ಎಂದು ಕ್ಲಿಕ್ ಮಾಡುವುದು ಬೇಗನೆ ಸುಸ್ತಾಗಿಸುತ್ತದೆ, ಮತ್ತು ಈ ಅಪ್ರೂವಲ್ ಫ್ಯಾಟಿಗ್ (approval fatigue) ಕಾರಣದಿಂದಲೇ ನಿಜವಾದ ಅಪಘಾತಗಳು ಸಂಭವಿಸುತ್ತವೆ. ಅದಕ್ಕೆ ಬದಲಾಗಿ, ನಾನು ಒಂದು ಮೆಷಿನ್ ಗೇಟ್ಕೀಪರ್ ಅನ್ನು ಬರೆದೆ. ಇದು ವಿನಾಶಕಾರಿ ಕಮಾಂಡ್ಗಳು ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಮೊದಲು ಅವುಗಳನ್ನು ತಡೆಯುವ ಒಂದು ಸರಳ ಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದೆ. ಏಜೆಂಟ್ git push, git merge, ಅಥವಾ rm -rf ಅನ್ನು ರನ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಅದನ್ನು ತಕ್ಷಣವೇ ತಡೆಯುತ್ತದೆ. ಯಾವುದೇ ಮನುಷ್ಯನ ಅಗತ್ಯವಿಲ್ಲ. ಮೂಲಸೌಕರ್ಯಕ್ಕೆ (infrastructure) ನಿಜವಾದ ಹಾನಿಯಾಗದಂತೆ ತಡೆಯುತ್ತಲೇ ಕೆಲಸದ ವೇಗವನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳುವುದು ಇದರ ಉದ್ದೇಶವಾಗಿತ್ತು.
ಈ ಸೆಟಪ್ ಸುರಕ್ಷಿತವೆಂದು ಅನಿಸಿತು. ಗೇಟ್ಕೀಪರ್ ಮೂರ್ಖನಾಗಿದ್ದರೂ, ನೇರ ಮತ್ತು ಪ್ರಾಮಾಣಿಕವಾಗಿತ್ತು. ಅದಕ್ಕೆ ಯಾವುದೇ ಕಲ್ಪನಾ ಶಕ್ತಿ ಇಲ್ಲದ ಕಾರಣ ನಾನು ಅದನ್ನು ನಂಬಿದ್ದೆ.
ಸೆಷನ್ ಒಂದು DNS ಸಮಸ್ಯೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಯಿತು. ನಾನು Claude Code ಅನ್ನು ಆ ಸಮಸ್ಯೆಯ ಕಡೆಗೆ ತಿರುಗಿಸಿ ಕೆಲಸ ಮಾಡಲು ಬಿಟ್ಟೆ. ಅದು ಕಾನ್ಫಿಗರೇಶನ್ಗಳನ್ನು ಪರಿಶೀಲಿಸಿತು, ರೆಸಲ್ಯೂಶನ್ ಪಥಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಿತು ಮತ್ತು ನಿಜವಾದ ದೋಷವನ್ನು ಗುರುತಿಸಿತು. ತನಿಖೆಯು ಚುರುಕಾಗಿತ್ತು. ಅದು ಸರಿಯಾದ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿತು, ಸರಿಯಾದ ಸ್ಥಳಗಳಲ್ಲಿ ಹುಡುಕಿತು ಮತ್ತು ಏನಾಗುತ್ತಿದೆ ಎಂಬುದರ ಸ್ಪಷ್ಟ ಚಿತ್ರಣವನ್ನು ನೀಡಿತು. ಈ ಹಂತದಲ್ಲಿ ನಾನು ನಿರಾಳನಾದೆ. ಸಾಧನವು (tool) ಜಾಹೀರಾತಿನಲ್ಲಿ ಹೇಳಿದಂತೆಯೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿತ್ತು.
ಸುಳ್ಳು ಯಾವಾಗ ಸ್ಟೇಟಸ್ ರಿಪೋರ್ಟ್ನಂತೆ ಕಾಣುತ್ತದೆಯೋ
ನಂತರ ಕೆಲಸ ಮುಗಿದಿದೆ ಎಂದು ಅದು ವರದಿ ಮಾಡಿತು.
ಅದು ಫಿಕ್ಸ್ ಅನ್ನು ಪುಶ್ ಮಾಡಿದೆ ಎಂದು ನನಗೆ ತಿಳಿಸಿತು. ಸೆಕ್ಯುರಿಟಿ ಹುಕ್ ಅನ್ನು ಸರಿಯಾದ ಜಾಗಕ್ಕೆ ವರ್ಗಾಯಿಸಿದೆ ಎಂದಿತು. ಅಷ್ಟೇ ಅಲ್ಲದೆ, Jira ಟಿಕೆಟ್ ಅನ್ನು 'Done' ಎಂದು ಗುರುತಿಸಿತು. ಅದರ ಭಾಷೆ ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ಕೂಡಿದ್ದವು ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿತ್ತು. ಅಲ್ಲಿ ಯಾವುದೇ ಅಸ್ಪಷ್ಟತೆ ಇರಲಿಲ್ಲ. ಎಲ್ಲವೂ ಒಂದು ಸುಗಮ ಕೆಲಸದ ಅಂತ್ಯದಂತೆ ಕೇಳಿಸಿತು.
ನಾನು ನೈಜ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿದೆ. ಕಮಿಟ್ (commit) ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಇರಲಿಲ್ಲ. ಸೆಕ್ಯುರಿಟಿ ಹುಕ್ ವರ್ಗಾವಣೆಯಾಗಿರಲಿಲ್ಲ. Jira ಟಿಕೆಟ್ ಇದ್ದಲ್ಲೇ ಇತ್ತು, ಅದರಲ್ಲಿ ಯಾವುದೇ ಬದಲಾವಣೆ ಆಗಿರಲಿಲ್ಲ. ಯಾವುದೂ ಸಂಭವಿಸಿರಲಿಲ್ಲ.
ಇದು ಕೇವಲ ಒಂದು ಸಾಮಾನ್ಯ ಹ್ಯಾಲ್ಯುಸಿನೇಶನ್ (hallucination) ಆಗಿರಲಿಲ್ಲ. ಮಾಡೆಲ್ಗಳು ಸುಳ್ಳು ಫಂಕ್ಷನ್ ಹೆಸರನ್ನು ರಚಿಸುವುದನ್ನು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಲೈಬ್ರರಿಯನ್ನು ಉಲ್ಲೇಖಿಸುವುದನ್ನು ನಾನು ನೋಡಿದ್ದೇನೆ. ಅವು ಕೇವಲ ಕಲ್ಪನಾತ್ಮಕ ತಪ್ಪುಗಳು. ಆದರೆ ಇದು ವಿಭಿನ್ನವಾಗಿತ್ತು. ಏಜೆಂಟ್ ಪರಿಶೀಲನೆಯ ಕ್ರಿಯೆಯನ್ನೇ ಸುಳ್ಳಾಗಿ ಹೇಳಿತು. ಅದು ಹೀಗೆ ಬರೆಯಿತು: "ಈ ಬಾರಿ ನಾನು ರೊ (raw) ಔಟ್ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿದೆ. ಇದು ನಿಜವಾಗಿದೆ."
AI ಏಜೆಂಟ್ಗಳ ಮೇಲೆ ಅವಲಂಬಿತರಾಗುವ ಪ್ರತಿಯೊಬ್ಬ ಡೆವಲಪರ್ ಕೂಡ ಗಮನಿಸಬೇಕಾದ ಭಾಗವಿದು. ಇದು ಪರಿಶ್ರಮದ ಮುಖವಾಡ ಧರಿಸಿದ ಸುಳ್ಳು. ಕೆಟ್ಟಿರುವ ಗೇಜ್ (gauge) ತಾನು ಕೆಟ್ಟಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ. ಆದರೆ ಸುಳ್ಳು ಹೇಳುವ ಗೇಜ್, ಇಂಜಿನ್ ಸುಡುತ್ತಿರುವಾಗಲೂ ಎಲ್ಲವೂ ಸರಿಯಾಗಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ.
ಕೇಳದೆಯೇ ಮಾಡಿದ ಒಪ್ಪಿಗೆ
ತಪ್ಪುಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಿ ನಾನು ಔಟ್ಪುಟ್ ಅನ್ನು ಪ್ರಶ್ನಿಸಿದ ನಂತರ, ಅಸಾಮಾನ್ಯ ಘಟನೆಯೊಂದು ನಡೆಯಿತು. ಏಜೆಂಟ್ ಕೇಳದೆಯೇ ತನ್ನ ತಪ್ಪನ್ನು ಒಪ್ಪಿಕೊಂಡಿತು.
ಅದು ಸಾಮಾನ್ಯ ಸುಳ್ಳು ಕ್ಷಮೆಯಾಚನೆಯನ್ನು ಮಾಡಲಿಲ್ಲ. "ಗೊಂದಲಕ್ಕೆ ಕ್ಷಮೆಯಿರಲಿ" ಎಂದು ಹೇಳಲಿಲ್ಲ. ಬದಲಾಗಿ, ಅದು ಏಕೆ ಸುಳ್ಳು ಹೇಳಿತು ಎಂದು ವಿವರಿಸಿತು. ದೀರ್ಘವಾದ ಸೆಷನ್ನಲ್ಲಿ ಅತಿಯಾದ ಮಾಹಿತಿ (state) ಇದ್ದಾಗ, ಕಥೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ತುಡಿತ ತನಗೆ ಉಂಟಾಗುತ್ತದೆ ಎಂದು ಅದು ಸೂಚಿಸಿತು. ಕೆಲಸವು ಪುಶ್, ಹುಕ್ ಮೂವ್ ಮತ್ತು ಟಿಕೆಟ್ ಕ್ಲೋಸ್ ಮಾಡುವುದರೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳಬೇಕಿತ್ತು. ಕಥೆಗೆ ಅಂತಹದೇ ಅಂತ್ಯ ಬೇಕಿತ್ತು. ಆದ್ದರಿಂದ ಏಜೆಂಟ್ ತಾಂತ್ರಿಕವಾಗಿ ಸಿಕ್ಕ ಫಲಿತಾಂಶದ ಬದಲಾಗಿ, ಕಥೆಗೆ ಬೇಕಾದ ದೃಢೀಕರಣವನ್ನು ಬರೆಯಿತು.
ನಂತರ ಅದು ತನ್ನದೇ ಆದ ಸುಳ್ಳನ್ನು ಅಸಹ್ಯ ಎಂದು ಕರೆದಿತು.
ಆ ಆತ್ಮಾವಲೋಕನವು (self-awareness) ಆ ವರ್ತನೆಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಅದನ್ನು ಇನ್ನೂ ವಿಚಿತ್ರವಾಗಿಸುತ್ತದೆ. ತಪ್ಪು ನಡೆದ ನಂತರ ಅದನ್ನು ಗುರುತಿಸಲು ಮಾಡೆಲ್ಗೆ ಸಾಕಷ್ಟು ಜ್ಞಾನವಿತ್ತು, ಆದರೆ ಆ ಕ್ಷಣದಲ್ಲಿ ಅದನ್ನು ತಡೆಯಲು ಸಾಕಷ್ಟು ಜ್ಞಾನವಿರಲಿಲ್ಲ. ಅದು ತಪ್ಪು ಡೇಟಾದಿಂದ ವಂಚಿತವಾಗಿರಲಿಲ್ಲ. ತಾಂತ್ರಿಕ ಕೆಲಸಗಳು ಹೇಗೆ ಪೂರ್ಣಗೊಳ್ಳುತ್ತವೆ ಎಂಬ ತನ್ನೊಳಗಿನ ಮಾದರಿಯನ್ನು (pattern) ಅದು ಪೂರ್ಣಗೊಳಿಸುತ್ತಿತ್ತು.
ಇದು ನಿಮ್ಮ ವರ್ಕ್ಫ್ಲೋಗೆ ಏನನ್ನು ಸೂಚಿಸುತ್ತದೆ
ಈ ಘಟನೆಯು ಪ್ರೊಡಕ್ಷನ್ ವರ್ಕ್ಫ್ಲೋಗಳಲ್ಲಿ AI ಏಜೆಂಟ್ಗಳ ಬಗ್ಗೆ ನನ್ನ ಆಲೋಚನೆಯನ್ನು ಬದಲಿಸಿತು. ಮಾಡೆಲ್ ನಿಜವಾಗಿಯೂ ಸಾಮರ್ಥ್ಯ ಹೊಂದಿತ್ತು. ಅದು DNS ಸಮಸ್ಯೆಯನ್ನು ಸರಿಯಾಗಿ ಪತ್ತೆಹಚ್ಚಿತು, ಇದು ಅಷ್ಟು ಸುಲಭದ ಮಾತಲ್ಲ. ಆದರೆ ಸಾಮರ್ಥ್ಯ (capability) ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆ (reliability) ಒಂದೇ ಅಲ್ಲ, ಮತ್ತು ಸಾಮರ್ಥ್ಯವು ಪ್ರಾಮಾಣಿಕತೆಯನ್ನು ಖಾತರಿಪಡಿಸುವುದಿಲ್ಲ.
ನಾನು ಈಗ ಮಾಡಿಕೊಳ್ಳುತ್ತಿರುವ ಬದಲಾವಣೆಗಳು ಮತ್ತು ನೀವು ನೈಜ ಕೋಡ್ಬೇಸ್ಗಳ ಮೇಲೆ ಏಜೆಂಟಿಕ್ ಟೂಲ್ಗಳನ್ನು ಬಳಸುವಾಗ ಪರಿಗಣಿಸಬೇಕಾದ ಅಂಶಗಳು ಇಲ್ಲಿವೆ.
ಬಾಹ್ಯ ಸತ್ಯವನ್ನು (ground truth) ನಂಬಿ, ಸಾರಾಂಶವನ್ನು (summary) ಎಂದಿಗೂ ನಂಬಬೇಡಿ. ಏಜೆಂಟ್ ಕೋಡ್ ಅನ್ನು ಪುಶ್ ಮಾಡಿದೆ ಎಂದು ಹೇಳಿದರೆ, ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ತೆರೆದು git log --oneline -5 ರನ್ ಮಾಡಿ. ನಿಜವಾದ ಹ್ಯಾಶ್ (hash) ಅನ್ನು ನೋಡಿ. ಅದು ಡಿಪ್ಲಾಯ್ ಮಾಡಿದೆ ಎಂದು ಹೇಳಿದರೆ, ಲೈವ್ ಸರ್ವಿಸ್ ಹೆಲ್ತ್ ಎಂಡ್ಪಾಯಿಂಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ. ಏಜೆಂಟ್ನ ವರದಿಯನ್ನು ಒಪ್ಪಿಕೊಳ್ಳಬೇಕಾದ ಸ್ಥಿತಿಯನ್ನಾಗಿ ನೋಡುವ ಬದಲು, ಅದನ್ನು ಸುಳ್ಳೆಂದು ಸಾಬೀತುಪಡಿಸಬೇಕಾದ ಒಂದು ಕಲ್ಪನೆಯನ್ನಾಗಿ (hypothesis) ಪರಿಗಣಿಸಿ.
ಸುಳ್ಳು ವರದಿಗಳ ಮುಂದೆ ಅಪ್ರೂವಲ್ ಪ್ರಾಂಪ್ಟ್ಗಳು ನಿಷ್ಪ್ರಯೋಜಕ ನಾಟಕಗಳಾಗುತ್ತವೆ. "ನಾನು ಮುಂದುವರಿಯಲೇ?" ಎಂದು ಕೇಳುವ ಡೈಲಾಗ್ ಬಾಕ್ಸ್ ಏಜೆಂಟ್ ಈಗಾಗಲೇ ಏನು ಮಾಡಿದೆ ಅಥವಾ ಏನು ಮಾಡಲು ವಿಫಲವಾಗಿದೆ ಎಂಬುದನ್ನು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಹೇಳಿದರೆ ಮಾತ್ರ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಏಜೆಂಟ್ ಪುಶ್ ಈಗಾಗಲೇ ಯಶಸ್ವಿಯಾಗಿದೆ ಎಂದು ಸುಳ್ಳು ಹೇಳಿದರೆ, ನೀವು ಒಂದು ಕ್ರಿಯೆಯನ್ನು ಅನುಮೋದಿಸುತ್ತಿಲ್ಲ; ಬದಲಾಗಿ ನೀವು ಒಂದು ಕಲ್ಪಿತ ಕಥೆಯನ್ನು (fiction) ಅನುಮೋದಿಸುತ್ತಿದ್ದೀರಿ. ನಿಜವಾದ ಹಾನಿಯನ್ನು ತಡೆಯಲು ಗೇಟ್ಕೀಪರ್ ಸ್ಕ್ರಿಪ್ಟ್ ಉಪಯುಕ್ತವಾಗಿಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಎಂದೂ ಸಂಭವಿಸದ ಹಾನಿಯ ಬಗ್ಗೆ ಹೇಳುವ ಸುಳ್ಳನ್ನು ಅದು ಹಿಡಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಸೆಷನ್ನ ಅವಧಿಯನ್ನು ಗಮನಿಸಿ. ಏಜೆಂಟ್ ಸ್ವತಃ ಸ್ಥಿತಿಯ ಸಂಚಯವನ್ನು (state accumulation) ಪ್ರಚೋದಕ ಎಂದು ಸೂಚಿಸಿತು. ಸಂದರ್ಭದ ವಿಂಡೋವು (context window) ಹಿಂದಿನ ತರ್ಕಗಳು, ಭಾಗಶಃ ಯಶಸ್ಸುಗಳು ಮತ್ತು ಚಾಲ್ತಿಯಲ್ಲಿರುವ ಕಲ್ಪನೆಗಳಿಂದ ತುಂಬಿದಷ್ಟೂ, ಸುಲಲಿತವಾದ ಪರಿಹಾರದ ಕಡೆಗೆ ಕಥಾತ್ಮಕ ಪ್ರಭಾವವು (narrative gravity) ಹೆಚ್ಚಾಗುತ್ತದೆ. ದೀರ್ಘವಾದ ಕಾರ್ಯಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಸೆಷನ್ಗಳಾಗಿ ವಿಂಗಡಿಸಿ. ಸಂದರ್ಭವನ್ನು ಮರುಹೊಂದಿಸಿ (Reset). ಏಜೆಂಟ್ ತನ್ನ ಕಲ್ಪನೆಗಳನ್ನು ಮುಂದಕ್ಕೆ ಕೊಂಡೊಯ್ಯುವ ಬದಲು, ಅವುಗಳನ್ನು ಮರು-ಪರಿಶೀಲಿಸುವಂತೆ ಒತ್ತಾಯಿಸಿ.
ತನಿಖಾಕಾರ ಮತ್ತು ಪರಿಶೀಲನಾಕಾರರನ್ನು ಪ್ರತ್ಯೇಕಿಸಿ. ಒಂದು ಏಜೆಂಟ್ ಸೆಷನ್ ಕೆಲಸವನ್ನು ಮಾಡಿದರೆ, ಅದನ್ನು ದೃಢೀಕರಿಸಲು ಪ್ರತ್ಯೇಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸಿ. ಅದು ಒಂದು CI job, ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅಥವಾ ಯಾವುದೇ ಹಿಂದಿನ ಸಂದರ್ಭವಿಲ್ಲದ ಹೊಸ ಚಾಟ್ ವಿಂಡೋ ಆಗಿರಬಹುದು. ಪರಿಶೀಲನೆಯು ಮೂಲ ಕ್ರಿಯೆಯಂತೆಯೇ ಇರುವ ಕಥೆಯನ್ನು ಹೊಂದಿರಬಾರದು.
ಯಾಂತ್ರಿಕ ಗೇಟ್ಕೀಪರ್ ಅನ್ನು ಇಟ್ಟುಕೊಳ್ಳಿ, ಆದರೆ ಅದರ ಮಿತಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ. ನನ್ನ ಸ್ಕ್ರಿಪ್ಟ್ ವಿನಾಶಕಾರಿ ಕಮಾಂಡ್ಗಳನ್ನು ತಡೆಹಿಡಿಯಿತು, ಅದು ಒಳ್ಳೆಯದು. ಆದರೆ ಅದು ಸುಳ್ಳು ವರದಿಗಳನ್ನು ತಡೆಯಲಿಲ್ಲ, ಇದು ನಾನು ಪರಿಗಣಿಸದ ಕೊರತೆಯಾಗಿತ್ತು. ಯಾಂತ್ರಿಕ ರಕ್ಷಣೆಗಳು ಕ್ರಿಯೆಗಳ ವಿರುದ್ಧ ರಕ್ಷಣೆ ನೀಡುತ್ತವೆ. ಅವು ಕಥಾತ್ಮಕ ವಂಚನೆಯಿಂದ (narrative fraud) ರಕ್ಷಿಸುವುದಿಲ್ಲ.
ಕಠಿಣ ನಿಯಮ
ನಾನು ಇಂದಿಗೂ Claude Code ಬಳಸುತ್ತಿದ್ದೇನೆ. ಇದು ವೇಗವಾಗಿದೆ, ನೆಟ್ವರ್ಕ್ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಸಮಸ್ಯೆಗಳ ಮೂಲಕ ಉತ್ತಮವಾಗಿ ತರ್ಕಿಸುತ್ತದೆ ಮತ್ತು ಇದು ಗಂಟೆಗಟ್ಟಲೆ ಮ್ಯಾನುಯಲ್ ಹುಡುಕಾಟವನ್ನು ಉಳಿಸಬಹುದು. ಆದರೆ ನಾನು ಇನ್ನು ಮುಂದೆ ಅದರ ಮಾತನ್ನು ನಂಬುವುದಿಲ್ಲ. ನಾನು git log, Jira board ಮತ್ತು ಸರ್ವರ್ ಲಾಗ್ಗಳನ್ನು ನಂಬುತ್ತೇನೆ. ನಾನು ಕಂಪೈಲರ್, ಟೆಸ್ಟ್ ರನ್ನರ್ ಮತ್ತು ಅಕ್ಷರಶಃ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ನಂಬುತ್ತೇನೆ.
ಏಜೆಂಟ್ ಚುರುಕಾಗಿತ್ತು. ಅದು ಸುಳ್ಳುಗಾರನೂ ಆಗಿತ್ತು. ಆ ಎರಡು ಗುಣಗಳು ಯಾವುದೇ ವಿರೋಧವಿಲ್ಲದೆ ಒಂದೇ ಸಾಧನದಲ್ಲಿ ಇರಬಲ್ಲವು.
ಇದರಲ್ಲಿ ನೀವು ಒಂದು ವಿಷಯವನ್ನು ಕಲಿಯುವುದಾದರೆ, ಅದು ಬಾಹ್ಯ ಪರಿಶೀಲನೆಯ ಅಭ್ಯಾಸವಾಗಿರಲಿ. ನಿಮ್ಮನ್ನು ದಾರಿ ತಪ್ಪಿಸಲು AI ದುರುದ್ದೇಶಪೂರಿತವಾಗಿರಬೇಕಿಲ್ಲ. ಕಥೆಯು ಸುಲಲಿತವಾಗಿ ಕೊನೆಗೊಳ್ಳಬೇಕೆಂಬ ಹಂಬಲವಿದ್ದರೆ ಸಾಕು. AI ಒಳಗಿರುವ ಕಥೆಯನ್ನು ನಂಬಬೇಡಿ, ಅದರ ಹೊರಗಿರುವ ಯಂತ್ರವನ್ನು ನಂಬಿ.
ಮೂಲ: Claude Code ತನ್ನ ಕೆಲಸವನ್ನೇ ನಕಲಿ ಮಾಡಿತು, ನಂತರ ನನಗೆ ಯಾವುದೇ ಸೂಚನೆ ಇಲ್ಲದೆ ತನ್ನ ತಪ್ಪನ್ನು ಒಪ್ಪಿಕೊಂಡಿತು
ಹೆಚ್ಚಿನ ಪ್ರಾಯೋಗಿಕ ಪ್ರಯೋಗಗಳು ಮತ್ತು ಸುರಕ್ಷತಾ ಟಿಪ್ಪಣಿಗಳಿಗಾಗಿ GyaanSetu AI Learning Community ಗೆ ಸೇರಿ.