ನನ್ನ ಕೋಡ್‌ಬೇಸ್‌ನ ನಕ್ಷೆಯನ್ನು AI ಕೋಡಿಂಗ್ ಏಜೆಂಟ್‌ಗೆ ರಚಿಸಲು ಬಿಟ್ಟೆ, ಏನಾಯಿತು ಎಂಬುದು ಇಲ್ಲಿದೆ

ನೀವು AI ಕೋಡಿಂಗ್ ಸಹಾಯಕನಿಗೆ ಬಗ್ ಸರಿಪಡಿಸಲು ಅಥವಾ ಏನಾದರೂ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ವಿವರಿಸಲು ಕೇಳಿದಾಗಲೆಲ್ಲ, ಅದು ಸಾಮಾನ್ಯವಾಗಿ ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಅದು ಫೈಲ್‌ಗಳನ್ನು ಓದುತ್ತದೆ, grep ಮಾಡುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ ಯೋಜನೆಯ ಬಗ್ಗೆ ನಿನ್ನೆಯೇ ಅದಕ್ಕೆ ಇದ್ದ ತಿಳುವಳಿಕೆಯನ್ನು ನಿಧಾನವಾಗಿ ಪುನರ್ನಿರ್ಮಿಸುತ್ತದೆ. ಇಂದು ಸೆಪ್ಟೆಂಬರ್ 2, 2026, ಮತ್ತು ಈ ಸಮಸ್ಯೆಯು ಹೆಚ್ಚು ಗಮನ ಸೆಳೆಯುತ್ತಿದೆ ಏಕೆಂದರೆ AI ಕೋಡಿಂಗ್ ಏಜೆಂಟ್‌ಗಳು ಈಗ ಒಂದು ವರ್ಷದ ಹಿಂದಿನಕ್ಕಿಂತ ಹೆಚ್ಚು ಸ್ವಾಯತ್ತವಾದ, ಬಹು-ಹಂತದ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತಿವೆ, ಅಂದರೆ ಪ್ರತಿ ಸೆಷನ್‌ನಲ್ಲೂ "ಮೊದಲಿನಿಂದ ಪ್ರಾರಂಭಿಸುವ" ವೆಚ್ಚವು ಸಮಯ ಮತ್ತು ಟೋಕನ್ ಬಿಲ್ ಎರಡರಲ್ಲೂ ವೇಗವಾಗಿ ಹೆಚ್ಚುತ್ತದೆ.

ಅದೇ ಸಮಸ್ಯೆಯನ್ನು Graft ಎಂಬ ಸಾಧನವು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ನಾನು ಅದನ್ನು ನಿಜವಾದ ಯೋಜನೆಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿದೆ, ಆಟಿಕೆ ಡೆಮೊ ಅಲ್ಲ, ಮತ್ತು ಅದು ನಿಜವಾಗಿ ಏನು ಮಾಡುತ್ತದೆ, ಏನು ಕಂಡುಹಿಡಿಯಿತು, ಮತ್ತು ಎಲ್ಲಿ ಕಡಿಮೆ ಬೀಳುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಮಗೆ ವಿವರಿಸಲು ಬಯಸುತ್ತೇನೆ.

Graft ನಿಜವಾಗಿ ಏನು

Graft ಅನ್ನು ನಿಮ್ಮ ಕೋಡ್‌ನ ಗ್ರಂಥಪಾಲಕ ಎಂದು ಯೋಚಿಸಿ. AI ಏಜೆಂಟ್ ಏನನ್ನಾದರೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕಾದಾಗಲೆಲ್ಲ ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ ಅಲೆದಾಡುವ ಬದಲು, Graft ಒಂದು ಸೂಚ್ಯಂಕವನ್ನು ಒಮ್ಮೆ ನಿರ್ಮಿಸುತ್ತದೆ: ನಿಮ್ಮ ಕೋಡ್‌ನ ಪ್ರತಿ ಭಾಗ ಏನು ಮಾಡುತ್ತದೆ, ಯಾವ ಫಂಕ್ಷನ್‌ಗಳು ಯಾವ ಇತರ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಕರೆಯುತ್ತವೆ, ಮತ್ತು ಎಲ್ಲವೂ ಹೇಗೆ ಸಂಪರ್ಕಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುವ ಸಣ್ಣ, ಸಂಪರ್ಕಿತ ಪಠ್ಯ ಫೈಲ್‌ಗಳ ಫೋಲ್ಡರ್.

ಇದನ್ನು ಎರಡು ಪದರಗಳಲ್ಲಿ ಮಾಡುತ್ತದೆ:

1. ಒಂದು ರಚನಾತ್ಮಕ ಗ್ರಾಫ್, tree-sitter ಎಂಬ ಕೋಡ್-ಪಾರ್ಸಿಂಗ್ ತಂತ್ರವನ್ನು ಬಳಸಿ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಈ ಪದರಕ್ಕೆ ಯಾವುದೇ AI ಮಾಡೆಲ್ ಅಗತ್ಯವಿಲ್ಲ. ಇದು ಕಂಪೈಲರ್ ಓದುವ ರೀತಿಯಲ್ಲಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಓದುತ್ತದೆ, ಮತ್ತು ಫಂಕ್ಷನ್ ಹೆಸರುಗಳು, ಕ್ಲಾಸ್‌ಗಳು, ಮತ್ತು ಅವುಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ.
2. ಐಚ್ಛಿಕ ಪರಿಕಲ್ಪನಾ ಪದರ, ಕೋಡ್‌ನ ಪ್ರತಿ ಭಾಗ ಯಾವುದಕ್ಕಾಗಿ ಎಂಬುದರ ಸರಳ-ಭಾಷೆಯ ಸಾರಾಂಶಗಳನ್ನು ಬರೆಯಲು AI ಮಾಡೆಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಈ ಭಾಗವು AI ಮಾಡೆಲ್ ಅನ್ನು ಕರೆಯುವ ಕಾರಣ ಚಲಾಯಿಸಲು ಹಣ ಖರ್ಚಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಇದು ಐಚ್ಛಿಕವಾಗಿದೆ.

ಮುಖ್ಯ ವಿಷಯ: ಮೊದಲ ಪದರ, ನಿಮ್ಮ ಇಡೀ ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ನಕ್ಷೆ ಮಾಡುವ ಪದರ, ಯಾವುದೇ ವೆಚ್ಚವಿಲ್ಲದೆ ಮತ್ತು ಯಾವುದೇ API ಕೀ ಅಗತ್ಯವಿಲ್ಲದೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಅದು ನಿಮ್ಮ ಫೈಲ್‌ಗಳನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಅಷ್ಟೇ.

ನಿಜವಾದ ಯೋಜನೆಯಲ್ಲಿ ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು ನಾನು ಏಕೆ ನಿರ್ಧರಿಸಿದೆ

ನಾನು ಒಂದು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಹಲವಾರು ನಿಜವಾದ ಕೋಡ್‌ಬೇಸ್‌ಗಳಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತೇನೆ: Kotlin ನಲ್ಲಿ ಬರೆದ Android ಅಪ್ಲಿಕೇಶನ್, ಆಧುನಿಕ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನೊಂದಿಗೆ ನಿರ್ಮಿಸಿದ ವೆಬ್‌ಸೈಟ್, ಒಂದೆರಡು ಸಣ್ಣ ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಗಳು, ಮತ್ತು ವಿವಿಧ ಕೆಲಸಗಳಿಗಾಗಿ ಕೆಲವು Python ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು. ಆ ಕೋಡ್‌ಬೇಸ್‌ಗಳಲ್ಲಿ ಒಂದಾದ Android ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸರಿಯಾಗಿ ಬೇರ್ಪಡಿಸುವ ಬದಲು ಅದಕ್ಕೆ ಜೋಡಿಸುತ್ತಾ ಹೋದ ಕಾರಣ ಮೂರು ಸಾವಿರಕ್ಕೂ ಹೆಚ್ಚು ಸಾಲುಗಳಿಗೆ ಬೆಳೆದಿರುವ ಒಂದೇ ಫೈಲ್ ಇದೆ. ನಿಜವಾದ ಸಾಫ್ಟ್‌ವೇರ್ ಯೋಜನೆಗಳಲ್ಲಿ ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಪರಿಸ್ಥಿತಿ. ಎಲ್ಲರೂ "ನಂತರ" ರೀಫ್ಯಾಕ್ಟರ್ ಮಾಡಬೇಕೆಂದು ಭಾವಿಸುತ್ತಾರೆ, ಮತ್ತು ನಂತರ ಯಾವಾಗಲೂ ಮುಂದೂಡಲ್ಪಡುತ್ತದೆ.

ಅಂತಹ ಫೈಲ್ ಅನ್ನು ಮುಟ್ಟುವ ಮೊದಲು, ಯಾವುದು ಯಾವುದರ ಮೇಲೆ ಅವಲಂಬಿತ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ತಿಳಿಯಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಒಂದು ಸಣ್ಣ ಬದಲಾವಣೆಯು ಮೂರು ಪರದೆಗಳ ಆಚೆ ಏನನ್ನಾದರೂ ಸದ್ದಿಲ್ಲದೆ ಮುರಿಯಬಹುದು. Graft ಉತ್ತರಿಸಲು ನಿರ್ಮಿಸಲಾದ ಪ್ರಶ್ನೆ ಅದೇ ಆಗಿದೆ, ಆದ್ದರಿಂದ ಇದು ನ್ಯಾಯಯುತ, ಪ್ರಾಮಾಣಿಕ ಪರೀಕ್ಷೆಯಾಗಿ ಅನಿಸಿತು.

ಸೆಟಪ್ ಮಾಡುವುದು

ಹಂತ 1: ಸಾಧನವನ್ನು ಸ್ಥಾಪಿಸಿ

Graft ಒಂದು ಸಣ್ಣ ಕಮಾಂಡ್-ಲೈನ್ ಪ್ರೋಗ್ರಾಂ ಆಗಿ ಸ್ಥಾಪನೆಯಾಗುತ್ತದೆ, ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಯಾವುದೇ ಡೆವಲಪರ್ ಸಾಧನವನ್ನು ಜಾಗತಿಕವಾಗಿ ಸ್ಥಾಪಿಸುವಂತೆಯೇ:

npm install -g @nanonets/graft

ಹಂತ 2: ಅದು ಏನು ಬದಲಾಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪೂರ್ವವೀಕ್ಷಣೆ ಮಾಡಿ

ನಿಮ್ಮ ಯೋಜನೆಗೆ ಏನನ್ನಾದರೂ ಸಂಪರ್ಕಿಸುವ ಮೊದಲು, ಇನ್ನೂ ಏನನ್ನೂ ಮುಟ್ಟದೆ, ಅದು ಯಾವ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ ಅಥವಾ ಮಾರ್ಪಡಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ತೋರಿಸಲು ಕೇಳಬಹುದು:

graft init --dry-run

ಇದು ಒಂದು ಸಣ್ಣ ಪಟ್ಟಿಯನ್ನು ಮುದ್ರಿಸಿತು: AI ಕೋಡಿಂಗ್ ಸಹಾಯಕಗಳಿಗಾಗಿ ಕೆಲವು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು, ಒಂದು ಸ್ಕಿಲ್ ಫೈಲ್, ಮತ್ತು ರಚಿತ ಗ್ರಾಫ್‌ಗಾಗಿ ಒಂದು ಫೋಲ್ಡರ್. ಏನನ್ನಾದರೂ ಒಪ್ಪಿಕೊಳ್ಳುವ ಮೊದಲು ಈ ಪಟ್ಟಿಯನ್ನು ನೋಡುವುದು ನಿಮ್ಮ ಯೋಜನೆಯನ್ನು ಗೌರವಿಸುವ ಸಾಧನದ ಉತ್ತಮ ಲಕ್ಷಣ.

ಹಂತ 3: ಈ ಯೋಜನೆಗೆ ಮಾತ್ರ ಸೀಮಿತವಾಗಿ ಚಲಾಯಿಸಿ

ಈ ರೀತಿಯ ಕೆಲವು ಸಾಧನಗಳು ನೀವು ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಯೋಜನೆಗೆ ಮಾತ್ರವಲ್ಲದೆ ನಿಮ್ಮ ಗಣಕದ ಪ್ರತಿ ಯೋಜನೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವ ಜಾಗತಿಕ ಕಾನ್ಫಿಗರೇಶನ್ ಬರೆಯಲು ಬಯಸುತ್ತವೆ. ನನಗೆ ಅದು ಬೇಡವಾಗಿತ್ತು, ಆದ್ದರಿಂದ ಎಲ್ಲವನ್ನೂ ಸ್ಥಳೀಯವಾಗಿ ಇಡಲು ಫ್ಲ್ಯಾಗ್ ಬಳಸಿದೆ:

graft init --no-global -y

ಇದು ಯೋಜನೆಯ ಪ್ರತಿ ನಿಜವಾದ ಮೂಲ ಫೈಲ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡಿತು (ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, Kotlin, TypeScript, JavaScript, ಮತ್ತು Python ನಲ್ಲಿ 77 ಫೈಲ್‌ಗಳು) ಮತ್ತು 561 ಪ್ರತ್ಯೇಕ ಕೋಡ್ ತುಣುಕುಗಳು ಮತ್ತು ಅವುಗಳ ನಡುವೆ 1,229 ಸಂಪರ್ಕಗಳನ್ನು ಹೊಂದಿದ ಗ್ರಾಫ್ ಅನ್ನು ನಿರ್ಮಿಸಿತು, ಕೆಲವು ಸೆಕೆಂಡುಗಳಲ್ಲಿ, ಯಾವುದೇ AI ಮಾಡೆಲ್ ಇಲ್ಲದೆ ಮತ್ತು ಯಾವುದೇ ವೆಚ್ಚವಿಲ್ಲದೆ.

ಕೆಲಸಕ್ಕೆ ಹಾಕುವುದು

ಇಲ್ಲಿ ಆಸಕ್ತಿಕರವಾಯಿತು. ನಾನು Graft ಗೆ ರೆಪೊ-ವ್ಯಾಪ್ತಿಯ ಮಾರ್ಗದರ್ಶನ ನಕ್ಷೆಯನ್ನು ಕೇಳಿದೆ, ಮತ್ತು ಅದು ತಕ್ಷಣವೇ ಆ ದೊಡ್ಡ Android ಫೈಲ್‌ನೊಳಗಿನ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಇಡೀ ಯೋಜನೆಯಲ್ಲಿ ಅತ್ಯಂತ ಹೆಚ್ಚು ಅವಲಂಬಿತ ಕೋಡ್ ತುಣುಕು ಎಂದು ಗುರುತಿಸಿತು, ಹತ್ತು ಇತರ ಸ್ಥಳಗಳು ಅದನ್ನು ಕರೆಯುತ್ತಿವೆ.

ನಂತರ ನಾನು ಹೆಚ್ಚು ನಿಖರವಾದ ಪ್ರಶ್ನೆ ಕೇಳಿದೆ: ಆ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಬದಲಾಯಿಸಿದರೆ ಏನೆಲ್ಲ ಪರಿಣಾಮಗೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸು. Graft ಇಡೀ ಸರಪಳಿಯನ್ನು ಪತ್ತೆಹಚ್ಚಿತು: ಪ್ರತಿ ಸ್ಕ್ರೀನ್, ಪ್ರತಿ ಸಹಾಯಕ ಫೈಲ್, ಆ ಫಂಕ್ಷನ್‌ನ ನಡವಳಿಕೆ ತಲುಪುವ ಪ್ರತಿ ಸ್ಥಳ, ತಕ್ಷಣವೇ ಮತ್ತು ಉಚಿತವಾಗಿ.

ಅದೇ ಉತ್ತರವನ್ನು ಕೋಡ್ ಅನ್ನು ಕೈಯಾರೆ ಓದಿ, ಅಥವಾ AI ಸಹಾಯಕನಿಗೆ ಎಲ್ಲವನ್ನೂ grep ಮಾಡಲು ಹೇಳಿ ಪಡೆಯಬೇಕಾಗಿದ್ದರೆ, ಸರಿಸುಮಾರು 200,000 ಟೋಕನ್‌ಗಳಷ್ಟು ಫೈಲ್ ವಿಷಯವನ್ನು ಓದಬೇಕಾಗಿತ್ತು. Graft ನ ಸ್ವಂತ ಲೆಕ್ಕಪತ್ರ ಸಾಧನವು ಗ್ರಾಫ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡುವ ಮೂಲಕ ಅಷ್ಟೊಂದನ್ನು ಉಳಿಸಿದೆ ಎಂದು ತೋರಿಸಿತು. ಮಧ್ಯಮ ಶ್ರೇಣಿಯ Claude ಮಾಡೆಲ್‌ನ ಪ್ರಸ್ತುತ ಬೆಲೆಯಲ್ಲಿ, ಒಂದೇ ವಿನಿಮಯದಲ್ಲಿ ಸುಮಾರು ನಲವತ್ತು ಸೆಂಟ್‌ಗಳಷ್ಟು ಉಳಿತಾಯವಾಗಿದೆ. ಇದು ಚಿಕ್ಕದಾಗಿ ಕಾಣಿಸಬಹುದು, ಆದರೆ ಆ ಕೋಡ್‌ಬೇಸ್ ಬಗ್ಗೆ ಯಾರಾದರೂ, ಮನುಷ್ಯ ಅಥವಾ AI, ಇಂತಹ ಪ್ರಶ್ನೆ ಕೇಳಿದಾಗಲೆಲ್ಲ ಆ ಉಳಿತಾಯ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ, ಮತ್ತು ನಿಜವಾದ ಮೌಲ್ಯ ಅಲ್ಲಿ ಸಂಗ್ರಹವಾಗುತ್ತದೆ.

ನನಗೆ ಇಷ್ಟವಾಗದಿದ್ದುದು

ಎಲ್ಲವೂ ಘರ್ಷಣೆ-ಮುಕ್ತವಾಗಿರಲಿಲ್ಲ. ಒಮ್ಮೆ ಸಂಪರ್ಕಿಸಿದ ನಂತರ, Graft ನಿಮ್ಮ AI ಕೋಡಿಂಗ್ ಸಹಾಯಕನಿಗೆ ನೀವು ಕಳುಹಿಸುವ ಪ್ರತಿ ಸಂದೇಶದಲ್ಲೂ ಚಲಿಸುವ ಹುಕ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಗ್ರಾಫ್‌ನಲ್ಲಿ ಏನಾದರೂ ಸಂಬಂಧಿತವಾದುದು ಇದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಎರಡು ಬೇರೆ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಕೋಡ್‌ಗೆ ಸಂಬಂಧಿಸದ ಸಾಮಾನ್ಯ ಸಂಭಾಷಣಾ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿದಾಗ, ಅದು ಇನ್ನೂ ಗ್ರಾಫ್ ಪರಿಶೀಲಿಸಲು ಸಲಹೆಯೊಂದಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಿತು. ಪ್ರಯತ್ನಿಸುವುದು ತಪ್ಪಲ್ಲ, ಆದರೆ ಆ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅದು ಅನಗತ್ಯ ಶಬ್ದವಾಗಿತ್ತು.

ಇದು ಅತ್ಯಂತ ಹೊಸ ಸಾಧನ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತಿಳಿಯುವುದೂ ಮುಖ್ಯ. ನಾನು ಇದನ್ನು ಬರೆಯುವ ಕೆಲವೇ ತಿಂಗಳ ಹಿಂದೆ ಅದನ್ನು ಮೊದಲ ಬಾರಿಗೆ ಪ್ರಕಟಿಸಲಾಗಿದೆ, ಮತ್ತು ಆ ಕಡಿಮೆ ಅವಧಿಯಲ್ಲಿ ಈಗಾಗಲೇ ಹಲವಾರು ಸಣ್ಣ ಆವೃತ್ತಿ ಬಿಡುಗಡೆಗಳಾಗಿವೆ. ಆ ಬದಲಾವಣೆಯ ವೇಗ ಉತ್ತೇಜಕ, ಆದರೆ ಹಳೆಯ ಡೆವಲಪರ್ ಸಾಧನಗಳಿಗೆ ಇರುವಂತೆ ವರ್ಷಗಳ ನೈಜ-ಪ್ರಪಂಚದ ಪರೀಕ್ಷೆ ಅದಕ್ಕೆ ಇನ್ನೂ ಆಗಿಲ್ಲ ಎಂಬುದನ್ನೂ ಅರ್ಥೈಸುತ್ತದೆ.

ತೀರ್ಮಾನ

AI ಕೋಡಿಂಗ್ ಸಹಾಯಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಲ್ಲಿ Graft ಒಂದು ನಿಜವಾದ, ದೈನಂದಿನ ಕಿರಿಕಿರಿಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ: ಸೆಷನ್‌ಗಳ ನಡುವೆ ಎಂದಿಗೂ ಬದಲಾಗದ ಕೋಡ್ ಅನ್ನು ನಿರಂತರವಾಗಿ ಪುನಃ ಅನ್ವೇಷಿಸುವುದು. ನಿಜವಾಗಿಯೂ ಅಸ್ತವ್ಯಸ್ತವಾದ, ಬಹು-ಭಾಷೆಯ ಯೋಜನೆಯಲ್ಲಿ, ಅದು ಸೆಕೆಂಡುಗಳಲ್ಲಿ, ಉಚಿತವಾಗಿ, ಸ್ಥಳೀಯ ಪಾರ್ಸಿಂಗ್ ಮಾತ್ರ ಬಳಸಿ ನಿಖರ, ಉಪಯುಕ್ತ ಉತ್ತರಗಳನ್ನು ನೀಡಿತು. ಇದು ಮಾಯಾಜಾಲವಲ್ಲ, ಮತ್ತು ನಿಮ್ಮ ಕಾರ್ಯವಿಧಾನಕ್ಕೆ ಸ್ವಲ್ಪ ಶಬ್ದ ಸೇರಿಸುತ್ತದೆ, ಆದರೆ ಬದಲಾವಣೆ ಮಾಡುವ ಮೊದಲು ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು AI ಸಹಾಯಕನಿಗೆ ಸಹಾಯ ಮಾಡುವ ಅಡಿಪಾಯವಾಗಿ, ಅದು ತನ್ನ ಸ್ಥಾನವನ್ನು ಗಳಿಸಿತು.

ಅನುಕೂಲಗಳು

• ಕೋರ್ ವೈಶಿಷ್ಟ್ಯಕ್ಕೆ ಯಾವುದೇ AI ಮಾಡೆಲ್ ಅಗತ್ಯವಿಲ್ಲದೆ, ಬಹು-ಭಾಷೆಯ ಕೋಡ್‌ಬೇಸ್‌ನ ಸಂಪೂರ್ಣ ನಕ್ಷೆಯನ್ನು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ನಿರ್ಮಿಸುತ್ತದೆ
• ರಚನಾತ್ಮಕ ಗ್ರಾಫ್ ಸಂಪೂರ್ಣವಾಗಿ ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರಿಂದ ಚಲಾಯಿಸಲು ಯಾವುದೇ ವೆಚ್ಚವಿಲ್ಲ
• ಬದಲಾವಣೆಯ ಸಂಪೂರ್ಣ "ಸ್ಫೋಟ ವ್ಯಾಪ್ತಿ" ಅನ್ನು ಪತ್ತೆಹಚ್ಚಬಹುದು, ಅಂದರೆ ನೀವು ಸಂಪಾದಿಸಲಿರುವ ಕೋಡ್ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುವ ಎಲ್ಲವನ್ನೂ
• ನಿಮ್ಮ ಇತರ ಯೋಜನೆಗಳ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಮುಟ್ಟದೆ ಒಂದೇ ಯೋಜನೆಗೆ ಸೀಮಿತಗೊಳಿಸಬಹುದು
• ರಚಿತ ಡೇಟಾವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವರ್ಷನ್ ಕಂಟ್ರೋಲ್‌ನಿಂದ ಹೊರಗಿಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಹಂಚಿಕೆಯ ರೆಪೊಸಿಟರಿಯನ್ನು ಅಸ್ತವ್ಯಸ್ತಗೊಳಿಸುವುದಿಲ್ಲ
• ಒಂದೇ ಯೋಜನೆಯಲ್ಲಿ ಅನೇಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಅನಾನುಕೂಲಗಳು

• ಪ್ರತಿ ಸಂದೇಶದಲ್ಲೂ ಚಲಿಸುವ ಹುಕ್ ಅನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ, ಕೋಡ್‌ಗೆ ಸಂಬಂಧಿಸದ ಸಂಭಾಷಣೆಗಳಲ್ಲಿ ಶಬ್ದಮಯವಾಗಿ ಅನಿಸಬಹುದು
• ಅತ್ಯಂತ ಹೊಸ ಸಾಫ್ಟ್‌ವೇರ್, ಇದುವರೆಗೆ ಕಡಿಮೆ ಟ್ರ್ಯಾಕ್ ರೆಕಾರ್ಡ್ ಮಾತ್ರ ಇದೆ
• ಆಳವಾದ, AI-ಸಾರಾಂಶ ಪದರಕ್ಕೆ ಇನ್ನೂ ನಿಮ್ಮ ಸ್ವಂತ AI ಮಾಡೆಲ್ ಪ್ರವೇಶ ಅಗತ್ಯ ಮತ್ತು ಅದನ್ನು ಆನ್ ಮಾಡಿದರೆ ಹಣ ಖರ್ಚಾಗುತ್ತದೆ
• ಸೆಟಪ್ ನಿಮ್ಮ ಯೋಜನೆಯ ಹಲವಾರು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಮುಟ್ಟುತ್ತದೆ, ಆದ್ದರಿಂದ ಒಪ್ಪಿಕೊಳ್ಳುವ ಮೊದಲು ಏನು ಬರೆಯಲಾಗಿದೆ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುವುದು ಒಳ್ಳೆಯದು

ಎಚ್ಚರಿಕೆ

ಈ ಲೇಖನವು ಶೈಕ್ಷಣಿಕ ಉದ್ದೇಶದ್ದಾಗಿದ್ದು, ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಸಾಧನದೊಂದಿಗೆ ಒಬ್ಬ ವ್ಯಕ್ತಿಯ ಪ್ರಾಯೋಗಿಕ ಅನುಭವವನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ಯಾವುದೇ ಆಜ್ಞೆಗಳು, ಸಂಖ್ಯೆಗಳು, ಅಥವಾ ಆವೃತ್ತಿ ವಿವರಗಳು ಸಾಧನವು ವಿಕಸನಗೊಂಡಂತೆ ಬದಲಾಗಬಹುದು, ಆದ್ದರಿಂದ ಅದನ್ನು ನೀವೇ ಸ್ಥಾಪಿಸುವ ಮೊದಲು ಸಾಧನದ ಸ್ವಂತ ಅಧಿಕೃತ ದಾಖಲೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ. ಹಂಚಿಕೆಯ ಯೋಜನೆಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿದರೆ, ಅದು ರಚಿಸಲು ಅಥವಾ ಮಾರ್ಪಡಿಸಲು ಪ್ರಸ್ತಾಪಿಸುವ ಪ್ರತಿ ಫೈಲ್ ಅನ್ನು ಮೊದಲು ಪರಿಶೀಲಿಸಿ, ಮತ್ತು ಬೇರೊಬ್ಬರಿಗೆ ಉತ್ತಮ ಅನುಭವ ಆಯಿತು ಎಂಬ ಕಾರಣಕ್ಕೆ ಹೊಸ ಡೆವಲಪರ್ ಸಾಧನ ಅಪಾಯ-ಮುಕ್ತ ಎಂದು ಎಂದಿಗೂ ಭಾವಿಸಬೇಡಿ.

ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

• Graft ಎಂದರೇನು? — ಇದು AI ಕೋಡಿಂಗ್ ಸಹಾಯಕಗಳು (ಮತ್ತು ಡೆವಲಪರ್‌ಗಳು) ಪ್ರತಿ ಬಾರಿ ಮೊದಲಿನಿಂದ ಪುನಃ ಅನ್ವೇಷಿಸದೆ ತ್ವರಿತವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕೋಡ್‌ಬೇಸ್‌ನ ಸ್ಥಳೀಯ, ಸಂಪರ್ಕಿತ ನಕ್ಷೆಯನ್ನು ನಿರ್ಮಿಸುವ ಸಾಧನ.
• ಇದು ಕೆಲಸ ಮಾಡಲು AI ಮಾಡೆಲ್ ಅಗತ್ಯವಿದೆಯೇ? — ಇಲ್ಲ. ಇದರ ಕೋರ್ ವೈಶಿಷ್ಟ್ಯ, ನಿಮ್ಮ ಕೋಡ್‌ನ ರಚನಾತ್ಮಕ ನಕ್ಷೆ, ಕೋಡ್-ಪಾರ್ಸಿಂಗ್ ತಂತ್ರವನ್ನು ಬಳಸಿ ಸಂಪೂರ್ಣವಾಗಿ ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಐಚ್ಛಿಕ ಆಳವಾದ ಪದರವು AI ಮಾಡೆಲ್ ಬಳಸುತ್ತದೆ, ಆದರೆ ಆ ಭಾಗ ಅಗತ್ಯವಿಲ್ಲ.
• ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಯೋಜನೆಯಲ್ಲಿ ಸ್ಥಾಪಿಸುವುದು ಸುರಕ್ಷಿತವೇ? — ಏನನ್ನಾದರೂ ಒಪ್ಪಿಕೊಳ್ಳುವ ಮೊದಲು ಅದು ಏನು ರಚಿಸುತ್ತದೆ ಅಥವಾ ಬದಲಾಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ಪೂರ್ವವೀಕ್ಷಣೆ ಮಾಡಬಹುದು, ಯಾವುದೇ ಹೊಸ ಡೆವಲಪರ್ ಸಾಧನವನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳುವ ಮೊದಲು ಇದು ಸಮಂಜಸ ಸುರಕ್ಷತಾ ಪರಿಶೀಲನೆ.
• ಒಂದೇ ಯೋಜನೆಯಲ್ಲಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆಯೇ? — ಹೌದು, ನನ್ನ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ಅದು ಒಂದೇ ಓಟದಲ್ಲಿ ಹಲವು ಭಾಷೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಪಾರ್ಸ್ ಮಾಡಿತು, ಕಂಪೈಲ್ಡ್ ಮೊಬೈಲ್ ಅಪ್ಲಿಕೇಶನ್ ಭಾಷೆ ಮತ್ತು ಹಲವಾರು ವೆಬ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಗಳು ಸೇರಿದಂತೆ.
• ಅದೇ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿರುವ ನನ್ನ ಇತರ ಯೋಜನೆಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆಯೇ? — ನೀವು ಅನುಮತಿಸಿದರೆ ಮಾತ್ರ. ಎಲ್ಲವನ್ನೂ ಒಂದೇ ಯೋಜನೆ ಫೋಲ್ಡರ್‌ಗೆ ಸೀಮಿತಗೊಳಿಸುವ ಸೆಟ್ಟಿಂಗ್ ಇದೆ.
• ಚಿಕ್ಕ, ಸರಳ ಯೋಜನೆಯಲ್ಲಿ ಬಳಸುವುದು ಯೋಗ್ಯವೇ? — ಬಹುಶಃ ಅಷ್ಟೊಂದಲ್ಲ. ಕೋಡ್‌ಬೇಸ್‌ನ ಗಾತ್ರ ಮತ್ತು ಅಸ್ತವ್ಯಸ್ತತೆ ಹೆಚ್ಚಿದಂತೆ ಪ್ರಯೋಜನ ಹೆಚ್ಚುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಸಾಕಷ್ಟು ಇತಿಹಾಸ ಸಂಗ್ರಹವಾದ ದೊಡ್ಡ ಫೈಲ್‌ಗಳು.
• ರಚಿತ ನಕ್ಷೆಯನ್ನು ವರ್ಷನ್ ಕಂಟ್ರೋಲ್‌ಗೆ ಕಮಿಟ್ ಮಾಡಬೇಕೇ? — ಇಲ್ಲ, ಅದನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪುನರ್ನಿರ್ಮಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವರ್ಷನ್ ಕಂಟ್ರೋಲ್‌ನಿಂದ ಹೊರಗಿಡಲಾಗುತ್ತದೆ.
• ಅತಿ ದೊಡ್ಡ ಅನನುಕೂಲ ಯಾವುದು? — ಪ್ರತಿ ಸಂದೇಶದಲ್ಲೂ ಪರಿಶೀಲಿಸುವ ಹುಕ್, ಕೋಡ್‌ಗೆ ಸಂಬಂಧಿಸದ ಸಂಭಾಷಣೆಗಳಲ್ಲಿ ಅನಗತ್ಯ ಮಾತಿನಂತೆ ಅನಿಸಬಹುದು.

ಟ್ಯಾಗ್‌ಗಳು

#ai #developertools #codingagents #productivity #softwareengineering #devtools #automation #codereview #techtools #programming