ಅನೇಕರು AI ಸಾಫ್ಟ್ವೇರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಬಹಳ ಅಗ್ಗವಾಗಿಸುತ್ತದೆ ಎಂದು ಹೇಳುತ್ತಾರೆ. ಮಾದರಿಗಳು (models) ಎಂಜಿನಿಯರ್ಗಳ ಬದಲಿಗೆ ಬಂದು, ಕೆಲಸಗಳನ್ನು ನಿಮಿಷಗಳಲ್ಲಿ ಮುಗಿಸುತ್ತವೆ ಎಂದು ಅವರು ಕಲ್ಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ. ಆ ಕಥೆ ಆಕರ್ಷಕವಾಗಿದೆ, ಆದರೆ ಅದು ಸಂಪೂರ್ಣವಾಗಿ ನಿಜವಲ್ಲ. ಸಾಫ್ಟ್ವೇರ್ ನಿರ್ಮಾಣದ ಅರ್ಥಶಾಸ್ತ್ರವು ಬದಲಾಗಿದೆ ಹೊರತು ಅಳಿದು ಹೋಗಿಲ್ಲ. ಮೊದಲ ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ ಬಂದಾಗ ತಾಂತ್ರಿಕ ಸಾಲವು (Technical debt) ಮಾಯವಾಗಲಿಲ್ಲ. ನಾವು ಅದನ್ನು ಪಾವತಿಸಲು ಕೇವಲ ಒಂದು ಹೊಸ ಮಾರ್ಗವನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ ಅಷ್ಟೆ.
ಹಳೆಯ ಇನ್ವಾಯ್ಸ್: ಸಿಬ್ಬಂದಿ ಸಂಖ್ಯೆ (Head Count)
ದಶಕಗಳಿಂದ, ತಾಂತ್ರಿಕ ಸಾಲವು ಪರಿಚಿತವಾದ ಒಂದು ವಿನಾಶಕಾರಿ ಚಕ್ರವನ್ನು (doom loop) ಸೃಷ್ಟಿಸುತ್ತಿತ್ತು. ಕೋಡ್ಬೇಸ್ ಕ್ರಮೇಣ ದುರ್ಬಲಗೊಳ್ಳುತ್ತಿತ್ತು. ಒಮ್ಮೆ ದಿನಗಟ್ಟಲೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದ ಫೀಚರ್ಗಳು ಈಗ ವಾರಗಟ್ಟಲೆ ತೆಗೆದುಕೊಳ್ಳತೊಡಗಿದವು. ಗಡುವುಗಳು ತಪ್ಪಿದಾಗ, ನಾಯಕತ್ವವು ಹೆಚ್ಚಿನ ಸಿಬ್ಬಂದಿ ನೇಮಕಾತಿಗಳನ್ನು ಮಾಡಿತು. ದೊಡ್ಡ ತಂಡಗಳು ಕೆಲಸದ ವೇಗವನ್ನು ಮತ್ತಷ್ಟು ಕಡಿಮೆ ಮಾಡಿದವು. ಸಮನ್ವಯದ ಹೊರೆ ಹೆಚ್ಚಾಯಿತು, ಸ್ಟ್ಯಾಂಡ್-ಅಪ್ಗಳು (stand-ups) ಹೆಚ್ಚಾದವು ಮತ್ತು ಕನ್ವಾಯ್ಸ್ ನಿಯಮವು (Conway’s Law) ಜಾರಿಗೆ ಬಂದಿತು: ಸಾಫ್ಟ್ವೇರ್ ಅದನ್ನು ನಿರ್ಮಿಸುವ ಜನರ ಸಂವಹನ ಕೊರತೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸಲು ಪ್ರಾರಂಭಿಸಿತು. ಹೆಚ್ಚಿನ ಬಗ್ಗಳು (bugs) ಪತ್ತೆಯಾಗದೆ ಉಳಿದವು. ಪ್ರತಿ ಪ್ಯಾಚ್ ಕೂಡ ಹೊಸ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸೇರಿಸಿತು. ಕಂಪನಿಗಳು ಈ ಕ್ಷಯಕ್ಕೆ ತಮಗೆ ತಿಳಿದಿದ್ದ ಏಕೈಕ ಹಣದ ರೂಪದಲ್ಲಿ ಪಾವತಿಸಿದವು: ಮಾನವ ಸಂಬಳಗಳು. ವೆಚ್ಚವು ಸ್ಪಷ್ಟವಾಗಿತ್ತು. ಪ್ರತಿ ತ್ರೈಮಾಸಿಕ ಬಜೆಟ್ ಪರಿಶೀಲನೆಯಲ್ಲೂ ಅದು ಎದ್ದು ಕಾಣುತ್ತಿತ್ತು.
ಹೊಸ ಇನ್ವಾಯ್ಸ್: ಟೋಕನ್ಗಳು ಮತ್ತು ಸಂದರ್ಭ (Tokens and Context)
ಜನರೇಟಿವ್ AI ಈ ಚಕ್ರವನ್ನು ಮುರಿದಿಲ್ಲ. ಅದು ಕೇವಲ ಪರ್ಯಾಯ ಪಾವತಿ ಯೋಜನೆಯನ್ನು ಪರಿಚಯಿಸಿದೆ. ಕೆಲಸದ ಅಡೆತಡೆಗಳನ್ನು ನಿವಾರಿಸಲು ಐದು ಎಂಜಿನಿಯರ್ಗಳನ್ನು ನೇಮಿಸಿಕೊಳ್ಳುವ ಬದಲು, ಕಂಪನಿಯು ಈಗ ಹೆಚ್ಚಿನ ಕಂಪ್ಯೂಟ್ (compute) ಸಾಮರ್ಥ್ಯಕ್ಕಾಗಿ ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಬಳಸುತ್ತಿದೆ. ಲಕ್ಷಣಗಳು ವಿಭಿನ್ನವಾಗಿ ಕಾಣಿಸಬಹುದು, ಆದರೆ ಮೂಲ ಕಾಯಿಲೆ ಒಂದೇ ಆಗಿದೆ.
ಒಂದು ಮಾಡೆಲ್ ವಿಫಲವಾಗತೊಡಗಿದಾಗ—ಅಂತರಾತ್ಮದ APIಗಳನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳುವುದು (hallucinating), ನಿರ್ಣಾಯಕ ಎಡ್ಜ್ ಕೇಸ್ಗಳನ್ನು (edge cases) ಮರೆಯುವುದು, ಅಥವಾ ತಪ್ಪು ಕಾರಣಗಳಿಗಾಗಿ ಪಾಸಾಗುವ ಪರೀಕ್ಷೆಗಳನ್ನು (tests) ಸೃಷ್ಟಿಸುವುದು—ಅದನ್ನು ಸರಿಪಡಿಸಲು (refactor) ಪ್ರಯತ್ನಿಸುವುದು ಅಪರೂಪ. ಬದಲಾಗಿ, ಇನ್ಫರೆನ್ಸ್ (inference) ಮೇಲೆ ಹಣ ವ್ಯಯಿಸುವುದು ಸಾಮಾನ್ಯ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿದೆ. ತಂಡಗಳು ಕಾಂಟೆಕ್ಸ್ಟ್-ವಿಂಡೋ (context-window) ಅಪ್ಗ್ರೇಡ್ಗಳನ್ನು ಖರೀದಿಸುತ್ತವೆ, ಮಲ್ಟಿ-ಏಜೆಂಟ್ ರಿಟ್ರೈ ಲೂಪ್ಗಳನ್ನು ಜೋಡಿಸುತ್ತವೆ, ಕೆಲಸದ ಹೊರೆಯನ್ನು ದೊಡ್ಡ ಫ್ರಾಂಟಿಯರ್ ಮಾಡೆಲ್ಗಳಿಗೆ ವರ್ಗಾಯಿಸುತ್ತವೆ ಅಥವಾ ವ್ಯತ್ಯಾಸವು (diff) ಸ್ವೀಕಾರಾರ್ಹವಾಗಿ ಕಾಣುವವರೆಗೆ 'regenerate' ಬಟನ್ ಅನ್ನು ಒತ್ತುತ್ತಲೇ ಇರುತ್ತವೆ. ಈ ತಂತ್ರಗಳು ಒಂದು ಅಥವಾ ಎರಡು ಸ್ಪ್ರಿಂಟ್ಗಳವರೆಗೆ ಕೇವಲ ಮೇಲ್ನೋಟದ ವೇಗವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಜಿರಾ (Jira) ಬೋರ್ಡ್ ಹಸಿರಾಗಿರುತ್ತದೆ. ಈ ಮಧ್ಯೆ, ವಾಸ್ತವದ ಆರ್ಕಿಟೆಕ್ಚರ್ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ: ಅದೇ ಗೊಂದಲಮಯ ಅವಲಂಬನೆಗಳು (dependencies), ಅದೇ ಬದಲಾಗಬಲ್ಲ ಗ್ಲೋಬಲ್ ಸ್ಟೇಟ್ (mutable global state), ಮತ್ತು ಪ್ರಸ್ತುತ ತಂಡದಲ್ಲಿ ಯಾರೂ ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳದ ಅದೇ ಮೊನೊಲಿತ್ (monolith).
ಅಚ್ಚುಕಟ್ಟಿಲ್ಲದ ಕೋಡ್ ಏಕೆ ಹೆಚ್ಚು ಟೋಕನ್ಗಳನ್ನು ಖರ್ಚು ಮಾಡುತ್ತದೆ?
ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು (LLMs) ಅಚ್ಚುಕಟ್ಟಾದ ಅಬ್ಸ್ಟ್ರಾಕ್ಷನ್ಗಳ (abstractions) ವಿರುದ್ಧ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಆದರೆ ಹೆಚ್ಚಿನ ಎಂಟರ್ಪ್ರೈಸ್ ರೆಪೊಸಿಟರಿಗಳು ಪುರಾತತ್ವ ತಾಣಗಳಂತೆ ಇವೆ. ಅವುಗಳಲ್ಲಿ ಸರ್ಕ್ಯುಲರ್ ಪ್ಯಾಕೇಜ್ ಅವಲಂಬನೆಗಳು, ಇನಿಶಿಯಲೈಸೇಶನ್ ಸ್ಕ್ರಿಪ್ಟ್ಗಳಲ್ಲಿ ಅಡಗಿರುವ ಗುಪ್ತ ಪರಿಣಾಮಗಳು (side effects), ಮತ್ತು ಡೇಟಾಬೇಸ್ ಟ್ರಿಗ್ಗರ್ಗಳು, ಮಿಡ್ಲ್ವೇರ್ ಲೇಯರ್ಗಳು ಹಾಗೂ ಫ್ರಂಟ್-ಎಂಡ್ ಘಟಕಗಳಾದ್ಯಂತ ಹರಡಿರುವ ಬಿಸಿನೆಸ್ ಲಾಜಿಕ್ ಇರುತ್ತದೆ. ಅಂತಹ ಪರಿಸರದಲ್ಲಿ, ಮಾಡೆಲ್ ಹೊಸ ಲಾಜಿಕ್ ಬರೆಯಲು ಶಕ್ತಿಯನ್ನು ವ್ಯಯಿಸುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ವಿಷಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು (comprehension) ಟೋಕನ್ಗಳನ್ನು ಸುಡುತ್ತದೆ.
128,000-ಟೋಕನ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋದ ಬಹುಪಾಲು ಭಾಗವು ಕೇವಲ ಸಿಸ್ಟಮ್ನ ಸ್ವರೂಪವನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಲು ವ್ಯಯವಾಗಬಹುದು. ಉಳಿದಿರುವ ಸಣ್ಣ ಭಾಗವು ಮಾತ್ರ ನಿಜವಾದ ಸಮಸ್ಯೆ ಪರಿಹಾರಕ್ಕಾಗಿ ಉಳಿಯುತ್ತದೆ. ಇದು ಒಬ್ಬ ಸ್ಟ್ರಕ್ಚರಲ್ ಇಂಜಿನಿಯರ್ಗೆ ಹೊಸ ಮಹಡಿಯನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ಹೇಳುವಾಗ, ಪ್ರತಿ ಲೆಕ್ಕಾಚಾರಕ್ಕೂ ಮೊದಲು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕಟ್ಟಡದ ನೀಲನಕ್ಷೆಯನ್ನು (blueprints) ನೆನಪಿನ ಶಕ್ತಿಯಿಂದ ಮರುಚಿತ್ರಿಸಲು ಒತ್ತಾಯಿಸಿದಂತೆ ಇರುತ್ತದೆ. ಇದರ ಪರಿಣಾಮ ಮೇಲ್ಮಟ್ಟದ ಪರಿಹಾರಗಳು ಮಾತ್ರ. ಮಾಡೆಲ್ ತಾನು ನೋಡುವ ಗೊಂದಲವನ್ನೇ ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಮೊದಲು ಆ ಗೊಂದಲವನ್ನು ಸರಿಪಡಿಸಲು ಅದಕ್ಕೆ ಅಧಿಕಾರ ಅಥವಾ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸಂದರ್ಭ (architectural context) ಇರುವುದಿಲ್ಲ.
ವೇಗದ ಔಟ್ಪುಟ್, ನಿಧಾನಗತಿಯ ಶಿಪ್ಪಿಂಗ್
ಕೇವಲ ಉತ್ಪಾದನೆಯ ವೇಗವು ಶಿಪ್ಪಿಂಗ್ ವೇಗಕ್ಕೆ ಸಮನಲ್ಲ. ನಿಮ್ಮ ಆರ್ಕಿಟೆಕ್ಚರ್ನಲ್ಲಿ ಮಾಡ್ಯುಲಾರಿಟಿ (modularity) ಇಲ್ಲದಿದ್ದರೆ, AI ಸೃಷ್ಟಿಸಿದ ಪ್ರತಿಯೊಂದು ಬದಲಾವಣೆಯೂ ಸಮಗ್ರ ಮಾನವ ವಿಮರ್ಶೆ ಮತ್ತು ರಿಗ್ರೆಷನ್ ಟೆಸ್ಟಿಂಗ್ ಅನ್ನು ಬಯಸುತ್ತದೆ. ಒಂದು ಮಾಡೆಲ್ ಮಧ್ಯಾಹ್ನದ ವೇಳೆಗೆ ಹತ್ತು ಪುಲ್ ರಿಕ್ವೆಸ್ಟ್ಗಳನ್ನು (pull requests) ಸೃಷ್ಟಿಸಬಹುದು, ಆದರೆ ಆ ಪುಲ್ ರಿಕ್ವೆಸ್ಟ್ಗಳು ಇಂಟಿಗ್ರೇಷನ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ಗಳು, ಸೆಕ್ಯೂರಿಟಿ ಸ್ಕ್ಯಾನರ್ಗಳು, ಕಾಂಪ್ಲೈಯನ್ಸ್ ಚೆಕ್ಲಿಸ್ಟ್ಗಳು ಮತ್ತು ಪ್ರೊಡಕ್ಷನ್ ಕ್ಯಾನರಿಗಳ ಮೂಲಕ ಹಾದುಹೋಗಲೇಬೇಕು. ಸ್ಪಷ್ಟವಾದ ಮಾಡ್ಯೂಲ್ ಗಡಿಗಳಿಲ್ಲದೆ, AI ಯಂತ್ರದ ವೇಗದಲ್ಲಿ ಬಗ್ಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಇದು ಒಂದು ಶೇರ್ಡ್ ಯುಟಿಲಿಟಿಯನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು, ಸಣ್ಣ ತಪ್ಪು ಕಲ್ಪನೆಗಳೊಂದಿಗೆ ಮೂರು ದೂರದ ಕಾಲ್ ಸೈಟ್ಗಳನ್ನು ಅಪ್ಡೇಟ್ ಮಾಡಬಹುದು ಮತ್ತು ಮನುಷ್ಯರು ಬೆಳಗಿನ ಜಾವ 3 ಗಂಟೆಗೆ ಎಚ್ಚರಗೊಂಡಾಗ ಮಾತ್ರ ಪತ್ತೆಹಚ್ಚಬಹುದಾದ ರೇಸ್ ಕಂಡೀಷನ್ಗಳನ್ನು (race conditions) ಉಂಟುಮಾಡಬಹುದು. ಅಡಚಣೆಯು ಕೀಬೋರ್ಡ್ನಿಂದ ವ್ಯಾಲಿಡೇಶನ್ ಪೈಪ್ಲೈನ್ಗೆ ಸ್ಥಳಾಂತರಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಆ ಪೈಪ್ಲೈನ್ ಬದಲಾವಣೆಗಳ ಪ್ರಮಾಣದಲ್ಲಿ ಹತ್ತು ಪಟ್ಟು ಹೆಚ್ಚಳವನ್ನು ನಿಭಾಯಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿಲ್ಲ.
ಅಡಗಿರುವ ಮಿತಿ (The Hidden Ceiling)
AI ಪೂರ್ವ ಯುಗದಲ್ಲಿ, ಕಠಿಣ ಮಿತಿಯು ನಿಮ್ಮ ನೇಮಕಾತಿ ಬಜೆಟ್ ಆಗಿತ್ತು. ಕನಿಷ್ಠ ಪಕ್ಷ ಅದನ್ನು ಸ್ಪ್ರೆಡ್ಶೀಟ್ನಲ್ಲಿ ಓದುವುದು ಸುಲಭವಾಗಿತ್ತು. ಈಗ ಮಿತಿಯು ಹೆಚ್ಚಿನ ಹಣಕಾಸು ತಂಡಗಳು ಗಮನಿಸದ ಅಂಶಗಳೊಳಗೆ ಅಡಗಿದೆ: ಇನ್ಫರೆನ್ಸ್ ವೆಚ್ಚಗಳು, ಎಂಬೆಡ್ಡಿಂಗ್ ಸ್ಟೋರೇಜ್, ಕಾಂಟೆಕ್ಸ್ಟ್-ವಿಂಡೋ ವಿಸ್ತರಣೆಗಳು ಮತ್ತು CI ರನ್ನರ್ಗಳನ್ನು ಕುಂಠಿತಗೊಳಿಸುವ ಆಟೋಮೇಟೆಡ್-ಟೆಸ್ಟಿಂಗ್ ಗರಿಡ್ಲಾಕ್. ಪ್ರೊಡಕ್ಟಿವಿಟಿ ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಳು ಹಸಿರಾಗಿ ಮಿನುಗುತ್ತಾ ಇರುತ್ತವೆ, ಆದರೆ ಪ್ರತಿ ಹೊಸ ಫೀಚರ್ನ ನಿಜವಾದ ವೆಚ್ಚವು ನಿಧಾನವಾಗಿ ಹೆಚ್ಚಾಗುತ್ತಾ ಹೋಗುತ್ತದೆ.
Architectural entropy is the real villain here. LLMs scale code production beautifully, but they do not reduce complexity. They do not untangle microservices, eliminate dead code, or collapse inheritance hierarchies. Once a system crosses the threshold where humans struggle to reason about it, AI struggles too. At that inflection point, costs curve upward whether you