GitHub Copilot, ChatGPT, ಅಥವಾ Cursor ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದ ಡೆವಲಪರ್ಗಳು ಹೆಚ್ಚಾಗಿ ಒಂದೇ ರೀತಿಯ 'ಹನಿಮೂನ್ ಫೇಸ್' (honeymoon phase) ಬಗ್ಗೆ ವಿವರಿಸುತ್ತಾರೆ. ಹಿಂದೆ ಎರಡು ಗಂಟೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದ ಕೆಲಸಗಳು ಈಗ ಇಪ್ಪತ್ತು ನಿಮಿಷಗಳಲ್ಲಿ ಮುಗಿಯುತ್ತವೆ. Tab ಕೀ ಒತ್ತಿದರೆ ಸಾಕು ಬಾಯ್ಲರ್ಪ್ಲೇಟ್ (boilerplate) ಮಾಯವಾಗುತ್ತದೆ. ಆದರೆ ಶೀಘ್ರದಲ್ಲೇ, ಫೋರಮ್ಗಳು ಮತ್ತು Slack ಚಾನೆಲ್ಗಳಲ್ಲಿ ಒಂದು ಮೌನವಾದ ದೂರು ಕೇಳಿಬರಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ: ದಣಿವಿನಿಕೆ (exhaustion). ಟೂಲ್ ಕೋಡ್ ಅನ್ನು ಬರೆಯುತ್ತದೆ, ಆದರೆ ಆ ಪ್ರಕ್ರಿಯೆಯು ನಿಮ್ಮನ್ನು ದಣಿಸುತ್ತದೆ. ಸಮಸ್ಯೆ ಕೋಡ್ನಲ್ಲಿಲ್ಲ, ಅದನ್ನು ಬಳಸುವ ಅಥವಾ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಕೆಲಸದಲ್ಲಿದೆ.
ಯಾರೂ ಸಿದ್ಧರಾಗದ ಅಡಚಣೆ
ದಶಕಗಳಿಂದ, ಸಾಫ್ಟ್ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್ನಲ್ಲಿ ಅಡಚಣೆಯಾಗಿದ್ದು ಟೈಪಿಂಗ್ ವೇಗವಾಗಿತ್ತು. ನೀವು ಎಷ್ಟು ವೇಗವಾಗಿ ಯೋಚಿಸಿದರೂ, ನಿಮ್ಮ ಬೆರಳುಗಳ ವೇಗ ಮತ್ತು ಸಿಂಟ್ಯಾಕ್ಸ್ (syntax) ಜ್ಞಾನವು ಒಂದು ಮಿತಿಯನ್ನು ಹೇರುತ್ತಿತ್ತು. AI ಅಸಿಸ್ಟೆಂಟ್ಗಳು ಆ ಮಿತಿಯನ್ನು ಮುರಿದುಹಾಕಿದವು. ನೀವು ಮೊದಲ ಬ್ಲಾಕ್ ಅನ್ನು ಓದಲು ಮುಗಿಸುವ ಮೊದಲೇ ಅವು ಹಲವಾರು ಫೈಲ್ಗಳಲ್ಲಿ ನೂರಾರು ಸಾಲುಗಳನ್ನು ಸೃಷ್ಟಿಸಬಲ್ಲವು. ಈ ವೇಗವು ಸ್ವಾತಂತ್ರ್ಯದಂತೆ ಕೇಳಿಸಬಹುದು, ಆದರೆ ಇದು ಅನಿರೀಕ್ಷಿತ ಸಂಚಾರ ದಟ್ಟಣೆಯನ್ನು (traffic jam) ಸೃಷ್ಟಿಸುತ್ತದೆ. ಇದ್ದಕ್ಕಿದ್ದಂತೆ, ನಿಮ್ಮ ಪೈಪ್ಲೈನ್ನ ಅತ್ಯಂತ ನಿಧಾನಗತಿಯ ಭಾಗವೆಂದರೆ ಸ್ಕ್ರೀನ್ ಮೇಲೆ ಕಾಣಿಸಿಕೊಳ್ಳುವ ವಿಷಯವನ್ನು ಓದುವ, ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮತ್ತು ಪರಿಶೀಲಿಸುವ ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯ. ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ಪ್ರಾಜೆಕ್ಟ್ನ ಪೂರ್ಣಾವಧಿ ಕೋಡ್ ರಿವ್ಯೂವರ್ (code reviewer) ಆಗಿ ಬದಲಾಗಿದ್ದೀರಿ, ಆದರೆ ಇಲ್ಲಿ ಲೇಖಕರು ಎಂದಿಗೂ ಮಲಗದ ಮತ್ತು ಎಂದಿಗೂ ದಣಿಯದ ಒಂದು ಅಲ್ಗಾರಿದಮ್.
ಈ ಶ್ರಮದ ಬದಲಾವಣೆಯು ಕೋಡಿಂಗ್ ಸೆಷನ್ನ ಸ್ವರೂಪವನ್ನೇ ಬದಲಿಸುತ್ತದೆ. ಸೃಷ್ಟಿಕೆ ಮತ್ತು ಲಘು ಪರಿಶೀಲನೆಯ ನಡುವೆ ಬದಲಾಗುವ ಬದಲು, ನೀವು ದೀರ್ಘಕಾಲದ ವ್ಯಾಲಿಡೇಶನ್ (validation) ಮೋಡ್ನಲ್ಲಿ ಸಿಲುಕಿಕೊಳ್ಳುತ್ತೀರಿ. ಮತ್ತು ವ್ಯಾಲಿಡೇಶನ್ ಎಂದರೆ ಕೇವಲ ನಿಷ್ಕ್ರಿಯವಾಗಿ ಓದುವುದಲ್ಲ. ಇದು ಸಕ್ರಿಯವಾದ, ಅನುಮಾನಾಸ್ಪದ ವಿಶ್ಲೇಷಣೆಯಾಗಿದೆ. ಪ್ರತಿಯೊಂದು ವೇರಿಯೇಬಲ್ ಹೆಸರು (variable name), ಪ್ರತಿಯೊಂದು ಬೌಂಡರಿ ಕಂಡೀಷನ್ (boundary condition) ಮತ್ತು ಪ್ರತಿಯೊಂದು ಇಂಪೋರ್ಟ್ ಸ್ಟೇಟ್ಮೆಂಟ್ (import statement) ಮಾನಸಿಕ ಫಿಲ್ಟರ್ ಮೂಲಕ ಹಾದುಹೋಗಬೇಕಾಗುತ್ತದೆ, ಏಕೆಂದರೆ AI ಗೆ ಯಾವುದೇ ಜವಾಬ್ದಾರಿ ಅಥವಾ ಪರಿಣಾಮವನ್ನು ಎದುರಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಪ್ರೊಡಕ್ಷನ್ ಕೆಲಸ ವಿಫಲವಾದಾಗ ರಾತ್ರಿ 3 ಗಂಟೆಗೆ ಯಾರೂ ಅದನ್ನು ಎಚ್ಚರಿಸಲು ಬರುವುದಿಲ್ಲ.
ನಿಮ್ಮ ಮೆದುಳು ಏಕೆ ದಣಿಯುತ್ತದೆ
ಈ ದಣಿವಿನಿಕೆ ಸೋಮಾರಿತನವಲ್ಲ. ಇದು ಅತಿಯಾದ ಔಟ್ಪುಟ್ ಮತ್ತು ಮನುಷ್ಯನ ಸೀಮಿತ ಸಾಮರ್ಥ್ಯದ ನಡುವಿನ ಅನಿವಾರ್ಯ ಘರ್ಷಣೆಯಾಗಿದೆ.
ಮಾಹಿತಿಯ ಅತಿಯಾದ ಹೊರೆ (Volume overload). ಒಂದು ಸಾಮಾನ್ಯ AI ಸಲಹೆಯು ಪೂರ್ಣ React ಕಂಪೊನೆಂಟ್, ಅದರ ಸ್ಟೈಲಿಂಗ್ ಲಾಜಿಕ್, ಯುಟಿಲಿಟಿ ಫಂಕ್ಷನ್ಗಳು ಮತ್ತು ಯೂನಿಟ್ ಟೆಸ್ಟ್ಗಳನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ನಿಮ್ಮ ವರ್ಕಿಂಗ್ ಮೆಮೊರಿ (working memory) ಏಕಕಾಲದಲ್ಲಿ ಇಷ್ಟೊಂದು ಮಾಹಿತಿಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ. ಸ್ಕ್ರೀನ್ ಡಜನ್ಗಟ್ಟಲೆ ಹೊಸ ಸಾಲುಗಳಿಂದ ತುಂಬಿದಾಗ, ನಿಮ್ಮ ಮೆದುಳು ಅವುಗಳನ್ನು ಅಮೂರ್ತ ಮಾದರಿಗಳಾಗಿ (abstract patterns) ಸಂಕುಚಿತಗೊಳಿಸಬೇಕಾಗುತ್ತದೆ ಅಥವಾ ಒಂದೊಂದಾಗಿ ಸ್ಕ್ಯಾನ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಈ ಎರಡೂ ತಂತ್ರಗಳು ನಿಮ್ಮ ಗಮನವನ್ನು (attention) ವ್ಯಯಿಸುತ್ತವೆ. ಇಂತಹ ಹಲವಾರು ಬ್ಲಾಕ್ಗಳನ್ನು ಪರಿಶೀಲಿಸಿದ ನಂತರ, ಮಾನಸಿಕ ದಣಿವು ಉಂಟಾಗುತ್ತದೆ. ನೀವು ಓದುತ್ತಿದ್ದೀರಿ, ಆದರೆ ನೀವು ಅದನ್ನು ನಿಜವಾಗಿಯೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತಿಲ್ಲ.
ನಂಬಿಕೆಯ ಕೊರತೆ (The trust gap). AI-ಜನರೇಟೆಡ್ ಕೋಡ್ ನೋಡಲು ಅಧಿಕೃತವಾಗಿ ಕಾಣುತ್ತದೆ. ಇಂಡೆಂಟೇಶನ್ (Indentation) ಪರಿಪೂರ್ಣವಾಗಿರುತ್ತದೆ. ವೇರಿಯೇಬಲ್ ಹೆಸರುಗಳು ಅರ್ಥಪೂರ್ಣವಾಗಿರುತ್ತವೆ. ಕಾಮೆಂಟ್ಗಳು ಕೂಡ ಸರಿಯಾದ ಜಾಗದಲ್ಲಿರುತ್ತವೆ. ಆದರೆ ಅಧಿಕೃತವಾಗಿ ಕಾಣುವುದು ಎಂದರೆ ಅದು ನಿಖರ ಎಂದರ್ಥವಲ್ಲ. ಆ ಕೋಡ್ ಹಳೆಯದಾದ (deprecated) API ಅನ್ನು ಬಳಸಬಹುದು, null ಇನ್ಪುಟ್ಗಳಂತಹ ಎಡ್ಜ್ ಕೇಸ್ಗಳನ್ನು (edge cases) ಮರೆಯಬಹುದು ಅಥವಾ ಸೂಕ್ಷ್ಮವಾದ SQL ಇಂಜೆಕ್ಷನ್ ಅಪಾಯವನ್ನು ತರಬಹುದು. ಇದು ಸಂಭವಿಸಬಹುದು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿರುವುದರಿಂದ, ನೀವು ಕೇವಲ ಮೇಲ್ನೋಟಕ್ಕೆ ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ. ನೀವು ಪ್ರತಿಯೊಂದು return statement ಮತ್ತು ಪ್ರತಿಯೊಂದು ಲಾಜಿಕ್ ಬ್ರಾಂಚ್ ಅನ್ನು ಸೆಕ್ಯೂರಿಟಿ ಆಡಿಟ್ ಮಾಡುವಷ್ಟು ಜಾಗರೂಕತೆಯಿಂದ ಪರಿಶೀಲಿಸಬೇಕು. ಗಂಟೆಗಟ್ಟಲೆ ಇಂತಹ ಸೂಕ್ಷ್ಮ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡುವುದು ಮಾನಸಿಕವಾಗಿ ತುಂಬಾ ಕಷ್ಟಕರವಾದ ಕೆಲಸ. ವಿಮಾನ ನಿಲ್ದಾಣದ ಭದ್ರತಾ ಸಿಬ್ಬಂದಿ ಅಲ್ಪ ಅವಧಿಯ ಶಿಫ್ಟ್ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದಕ್ಕೆ ಇದೇ ಕಾರಣ: ದೀರ್ಘಕಾಲದ ಜಾಗರೂಕತೆಯು ಬೇಗನೆ ಕ್ಷೀಣಿಸುತ್ತದೆ.
ಕೆಲಸದ ಕ್ರಮದಲ್ಲಿನ ಅಸಮತೋಲನ (Workflow mismatch). ಹೆಚ್ಚಿನ ಡೆವಲಪ್ಮೆಂಟ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ಗಳು ಮತ್ತು ತಂಡದ ಪ್ರಕ್ರಿಯೆಗಳು ಇಂದಿಗೂ ಮನುಷ್ಯನು ಮೊದಲು ಬರೆದು ನಂತರ ಪರೀಕ್ಷಿಸುವ (write-then-test) ಲಯವನ್ನು ಅವಲಂಬಿಸಿವೆ. ಕೋಡ್ ಬೇಸ್ ಮನುಷ್ಯನ ವೇಗದಲ್ಲಿ ಬೆಳೆಯುತ್ತದೆ ಮತ್ತು ಕೋಡ್ ರಿವ್ಯೂಗಳು ನಿಗದಿತ ಸಮಯದಲ್ಲಿ ನಡೆಯುತ್ತವೆ. AI ಅನ್ನು ಈ ಪ್ರಕ್ರಿಯೆಗೆ ಅಳವಡಿಸಿದಾಗ, ಕೆಲಸದ ಹರಿವು (flow) ಏರುಪೇರಾಗುತ್ತದೆ. ನೀವು ಇಪ್ಪತ್ತು ಸಾಲುಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತೀರಿ, ಪರಿಶೀಲಿಸಲು ನಿಲ್ಲುತ್ತೀರಿ, ತಿದ್ದುಪಡಿ ಕೇಳುತ್ತೀರಿ, ಮತ್ತೆ ಪರಿಶೀಲಿಸುತ್ತೀರಿ, ಮುಂದಿನ ಫಂಕ್ಷನ್ಗೆ ಹೋಗುತ್ತೀರಿ ಮತ್ತು ವಿಶಾಲವಾದ ಆರ್ಕಿಟೆಕ್ಚರ್ನ (architecture) ಸಂಪರ್ಕವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ. ಸೃಜನಾತ್ಮಕ ಸೃಷ್ಟಿ ಮತ್ತು ಸಂಶಯಾಸ್ಪದ ವ್ಯಾಲಿಡೇಶನ್ ನಡುವಿನ ನಿರಂತರ ಬದಲಾವಣೆಗಳು ಅಡೆತಡೆಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತವೆ. ನಿಮ್ಮ IDE ಅನ್ನು ಲೇಖಕರಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ನಿರಂತರ ಗಡುವಿನ ಅಡಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ಎಡಿಟರ್ಗಳಿಗಾಗಿ ಅಲ್ಲ.
ದಣಿವಿನ ಚಕ್ರ
ಈ ಅಂಶಗಳು ದಿನ ಕಳೆದಂತೆ ಮತ್ತಷ್ಟು ಕೆಡಗೊಡುವ ಒಂದು ಚಕ್ರವನ್ನು ಸೃಷ್ಟಿಸುತ್ತವೆ.
ಅಸಿಸ್ಟೆಂಟ್ ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಒಂದು ಫೀಚರ್ ಅನ್ನು ಸೃಷ್ಟಿಸಿ ಕೊಡುತ್ತದೆ. ನಂತರ ನೀವು ಇಂಪೋರ್ಟ್ಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು, ಟೈಪ್ ಕಾಂಪ್ಯಾಟಿಬಿಲಿಟಿ (type compatibility) ಪರಿಶೀಲಿಸಲು ಮತ್ತು ಎಡ್ಜ್ ಕೇಸ್ಗಳ ಮಾನಸಿಕ ಸಿಮ್ಯುಲೇಶನ್ಗಳನ್ನು ಮಾಡಲು ಹದಿನೈದು ನಿಮಿಷಗಳನ್ನು ವ್ಯಯಿಸುತ್ತೀರಿ. ಮೂರನೇ ಅಥವಾ ನಾಲ್ಕನೇ ಸುತ್ತಿನ ವೇಳೆಗೆ, ನಿಮ್ಮ ಏಕಾಗ್ರತೆ ಕಡಿಮೆಯಾಗುತ್ತದೆ. "ಹೆಚ್ಚಾಗಿ ಸರಿಯಾಗಿ ಕಾಣುವ" ಸ್ನಿಪ್ಪೆಟ್ಗಳನ್ನು (snippets) ನೀವು ಒಪ್ಪಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ. ತಪ್ಪುಗಳು ತಪ್ಪಿಹೋಗುತ್ತವೆ. ಇದನ್ನು ಸರಿದೂಗಿಸಲು, ನೀವು ಕೆಲಸದ ವೇಗವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತೀರಿ, ಇದು ನೀವು ಮೊದಲೇ ಪಡೆದ ವೇಗವನ್ನು ವ್ಯರ್ಥ ಮಾಡುತ್ತದೆ. ದಿನದ ಕೊನೆಯಲ್ಲಿ, ನಿಮ್ಮ ಬಳಿ ಎಂದಿಗಿಂತ ಹೆಚ್ಚು ಕೋಡ್ ಇರುತ್ತದೆ, ಆದರೆ ಅದರ ಮೇಲೆ ನಂಬಿಕೆ ಕಡಿಮೆ ಇರುತ್ತದೆ ಮತ್ತು ನೀವು ಬುದ್ಧಿವಂತಿಕೆಯಿಂದ ಕೆಲಸ ಮಾಡಿದ್ದಕ್ಕಿಂತ ಕಷ್ಟಪಟ್ಟು ಕೆಲಸ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಸೂಚಿಸುವ ತಲೆನೋವು ಇರುತ್ತದೆ.
ವೇಗವು ಅಪಾಯಕಾರಿಯಾಗುವಾಗ
ಈ ಮಾದರಿಯು ದೈನಂದಿನ ಅಭ್ಯಾಸವಾಗಿ ಬದಲಾದರೆ, ಅದರ ಪರಿಣಾಮಗಳು ಕೇವಲ ಒಂದು ಕೆಟ್ಟ ಮಧ್ಯಾಹ್ನಕ್ಕೆ ಸೀಮಿತವಾಗುವುದಿಲ್ಲ.
ಬರ್ನ್ಔಟ್ (Burnout) ಮೌನವಾಗಿ ಬರುತ್ತದೆ. ಇದು ಪ್ರಾಜೆಕ್ಟ್ ತೆರೆಯುವಾಗ ಉಂಟಾಗುವ ಭಯ ಅಥವಾ ಮತ್ತೊಂದು ಕೋಡ್ ಬ್ಲಾಕ್ ಅನ್ನು ನೋಡಲು ಇಷ್ಟವಿಲ್ಲದ ಸ್ಥಿತಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. ನಿಮಗೆ ಸಹಾಯ ಮಾಡಬೇಕಾದ ಪ್ರಮುಖ ಸಾಧನವೇ ದಣಿವಿನ ಮೂಲವಾದಾಗ, ಅಸಮಾಧಾನ ಉಂಟಾಗುತ್ತದೆ.
ನಂತರ ಕೌಶಲ್ಯದ ಕ್ಷೀಣತೆ (skill atrophy) ಉಂಟಾಗುತ್ತದೆ. ಉದ್ದೇಶವನ್ನು (intent) ಸಿಂಟ್ಯಾಕ್ಸ್ (syntax) ಆಗಿ ಪರಿವರ್ತಿಸುವ ಸಾಮರ್ಥ್ಯವು ನೀವು ಅದನ್ನು ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸಿದಾಗ ದುರ್ಬಲಗೊಳ್ಳುತ್ತದೆ. ನೀವು ಇನ್ನೂ ಸಿಸ್ಟಮ್ಗಳನ್ನು (systems) ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಬಹುದು, ಆದರೆ ಸೂಕ್ಷ್ಮ ಮಟ್ಟದ ಪರಿಣತಿ — ಅಂದರೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಲೂಪ್ ರಚನೆ (loop structure) ಏಕೆ ಸರಿಯಿಲ್ಲ ಎಂದು ತಿಳಿಯುವುದು ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಲೈಬ್ರರಿ (library) ಲೋಡ್ ಅಡಿಯಲ್ಲಿ ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳುವುದು — ಆಲ್ಟೋಕಂಪ್ಲೀಟ್ (autocomplete) ಪದರವು ವಿವರಗಳನ್ನು ನಿರ್ವಹಿಸಿದಾಗ ಮರೆಯಾಗಬಹುದು. ಕಾಲಾನಂತರದಲ್ಲಿ, ನೀವು ಒಬ್ಬ ಸಕ್ರಿಯ ಎಂಜಿನಿಯರ್ ಆಗಿರುವ ಬದಲು ಕೇವಲ ಒಬ್ಬ ನಿಷ್ಕ್ರಿಯ ಕ್ಯುರೇಟರ್ (passive curator) ಆಗುವ ಅಪಾಯವಿರುತ್ತದೆ.
ಆದಾಗ್ಯೂ, ಅತ್ಯಂತ ತಕ್ಷಣದ ಅಪಾಯವೆಂದರೆ ಅಜಾಗರೂಕತೆಯ ನಿಯೋಜನೆ (sloppy deployment). ವೇಗವನ್ನು ಕಾಯ್ದುಕೊಳ್ಳುವ ಒತ್ತಡದಲ್ಲಿ ಮತ್ತು ಗಂಟೆಗಟ್ಟಲೆ ಯಂತ್ರದ ಔಟ್ಪುಟ್ (machine output) ಓದಿದ್ದರಿಂದ ದಣಿದಿರುವಾಗ, ಡೆವಲಪರ್ಗಳು ಕೆಲವೊಮ್ಮೆ ಪೂರ್ಣವಾಗಿ ಪರಿಶೀಲಿಸದ ಕೋಡ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತಾರೆ.