ಸಾಫ್ಟ್‌ವೇರ್ ತಂಡಗಳಿಗೆ ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆ: ವರ್ಕಿಂಗ್ ಮಾಡೆಲ್ ಮತ್ತು ಮಿತಿಗಳು

ಲಾಭಗಳು:

• ಕೋಡಿಂಗ್ ಸಹಾಯಕನು ಭಾಷಾ ಮಾದರಿಯಾಗಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಾನೆ ಮತ್ತು ಟೋಕನ್, ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ, ಭ್ರಮೆಯ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ವಿವರಿಸುವ ಸಾಮರ್ಥ್ಯ
• ಮಾನಸಿಕ ನಕ್ಷೆಯೊಂದಿಗೆ AI ಪ್ರಬಲ ಮತ್ತು ದುರ್ಬಲವಾಗಿರುವ ಸಾಫ್ಟ್‌ವೇರ್ ಕಾರ್ಯಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಸಾಮರ್ಥ್ಯ
• ತಮ್ಮ ಸ್ವಂತ ಕಾರ್ಯಗಳಿಗೆ ಪ್ರಸ್ತಾಪಿಸುವ-ಉತ್ಪಾದಿಸುವ-ಪರಿಶೀಲಿಸುವ ಮೂಲಭೂತ ಕೆಲಸದ ಚಕ್ರವನ್ನು ಅನ್ವಯಿಸುವ ಸಾಮರ್ಥ್ಯ

ಸಾಫ್ಟ್‌ವೇರ್ ಡೆವಲಪರ್‌ಗಳ ದಿನವನ್ನು "ಮೊದಲಿನಿಂದ ಕೋಡ್ ಬರೆಯಲು" ವಿರಳವಾಗಿ ಕಳೆಯಲಾಗುತ್ತದೆ. ನೈಜ ಸಮಯ; ಬೇರೊಬ್ಬರು ಬರೆದ ಕೋಡ್ ಅನ್ನು ಓದುವುದು, ದೋಷವನ್ನು ಪುನರುತ್ಪಾದಿಸಲು ಪ್ರಯತ್ನಿಸುವುದು, ಲಾಗ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವುದು (ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ರಚಿಸಲಾದ ಲಾಗ್ ಲೈನ್‌ಗಳು), ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದು, PR ಬರೆಯುವುದು (ಪುಲ್ ವಿನಂತಿ - ತಂಡದ ಪರಿಶೀಲನೆಗಾಗಿ ಕೋಡ್ ಬದಲಾವಣೆಯನ್ನು ಸಲ್ಲಿಸುವ ವಿಲೀನ ವಿನಂತಿ) ವಿವರಣೆ ಮತ್ತು ದಸ್ತಾವೇಜನ್ನು ನವೀಕರಿಸುವುದು. ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆ (AI) ಎಂಬುದು ವೇಗ ಗುಣಕವಾಗಿದ್ದು, ಇದು ಬಹುತೇಕ ಎಲ್ಲಾ ಕಾಣದ ಕೆಲಸಗಳನ್ನು ಸ್ಪರ್ಶಿಸಬಹುದು. ಆದರೆ ಅದನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಬಳಸುವ ಮೊದಲ ಷರತ್ತು ಅದು ಏನು ಮತ್ತು ಅದು ಏನಲ್ಲ ಎಂಬುದನ್ನು ಸರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು.

ಈ ಘಟಕದಲ್ಲಿ, ನಾವು ಮೊದಲು ಸರಳ ಭಾಷೆಯಲ್ಲಿ ಕೋಡಿಂಗ್ ಸಹಾಯಕನ ಆಧಾರವಾಗಿರುವ ತಂತ್ರಜ್ಞಾನವನ್ನು ವಿವರಿಸುತ್ತೇವೆ; ನಂತರ ನಾವು ಮಾದರಿಯ ಸಾಮರ್ಥ್ಯ ಮತ್ತು ದೌರ್ಬಲ್ಯಗಳ ಮಾನಸಿಕ ನಕ್ಷೆಯನ್ನು ರಚಿಸುತ್ತೇವೆ; ಅಂತಿಮವಾಗಿ, ನಾವು ಸಂಪೂರ್ಣ ಮಾಡ್ಯೂಲ್‌ನಾದ್ಯಂತ ಬಳಸುವ ಮೂಲಭೂತ ಕೆಲಸದ ಶಿಸ್ತನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ: ಪ್ರಸ್ತಾಪಿಸಿ, ಉತ್ಪಾದಿಸಿ, ಪರಿಶೀಲಿಸಿ. ಈ ಮೂರು ಹಂತಗಳು ಮುಂದಿನ ಹನ್ನೊಂದು ಘಟಕಗಳ ಬೆನ್ನೆಲುಬು.

ಗಮನಿಸಿ: ಈ ಮಾಡ್ಯೂಲ್ ಸಾಮಾನ್ಯ ತರಬೇತಿಯಾಗಿದೆ. ಭದ್ರತೆ-ನಿರ್ಣಾಯಕ ಸಾಫ್ಟ್‌ವೇರ್‌ನಲ್ಲಿ (ಪಾವತಿ ಪ್ರಕ್ರಿಯೆ, ಆರೋಗ್ಯ ರಕ್ಷಣೆ, ದೃಢೀಕರಣ, ನಿರ್ಣಾಯಕ ಮೂಲಸೌಕರ್ಯ) AI ಔಟ್‌ಪುಟ್ ಅರ್ಹ ಇಂಜಿನಿಯರ್‌ನಿಂದ ಪರಿಶೀಲನೆ ಮತ್ತು ಅನುಮೋದನೆಗೆ ಪರ್ಯಾಯವಾಗಿರುವುದಿಲ್ಲ. AI ಸಹಾಯಕ; ಸಹಿ ಮಾಡಿದವರು ಇಂಜಿನಿಯರ್.

ಕೋಡಿಂಗ್ ಸಹಾಯಕ ನಿಜವಾಗಿ ಏನು ಮಾಡುತ್ತಾನೆ?

ಹೆಚ್ಚಿನ ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್‌ಗಳನ್ನು ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಯಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿದೆ (ಎಲ್‌ಎಲ್‌ಎಂ-ಬೃಹತ್ ಪ್ರಮಾಣದ ಪಠ್ಯ ಮತ್ತು ಕೋಡ್‌ನ ಮೇಲೆ ತರಬೇತಿ ಪಡೆದ AI ಮುಂದಿನ "ಚಂಕ್" ಅನ್ನು ಊಹಿಸುತ್ತದೆ). ಮಾದರಿಯು ಮಾನವನಂತೆ ಕೋಡ್ ಅನ್ನು "ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ"; ಇದು ಉದಾಹರಣೆಗಳ ದೊಡ್ಡ ಪೂಲ್‌ನಿಂದ ಕಲಿಯುವ ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ನೀವು ನೀಡುವ ಸಂದರ್ಭದ ಬಹುಪಾಲು ಮುಂದುವರಿಕೆಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಈ ತೋರಿಕೆಯಲ್ಲಿ ಸರಳವಾದ ಕಾರ್ಯವಿಧಾನವು ಆಚರಣೆಯಲ್ಲಿ ಆಶ್ಚರ್ಯಕರವಾದ ಪ್ರವೀಣ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತದೆ - ಏಕೆಂದರೆ ಹೆಚ್ಚಿನ ಸಾಫ್ಟ್‌ವೇರ್ ಪುನರಾವರ್ತಿತ ಮಾದರಿಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ: HTTP ವಿನಂತಿ, ಲೂಪ್, ಶೂನ್ಯ ಪರಿಶೀಲನೆ, ಪರೀಕ್ಷಾ ಮಾದರಿ.

ಇಲ್ಲಿ ಮೂರು ಪದಗಳು ನಿರ್ಣಾಯಕವಾಗಿವೆ. ಟೋಕನ್ ಮಾದರಿಯು ಪಠ್ಯವನ್ನು ವಿಭಜಿಸುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಚಿಕ್ಕ ಘಟಕವಾಗಿದೆ; ಇದು ಸರಿಸುಮಾರು ಕೆಲವು ಅಕ್ಷರಗಳು ಅಥವಾ ಪದದ ಭಾಗವಾಗಿದೆ. ಸಂದರ್ಭ ವಿಂಡೋವು ಮಾದರಿಯು ಏಕಕಾಲದಲ್ಲಿ "ನೋಡಬಹುದಾದ" ಟೋಕನ್‌ಗಳ ಪ್ರಮಾಣವಾಗಿದೆ; ನಿಮ್ಮ ಕೋಡ್, ದೋಷ ಸಂದೇಶ ಮತ್ತು ಸೂಚನೆಯು ಈ ವಿಂಡೋದಲ್ಲಿ ಸರಿಹೊಂದಬೇಕು. ಪ್ರಾಂಪ್ಟ್ ಎಂದರೆ ನೀವು ಮಾದರಿಗೆ ನೀಡುವ ಎಲ್ಲಾ ಸೂಚನೆಗಳು ಮತ್ತು ಸಂದರ್ಭ. ನೀವು ಪಡೆಯುವ ಔಟ್‌ಪುಟ್‌ನ ಗುಣಮಟ್ಟವು ಈ ಎರಡರ ಮೇಲೆ ನೇರವಾಗಿ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ: ನೀವು ಮಾದರಿಯನ್ನು ನೀಡುವ ಉತ್ತಮ ಸಂದರ್ಭ ಮತ್ತು ಸ್ಪಷ್ಟವಾದ ಸೂಚನೆಗಳು, ನೀವು ಉತ್ತಮ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೀರಿ. ಕೆಟ್ಟ ಇನ್‌ಪುಟ್ ಕೆಟ್ಟ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಅದು ಸ್ಮಾರ್ಟ್ ಮಾದರಿಯಾಗಿದ್ದರೂ ಸಹ - ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಕ್ಲಾಸಿಕ್ “ಗಾರ್ಬೇಜ್ ಇನ್, ಗಾರ್ಬೇಜ್ ಔಟ್” ನಿಯಮವು AI ಗೆ ಸಹ ಅನ್ವಯಿಸುತ್ತದೆ.

ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತು ದೌರ್ಬಲ್ಯಗಳ ನಕ್ಷೆ

AI ಅನ್ನು ಸರಿಯಾದ ಉದ್ಯೋಗಗಳಿಗೆ ನಿರ್ದೇಶಿಸಲು, ಅದು ಎಲ್ಲಿ ಹೊಳೆಯುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಿ ಎಡವುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ. ಈ ನಕ್ಷೆಯನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದರಿಂದ ಪ್ರತಿ ಮುಂದಿನ ಮಿಷನ್‌ನೊಂದಿಗೆ ನೀವು ಆಶ್ಚರ್ಯಚಕಿತರಾಗುವಂತೆ ಮಾಡುತ್ತದೆ, "ನಾನು ಈ ಕೆಲಸವನ್ನು AI ಗೆ ಹೊರಗುತ್ತಿಗೆ ನೀಡಬೇಕೇ ಅಥವಾ ಅದನ್ನು ನಾನೇ ಮಾಡಬೇಕೇ?" ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

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

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

ಮಿಷನ್ ಪ್ರಕಾರ

AI ನ ಪಾತ್ರ

ಮನುಷ್ಯನ ಪಾತ್ರ

ಬಾಯ್ಲರ್ / ಅಸ್ಥಿಪಂಜರವನ್ನು ಉತ್ಪಾದಿಸಿ

ಡ್ರಾಫ್ಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ

ಹೊಂದಾಣಿಕೆಗಳು, ವಿಮರ್ಶೆಗಳು

ಕೋಡ್ ವಿವರಣೆ

ತ್ವರಿತ ಸಾರಾಂಶವನ್ನು ನೀಡುತ್ತದೆ

ಕೋಡ್‌ನಲ್ಲಿ ನಿರ್ಣಾಯಕ ಭಾಗವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ

ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವುದು

ಪ್ರಕರಣವು ಸೂಚಿಸುತ್ತದೆ

ವ್ಯಾಪ್ತಿ ಮತ್ತು ನಿಖರತೆಯನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ

ಭದ್ರತೆ-ನಿರ್ಣಾಯಕ ತರ್ಕ

ಸಹಾಯಕ ಕಲ್ಪನೆ

ನಿರ್ಧಾರ ಮತ್ತು ಜವಾಬ್ದಾರಿ ಸಂಪೂರ್ಣವಾಗಿ ಮನುಷ್ಯರ ಮೇಲಿದೆ.

API/ಲೈಬ್ರರಿ ಬಳಕೆ

ಮಾದರಿಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ

ಅಸ್ತಿತ್ವ ಮತ್ತು ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ

ವಾಸ್ತುಶಿಲ್ಪದ ನಿರ್ಧಾರ

ಆಯ್ಕೆಗಳ ವಿಧಗಳು

ಸಂದರ್ಭವನ್ನು ತಿಳಿದುಕೊಂಡು ಆಯ್ಕೆಮಾಡುತ್ತದೆ ಮತ್ತು ಸಮರ್ಥಿಸುತ್ತದೆ

ಹಂತ ಹಂತವಾಗಿ: ಬೇಸಿಕ್ ವರ್ಕಿಂಗ್ ಸೈಕಲ್

1. ಕಾರ್ಯವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಿ. ನಿಮಗೆ ಬೇಕಾದುದನ್ನು ಒಂದೇ ವಾಕ್ಯದಲ್ಲಿ ಬರೆಯಲು ನಿಮಗೆ ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ಮಾದರಿಯೂ ಸಾಧ್ಯವಿಲ್ಲ. ಮುಂಚಿನ ಅನಿಶ್ಚಿತತೆಯು ಇನ್‌ಪುಟ್‌ನಲ್ಲಿ ಹರಿಯುತ್ತದೆ, ಅದು ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ಹೆಚ್ಚಾಗುತ್ತದೆ.
2. ಸಂದರ್ಭವನ್ನು ನೀಡಿ. ಪ್ರಾಂಪ್ಟ್‌ಗೆ ಸಂಬಂಧಿತ ಕೋಡ್, ಪೂರ್ಣ ದೋಷ ಸಂದೇಶ, ಭಾಷೆ/ಫ್ರೇಮ್‌ವರ್ಕ್ ಆವೃತ್ತಿ ಮತ್ತು ನಿರ್ಬಂಧಗಳನ್ನು ಸೇರಿಸಿ. "ಇದನ್ನು ಸರಿಪಡಿಸಿ" ಎಂದು ಹೇಳಬೇಡಿ, "ಪೈಥಾನ್ 3.11, FastAPI 0.110; ಈ ಕಾರ್ಯವು 500 ದೋಷವನ್ನು ನೀಡುತ್ತದೆ, ವಿನಂತಿಯ ದೇಹವು ಖಾಲಿಯಾದಾಗ ಅದು ಸ್ಫೋಟಗೊಳ್ಳುತ್ತದೆ".
3. ಹೇರುವ ಪಾತ್ರ ಮತ್ತು ಸ್ವರೂಪ. "ನೀವು ಹಿರಿಯ ಗೋ ಡೆವಲಪರ್ ಆಗಿದ್ದೀರಿ; ಕೇವಲ ಕೋಡ್ ಮತ್ತು ಎರಡು-ವಾಕ್ಯದ ತಾರ್ಕಿಕತೆಯನ್ನು ನೀಡಿ" ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ.
4. ಸಣ್ಣದನ್ನು ಕೇಳಿ. ಒಂದು ದೈತ್ಯ ವಿನಂತಿಗಿಂತ ಅದನ್ನು ಹಂತಗಳಾಗಿ ವಿಭಜಿಸಿ; ಪ್ರತಿ ಹಂತವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರಿಶೀಲಿಸಿ. ಪ್ರಮುಖ ಬದಲಾವಣೆಗಳು ಅಪಾಯಕಾರಿ ಏಕೆಂದರೆ ಅವುಗಳು ಪರಿಶೀಲಿಸಲು ಕಷ್ಟ ಮತ್ತು ದೋಷಗಳನ್ನು ಮರೆಮಾಡಲು ಗುರಿಯಾಗುತ್ತವೆ.
5. ಪರಿಶೀಲಿಸಿ. ಅದನ್ನು ಚಲಾಯಿಸಿ, ಪರೀಕ್ಷಿಸಿ, ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಓದಿ. ಪರಿಶೀಲಿಸದ AI ಕೋಡ್ "ಸ್ಕೆಚ್" ಆಗಿದೆ, "ಪರಿಹಾರ" ಅಲ್ಲ. ಇದು ಚಕ್ರದ ಅತ್ಯಂತ ನೆಗೋಶಬಲ್ ಅಲ್ಲದ ಹಂತವಾಗಿದೆ.

ಮೂರು ಮಿನಿ ಪ್ರಕರಣಗಳು

ಪ್ರಕರಣ 1 - ಸಮಯ ಉಳಿತಾಯವು ನಿಜ ಆದರೆ ಸಾಧಾರಣವಾಗಿದೆ. ಒಂದು ತಂಡವು AI ಯೊಂದಿಗೆ ಹೊಸ CRUD (ರಚಿಸಿ-ಓದಿ-ಅಪ್‌ಡೇಟ್-ಅಳಿಸಿ) ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಅಸ್ಥಿಪಂಜರಗೊಳಿಸಿದಾಗ, ಮೊದಲ ಡ್ರಾಫ್ಟ್ ಸಮಯವು ಸರಿಸುಮಾರು 40 ನಿಮಿಷಗಳಿಂದ 8 ನಿಮಿಷಗಳಿಗೆ ಇಳಿಯಿತು. ಆದಾಗ್ಯೂ, ಪರಿಶೀಲನೆ ಮತ್ತು ಪರೀಕ್ಷೆಯೊಂದಿಗೆ, ಒಟ್ಟು ಸಮಯ 25 ನಿಮಿಷಗಳು; ಆದ್ದರಿಂದ ನಿಜವಾದ ಲಾಭವು 40 ರಿಂದ 25 ರಷ್ಟಿದೆ, ಸುಮಾರು 38%. "ನಾವು 10 ಪಟ್ಟು ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಿದ್ದೇವೆ" ಎಂಬ ನಿರೀಕ್ಷೆಯ ಬದಲಿಗೆ ಈ ದರವನ್ನು ಅಳೆಯಲಾಗುತ್ತದೆ, ಇದು ಸಮರ್ಥನೀಯ ಲಾಭವಾಗಿದೆ.

ಪ್ರಕರಣ 2 - ಭ್ರಮೆಯು ದುಬಾರಿಯಾಗಿದೆ. ದೃಢೀಕರಣವಿಲ್ಲದೆಯೇ ಡೆವಲಪರ್ AI- ಸೂಚಿಸಿದ ವಿನಂತಿಗಳನ್ನು ಬಳಸಿದ್ದಾರೆ.get_json() ಕರೆ; ಅಂತಹ ಯಾವುದೇ ವಿಧಾನ ಇರಲಿಲ್ಲ (ನಿಖರವಾಗಿ response.json()). ಕೋಡ್ ಕಂಪೈಲ್ ಮಾಡದಿದ್ದಾಗ 20 ನಿಮಿಷಗಳು ಕಳೆದುಹೋಗಿವೆ. ಸರಳವಾದ "ಈ ವಿಧಾನವು ನಿಜವಾಗಿಯೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ?" ಪರಿಶೀಲನೆಯು ನಷ್ಟವನ್ನು ಮರುಹೊಂದಿಸುತ್ತದೆ.

ಪ್ರಕರಣ 3 - ಉತ್ತಮ ಸಂದರ್ಭವು ಔಟ್‌ಪುಟ್ ಅನ್ನು ದ್ವಿಗುಣಗೊಳಿಸುತ್ತದೆ. ಅದೇ ದೋಷಕ್ಕಾಗಿ, ಒಬ್ಬ ಡೆವಲಪರ್ ಸರಳವಾಗಿ "ನಾನು ದೋಷವನ್ನು ಪಡೆಯುತ್ತಿದ್ದೇನೆ" ಎಂದು ಬರೆದರು ಮತ್ತು ಇನ್ನೊಬ್ಬರು ಪೂರ್ಣ ಸ್ಟಾಕ್ ಟ್ರೇಸ್, ಆವೃತ್ತಿ ಮತ್ತು ಇನ್‌ಪುಟ್ ಮಾದರಿಯನ್ನು ಸೇರಿಸಿದ್ದಾರೆ. ಎರಡನೆಯದು ಮೊದಲ ಪ್ರಯತ್ನದಲ್ಲಿ ಸರಿಯಾದ ಪರಿಹಾರವನ್ನು ಪಡೆದುಕೊಂಡಿತು; ಮೊದಲನೆಯದು ಮೂರು ತಿರುವುಗಳನ್ನು ಕಳೆದಿದೆ. ವ್ಯತ್ಯಾಸವು ಮಾದರಿಯಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ ಇನ್ಪುಟ್ನಲ್ಲಿದೆ.

ನಾಲ್ಕು ನಕಲು ಮಾಡಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್‌ಗಳು

ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ, ಶಕ್ತಿಯುತ ಆರಂಭಿಕ ಪ್ರಾಂಪ್ಟ್:

ಪಾತ್ರ: ನೀವು ಅನುಭವಿ {{ಭಾಷೆ}} ಡೆವಲಪರ್. ಕಾರ್ಯ: {{what_want}}ಸಂದರ್ಭ:- ಚೌಕಟ್ಟು/ಆವೃತ್ತಿ: {{framework_and_version}}- ನಿರ್ಬಂಧಗಳು: {{ಕಾರ್ಯನಿರ್ವಹಣೆ, ಶೈಲಿ, ಅವಲಂಬನೆ ನಿಯಮಗಳು}}ನಿಯಮಗಳು:- ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಗ್ರಂಥಾಲಯ/ಕಾರ್ಯವನ್ನು ಬಳಸಬೇಡಿ; ನಿಮಗೆ ಖಚಿತವಿಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು "ಪರಿಶೀಲಿಸು" ಎಂದು ಗುರುತಿಸಿ. - ಮೊದಲು, ಒಂದು ಸಣ್ಣ ಯೋಜನೆಯನ್ನು ನೀಡಿ, ನಂತರ ಕೋಡ್, ನಂತರ ಸಮರ್ಥನೆಯ 2 ವಾಕ್ಯಗಳನ್ನು ನೀಡಿ. - ಪರೀಕ್ಷಿಸಬಹುದಾದ, ವರ್ಕಿಂಗ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಿ.

ಅನಿಶ್ಚಿತತೆಯನ್ನು ಮತ್ತೆ ಮಾದರಿಗೆ ಫಿಲ್ಟರ್ ಮಾಡಲು:

ಕೆಳಗಿನ ಕಾರ್ಯವನ್ನು ಪರಿಹರಿಸುವ ಮೊದಲು, ನೀವು ಕಾಣೆಯಾಗಿರುವ ಅಥವಾ ಅಸ್ಪಷ್ಟವಾಗಿರುವ ಪ್ರಶ್ನೆಗಳಂತೆ ಕನಿಷ್ಠ 3 ಅಂಕಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ. ನಾನು ಉತ್ತರಿಸುವ ಮೊದಲು ಕೋಡ್ ಬರೆಯಬೇಡಿ. ಕಾರ್ಯ: {{task}}

ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ವಯಂ-ಪರಿಶೀಲಿಸಲು:

ನೀವು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ತಯಾರಿಸಿದ್ದೀರಿ. ಈಗ ನಿಮ್ಮ ಪಾತ್ರವನ್ನು ಬದಲಾಯಿಸಿ ಮತ್ತು ಈ ಕೋಡ್ ಅನ್ನು ಟೀಕಿಸಿ:- ಕೆಲಸ ಮಾಡದಿರುವ 3 ಪ್ರಕರಣಗಳನ್ನು (ಎಡ್ಜ್ ಕೇಸ್‌ಗಳು) ಪಟ್ಟಿ ಮಾಡಿ.- ನೀವು ಮಾಡಬಹುದಾದ ಯಾವುದೇ APIಗಳು/ಕಾರ್ಯಗಳು ಇವೆಯೇ? ಗುರುತಿಸಿ.- ಸರಿಪಡಿಸಿದ ಆವೃತ್ತಿಯನ್ನು ನೀಡಿ.ಕೋಡ್:{{code}}

ನಿರ್ಧಾರವನ್ನು ಆಯ್ಕೆಗಳಾಗಿ ವಿಭಜಿಸಲು:

{{ಸಮಸ್ಯೆ}}ಗೆ 2-3 ಪರಿಹಾರ ವಿಧಾನಗಳನ್ನು ಸೂಚಿಸಿ. ಪ್ರತಿಯೊಂದಕ್ಕೂ: ಚಿಕ್ಕ ವಿವರಣೆ, ಪ್ಲಸ್/ಮೈನಸ್, ಯಾವಾಗ ಆಯ್ಕೆ ಮಾಡಬೇಕು. ಕೋಷ್ಟಕ ರೂಪದಲ್ಲಿ ನೀಡಿ. ನನಗಾಗಿ ಆರಿಸಿಕೊಳ್ಳಬೇಡ; ಕೇವಲ ಆಯ್ಕೆಯನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಿ.

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್

ದುರ್ಬಲ: "ಈ ಕೋಡ್‌ನಲ್ಲಿ ದೋಷವನ್ನು ಸರಿಪಡಿಸಿ." (ಯಾವ ದೋಷ? ಯಾವ ಭಾಷೆ? ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ ಏನು?)

ಪ್ರಬಲ: "Python 3.11 / FastAPI 0.110. ವಿನಂತಿಯ ಭಾಗವು ಖಾಲಿಯಾದಾಗ ಕೆಳಗಿನ ಎಂಡ್‌ಪಾಯಿಂಟ್ 500 ಅನ್ನು KeyError ನೊಂದಿಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಖಾಲಿ ದೇಹದಲ್ಲಿ 400 ಮತ್ತು ಅರ್ಥಪೂರ್ಣ ಸಂದೇಶವನ್ನು ಹಿಂತಿರುಗಿಸಲು ನಾನು ಬಯಸುತ್ತೇನೆ. ಮೊದಲು ಕಾರಣವನ್ನು ವಿವರಿಸಿ, ನಂತರ ಸರಿಪಡಿಸಿದ ಕಾರ್ಯವನ್ನು ನೀಡಿ, ನಂತರ ಈ ಸನ್ನಿವೇಶಕ್ಕಾಗಿ ಪರೀಕ್ಷೆಯನ್ನು ಬರೆಯಿರಿ. [ಕೋಡ್]"

ಶಕ್ತಿಯುತ ಆವೃತ್ತಿ; ಇದು ಭಾಷೆ, ಆವೃತ್ತಿ, ನಿಜವಾದ ದೋಷ, ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಸ್ವರೂಪವನ್ನು ನೀಡುತ್ತದೆ. ಮಾದರಿಯು ಇನ್ನು ಮುಂದೆ ಊಹಿಸಬೇಕಾಗಿಲ್ಲ.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• ಪರಿಶೀಲನೆ ಇಲ್ಲದೆ ನಂಬಿಕೆ. ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಮತ್ತು ಅತ್ಯಂತ ದುಬಾರಿ ತಪ್ಪು. ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವವರೆಗೆ ಮತ್ತು ಪರೀಕ್ಷಿಸುವವರೆಗೆ "ಪರಿಹರಿಸಲಾಗಿದೆ" ಎಂದು ಹೇಳಬೇಡಿ.
• ಸಂದರ್ಭವಿಲ್ಲದೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುವುದು. ಆವೃತ್ತಿ, ದೋಷ ಪಠ್ಯ ಮತ್ತು ನಿರ್ಬಂಧಗಳಿಲ್ಲದ ಉತ್ತರವು ಸಾಮಾನ್ಯ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ತಪ್ಪಾಗಿದೆ.
• ಒಂದು ದೊಡ್ಡ ವಿನಂತಿ. 300-ಸಾಲಿನ ಉತ್ಪಾದನೆಯನ್ನು ಒಮ್ಮೆಗೆ ವಿನಂತಿಸಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗದಿರುವುದು ತಪ್ಪುಗಳನ್ನು ಅಗೋಚರಗೊಳಿಸುತ್ತದೆ.
• ಮಾದರಿಯ ಆತ್ಮ ವಿಶ್ವಾಸವನ್ನು ಪುರಾವೆಯಾಗಿ ತಪ್ಪಾಗಿ ಗ್ರಹಿಸುವುದು. AI ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ಏನಾದರೂ ತಪ್ಪು ಹೇಳಬಹುದು; ಟೋನ್ ನಿಖರತೆಯ ಸೂಚಕವಲ್ಲ.
• ಕಂಪನಿಯ ರಹಸ್ಯವನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಅಂಟಿಸುವುದು. ಖಾಸಗಿ ಕೀಗಳು, ಗ್ರಾಹಕರ ಡೇಟಾ ಅಥವಾ ಖಾಸಗಿ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಅನುಮೋದಿಸದ ಪರಿಕರಗಳಲ್ಲಿ ನಮೂದಿಸಬಾರದು (ನಾವು ಈ ವಿಷಯವನ್ನು ಘಟಕ 10 ರಲ್ಲಿ ಪರಿಶೀಲಿಸುತ್ತೇವೆ).

ಸಲಹೆ: ಪ್ರತಿ AI ಔಟ್‌ಪುಟ್ ಅನ್ನು "ಇದು ಡ್ರಾಫ್ಟ್" ಎಂದು ಪರಿಗಣಿಸಿ. ಈ ಏಕೈಕ ಮಾನಸಿಕ ಅಭ್ಯಾಸವು ಮಾಡ್ಯೂಲ್‌ನಾದ್ಯಂತ ನೀವು ನೋಡುವ ಹೆಚ್ಚಿನ ಅಪಾಯಗಳನ್ನು ನಂದಿಸುತ್ತದೆ.

ಸಾರಾಂಶದಲ್ಲಿ

ಕೋಡಿಂಗ್ ಅಸಿಸ್ಟೆಂಟ್ ಒಂದು ಭಾಷಾ ಮಾದರಿಯಾಗಿದ್ದು ಅದು ಮುಂದಿನ ಬಹುಪಾಲು ತುಣುಕನ್ನು ಊಹಿಸುತ್ತದೆ; ಇದು ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ, ಇದು ಮಾದರಿಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ಅವರು ಪುನರಾವರ್ತಿತ, ಸೂತ್ರದ ಕೆಲಸಗಳಲ್ಲಿ ಪ್ರಬಲರಾಗಿದ್ದಾರೆ; ನಿಮ್ಮ ಸಂದರ್ಭಕ್ಕೆ ನಿರ್ದಿಷ್ಟವಾದ ಪರಿಶೀಲನೆಯ ಅಗತ್ಯವಿರುವ ಕೆಲಸಕ್ಕಾಗಿ ಇದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಬೇಕು. ದೊಡ್ಡ ಅಪಾಯವೆಂದರೆ ಭ್ರಮೆ, ಮತ್ತು ಕೇವಲ ಪ್ರತಿವಿಷವೆಂದರೆ ಪರಿಶೀಲನೆ. ಸಂಪೂರ್ಣ ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ ನಾವು ಅನುಸರಿಸುವ ಶಿಸ್ತು ಸ್ಪಷ್ಟವಾಗಿದೆ: ಕಾರ್ಯವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಿ, ಸಂದರ್ಭವನ್ನು ನೀಡಿ, ಸಣ್ಣದನ್ನು ಕೇಳಿ, ಪ್ರತಿ ವಿತರಣೆಯನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ.

ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ

ಕಳೆದ ವಾರದಲ್ಲಿ ನೀವು ಮಾಡಿದ ಮೂರು ಸಾಫ್ಟ್‌ವೇರ್ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಿರಿ (ಉದಾ. ದೋಷ ಪರಿಹಾರ, ಪರೀಕ್ಷೆ, README ಅಪ್‌ಡೇಟ್). ಪ್ರತಿಯೊಂದಕ್ಕೂ "ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತು ದೌರ್ಬಲ್ಯಗಳ ನಕ್ಷೆ" ಅನ್ನು ನೋಡಿ ಮತ್ತು AI ಇದನ್ನು ಮಾಡಿದ್ದರೆ ನಿಮ್ಮ ಮತ್ತು AI ನ ಪಾತ್ರ ಏನೆಂದು ಒಂದೇ ವಾಕ್ಯದಲ್ಲಿ ವಿವರಿಸಿ. ನಂತರ ಮೇಲಿನ "ಪ್ರಾಂಪ್ಟ್" ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ AI ಗೆ ಈ ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ನೀಡಿ ಮತ್ತು ಔಟ್‌ಪುಟ್ ಅನ್ನು ರನ್ ಮಾಡಿ ಮತ್ತು ಪರಿಶೀಲಿಸಿ; ನೀವು ಎಷ್ಟು ನಿಮಿಷಗಳನ್ನು ಉಳಿಸಿದ್ದೀರಿ ಮತ್ತು ಎಷ್ಟು ತಪ್ಪುಗಳನ್ನು ಸರಿಪಡಿಸಬೇಕು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

ಪರಿಶೀಲನಾಪಟ್ಟಿ

• [ ] LLM ಮಾದರಿಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, ಕೋಡ್ ಅನ್ನು "ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ" ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ.
• [ ] ನಾನು ಟೋಕನ್, ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಮತ್ತು ಪ್ರಾಂಪ್ಟ್ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ವಿವರಿಸಬಲ್ಲೆ.
• AI ಪ್ರಬಲ ಮತ್ತು ದುರ್ಬಲವಾಗಿರುವ ಕಾರ್ಯಗಳ ಪ್ರಕಾರಗಳ ನಡುವೆ ನಾನು ಪ್ರತ್ಯೇಕಿಸಬಲ್ಲೆ.
• [ ] ಭ್ರಮೆ ಎಂದರೇನು ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ ಮತ್ತು ಪರಿಶೀಲನೆ ಮಾತ್ರ ಪ್ರತಿವಿಷವಾಗಿದೆ.
• [ ] ನಾನು "ಪ್ರಸ್ತಾಪಿಸು, ಉತ್ಪಾದಿಸು, ಪರಿಶೀಲಿಸು" ಚಕ್ರವನ್ನು ನನ್ನ ಸ್ವಂತ ಕಾರ್ಯಕ್ಕೆ ಅಳವಡಿಸಿಕೊಂಡಿದ್ದೇನೆ.
• [ ] ನಾನು ಕಾಂಕ್ರೀಟ್ ಉದಾಹರಣೆಯಲ್ಲಿ ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್ ಮತ್ತು ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ತೋರಿಸಬಹುದು.