ಗುರಿ ಓದುಗರು: AI ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪರಿಕರಗಳನ್ನು (ಉದಾಹರಣೆಗೆ ಕರ್ಸರ್, ವಿಂಡ್‌ಸರ್ಫ್, ಟ್ರೇ...) ಬಳಸುತ್ತಿರುವ ಡೆವಲಪರ್‌ಗಳು ಮತ್ತು AI ವೆಚ್ಚಗಳ ಬಗ್ಗೆ ಅರಿವಿಲ್ಲದ ತಾಂತ್ರಿಕ ವ್ಯವಸ್ಥಾಪಕರು.

ಪ್ರಮುಖ ಅಂಶ: ಟೋಕನ್ ಕೇವಲ ಬಿಲ್ಲಿಂಗ್ ಘಟಕವಲ್ಲ, ಆದರೆ ಒಂದು ರೀತಿಯ "ಗಮನ ಸಂಪನ್ಮೂಲ" ಮತ್ತು "ಕಂಪ್ಯೂಟಿಂಗ್ ಪವರ್ ಕರೆನ್ಸಿ". ಏಜೆಂಟ್ ಮೋಡ್ ಅನ್ನು ದುರುಪಯೋಗಪಡಿಸಿಕೊಳ್ಳುವುದು ಮತ್ತು ಸಂದರ್ಭ ನಿರ್ವಹಣೆಯನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದು, ವಾಸ್ತವವಾಗಿ ಯುದ್ಧತಂತ್ರದ ಪರಿಶ್ರಮವನ್ನು (AI ಅನ್ನು ಕುರುಡಾಗಿ ಎಸೆಯಲು ಬಿಡುವುದು) ಕಾರ್ಯತಂತ್ರದ ಸೋಮಾರಿತನವನ್ನು (ಸ್ವತಃ ಯೋಚಿಸದಿರುವುದು) ಮರೆಮಾಚುತ್ತಿದೆ.

ನಿಮ್ಮ "AI ಖರ್ಚು" ನಿಮ್ಮ ಸಂಬಳಕ್ಕಿಂತ ಹೆಚ್ಚಿರಬಹುದು

ಕೆಲವು ದಿನಗಳ ಹಿಂದೆ, ನಾನು ನನ್ನ ಟೋಕನ್ ಬಿಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿದೆ. ಆ ಸಂಖ್ಯೆಯನ್ನು ನೋಡಿದಾಗ, ನನಗೆ ಸ್ವಲ್ಪ ಆಶ್ಚರ್ಯವಾಯಿತು: 10 ಮಿಲಿಯನ್ ಟೋಕನ್‌ಗಳು. ಗಮನಿಸಿ, ಇದು ಒಂದು ತಿಂಗಳ ಬಳಕೆಯಲ್ಲ, ಇದು ಒಂದು ದಿನ.

ನಾನು ಇದು ತುಂಬಾ ವಿಚಿತ್ರವೆಂದು ಭಾವಿಸಿದೆ. ನಂತರ ನಾನು ಟೋಕನ್ ಲೆಕ್ಕಾಚಾರಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಕಿರು ವೀಡಿಯೊವನ್ನು ಪೋಸ್ಟ್ ಮಾಡಿದೆ.

ಪರಿಣಾಮವಾಗಿ, ಕಾಮೆಂಟ್ ವಿಭಾಗವು ನನಗೆ "ಆಕಾಶದ ಮೇಲೆ ಆಕಾಶವಿದೆ" ಎಂಬುದನ್ನು ತೋರಿಸಿತು.

ಕೆಳಗಿನ ಚಿತ್ರವು ಬಳಕೆದಾರ "ಓಲ್ಡ್ ಕೆ ಅವರ ದಿನಚರಿ" ಯಿಂದ ಒಂದು ದಿನದ ಎರಡು ಕೋಟಿ ಟೋಕನ್ ಬಳಕೆಯ ದಾಖಲೆಯ ಸ್ಕ್ರೀನ್‌ಶಾಟ್ ಆಗಿದೆ:

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

ಒಂದು ಕೋಟಿ ಟೋಕನ್‌ಗಳು ಎಂದರೆ ಏನು? "ಕೆಲವು ಮುಖ್ಯವಾಹಿನಿಯ ವಾಣಿಜ್ಯ ಮಾದರಿಗಳ" ಸಾಮಾನ್ಯ ಬಿಲ್ಲಿಂಗ್ ಪ್ರಮಾಣದ ಪ್ರಕಾರ (ಇನ್‌ಪುಟ್/ಔಟ್‌ಪುಟ್ ಅನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ವಿಧಿಸಲಾಗುತ್ತದೆ, ಒಟ್ಟಾರೆಯಾಗಿ ಸರಿಸುಮಾರು 10 ಡಾಲರ್ / ಮಿಲಿಯನ್ ಟೋಕನ್‌ಗಳು ಎಂದು ಅಂದಾಜಿಸಲಾಗಿದೆ), ಈ ಒಂದು ದಿನಕ್ಕೆ 1000 ಡಾಲರ್‌ಗಳನ್ನು ಸುಡಲಾಗುತ್ತದೆ. ಒಂದು ದಿನಕ್ಕೆ 7000 ಯುವಾನ್‌ಗಳನ್ನು ಸುಡಲಾಗುತ್ತದೆ. ಅನೇಕ ಜೂನಿಯರ್ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳ ಒಂದು ತಿಂಗಳ ಸಂಬಳವು AI "ಚಿಂತನೆಗೆ" ಸಾಕಾಗುವುದಿಲ್ಲ.

(ಗಮನಿಸಿ: ವಿಭಿನ್ನ ಮಾದರಿಗಳು/ಪೂರೈಕೆದಾರರ ಬೆಲೆಗಳು ಬಹಳವಾಗಿ ಬದಲಾಗುತ್ತವೆ, ಮತ್ತು ಇನ್‌ಪುಟ್ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ನ ಬೆಲೆಗಳು ಸಹ ಸಾಮಾನ್ಯವಾಗಿ ವಿಭಿನ್ನವಾಗಿರುತ್ತವೆ. ಇಲ್ಲಿನ ಉದ್ದೇಶವು ದಶಮಾಂಶ ಬಿಂದುವಿನ ನಂತರದ ಎರಡು ಅಂಕೆಗಳಿಗೆ ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದಲ್ಲ, ಆದರೆ ಮೊದಲು "ಪ್ರಮಾಣದ ಪ್ರಜ್ಞೆ"ಯನ್ನು ಸ್ಥಾಪಿಸುವುದು.)

ನೀವು ನೀವೇ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಬಯಸಿದರೆ, ಸಾಮಾನ್ಯವಾಗಿ ಇದು ಒಂದು ಸೂತ್ರವಾಗಿದೆ (ಕ್ಯಾಶ್/ರಿಯಾಯಿತಿ ಮತ್ತು ಇತರ ವಿಶೇಷ ನಿಯಮಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ): ವೆಚ್ಚ ≈ (ಇನ್‌ಪುಟ್ ಟೋಕನ್‌ಗಳು / 1,000,000) × ಬೆಲೆ_ಇನ್ + (ಔಟ್‌ಪುಟ್ ಟೋಕನ್‌ಗಳು / 1,000,000) × ಬೆಲೆ_ಔಟ್

ಇದು ತುಂಬಾ ಪ್ರತಿ-ಅರ್ಥಗರ್ಭಿತವಾಗಿದೆ. AI ಅಗ್ಗವಾಗಿದೆ ಎಂದು ನಾವು ಯಾವಾಗಲೂ ಭಾವಿಸುತ್ತೇವೆ, OpenAI ಬೆಲೆಗಳನ್ನು ಸಹ ಕಡಿಮೆ ಮಾಡುತ್ತಿದೆ. ಆದರೆ ನೈಜ ಎಂಜಿನಿಯರಿಂಗ್‌ನಲ್ಲಿ, ಟೋಕನ್ ಬಳಕೆಯು ಘಾತೀಯವಾಗಿ ಸ್ಫೋಟಗೊಳ್ಳುವುದು ಏಕೆ?

ಇಂದು, ಈ "ಟೋಕನ್ ಕಪ್ಪು ಕುಳಿ"ಯ ಹಿಂದಿನ ತರ್ಕವನ್ನು ಆಳವಾಗಿ ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ನಾವು ಹೇಗೆ ನಷ್ಟವನ್ನು ತಡೆಯಬಹುದು ಎಂಬುದನ್ನು ನಿಮಗೆ ತೋರಿಸುತ್ತೇನೆ.

I. ಟೋಕನ್‌ಗಳು "ಘಾತೀಯವಾಗಿ ಸ್ಫೋಟಗೊಳ್ಳುವುದು" ಏಕೆ?

ಅನೇಕ ಸಹೋದರರಿಗೆ ಟೋಕನ್‌ಗಳ ಪ್ರಮಾಣದ ಬಗ್ಗೆ ಯಾವುದೇ ಕಲ್ಪನೆ ಇಲ್ಲ. ಅವರು ಭಾವಿಸುತ್ತಾರೆ: "ಓಹ್, ಅದು ಕೆಲವು ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಕಳುಹಿಸುವುದು ಅಷ್ಟೇ ಅಲ್ಲವೇ? ಅದು ಎಷ್ಟು ಆಗಬಹುದು?"

1. ಸ್ಪಷ್ಟ ಲೆಕ್ಕಾಚಾರ

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

ಕೆಳಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು "ಅಂದಾಜು ಅಳತೆಗೋಲು" ಎಂದು ಪರಿಗಣಿಸಿ (ಗುರಿಯು ಪ್ರಮಾಣವನ್ನು ನಿರ್ಣಯಿಸುವುದು, ವೆಚ್ಚವನ್ನು ಅಂದಾಜು ಮಾಡುವುದು ಮತ್ತು ನಷ್ಟ ತಡೆಗಟ್ಟುವ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು):

• 1 ಚೈನೀಸ್ ಅಕ್ಷರ: ಸಾಮಾನ್ಯವಾಗಿ 1-2 ಟೋಕನ್‌ಗಳು (ಹೆಚ್ಚು ಬಾರಿ ಬಳಸುವ ಅಕ್ಷರಗಳು 1 ಕ್ಕೆ ಹತ್ತಿರವಾಗಿರುತ್ತವೆ, ಅಪರೂಪದ ಅಕ್ಷರಗಳು/ಸಂಯೋಜನೆಗಳು 2-3 ಕ್ಕೆ ಸುಲಭವಾಗಿ ತಲುಪಬಹುದು)

• 1 ಇಂಗ್ಲಿಷ್ ಪದ: ಸಾಮಾನ್ಯವಾಗಿ ಸುಮಾರು 1.2-1.5 ಟೋಕನ್‌ಗಳು (ಒರಟು ಅಂದಾಜುಗಾಗಿ 1.3 ಅನ್ನು ಬಳಸುವುದು ಸಹ ಸರಿ)

• 1 ಸಾಲಿನ ಕೋಡ್ ≈ 10-50 ಟೋಕನ್‌ಗಳು (ಇಂಡೆಂಟೇಶನ್, ಕಾಮೆಂಟ್‌ಗಳು, ಪ್ರಕಾರದ ಘೋಷಣೆಗಳು ಸೇರಿದಂತೆ)

• ಸಂಕ್ಷಿಪ್ತ ವ್ಯವಹಾರ ತರ್ಕ ≈ 12-20 ಟೋಕನ್‌ಗಳು

• ಪ್ರಕಾರದ ಟಿಪ್ಪಣಿಗಳು, ಇಂಟರ್ಫೇಸ್, JSDoc, 4-ಸ್ಪೇಸ್ ಇಂಡೆಂಟೇಶನ್ ≈ 20-35 ಟೋಕನ್‌ಗಳು

• ದೊಡ್ಡ ಪ್ರಮಾಣದ ಆಮದುಗಳು / ಅಲಂಕಾರಕಗಳು / ಕಾಮೆಂಟ್‌ಗಳು ≈ 30-50+ ಟೋಕನ್‌ಗಳು

• 1 ಮೂಲ ಫೈಲ್ (400-600 ಸಾಲುಗಳು, ಆಧುನಿಕ TS/Java ಯೋಜನೆ) ≈ 4,000-24,000 ಟೋಕನ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿದೆ (ಮಧ್ಯಮ ≈ 12,000-18,000)

• 1 ಮಧ್ಯಮ ಗಾತ್ರದ ಯೋಜನೆ (100-200 ಮೂಲ ಫೈಲ್‌ಗಳು, src/ ಅನ್ನು ಮಾತ್ರ ಎಣಿಸಿ, node_modules/ / ಉತ್ಪಾದಿತ ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿಲ್ಲ)

• ಕೋರ್ ಮೂಲ ಕೋಡ್ ಅನ್ನು "ಒಂದು ಬಾರಿ ಓದುವುದು" ಸಾಮಾನ್ಯವಾಗಿ ಮಿಲಿಯನ್ ಟೋಕನ್‌ಗಳಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ

• ನೀವು ಪರೀಕ್ಷೆಗಳು, ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು, ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು, ಅವಲಂಬನೆ ಘೋಷಣೆಗಳು ಮತ್ತು ಲಾಗ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಿದರೆ, ಹತ್ತಾರು ಮಿಲಿಯನ್ ಟೋಕನ್‌ಗಳು ಸಹ ಅಸಾಮಾನ್ಯವೇನಲ್ಲ

ಇಂದಿನ ಫ್ರಂಟ್-ಎಂಡ್ ಯೋಜನೆಗಳು TypeScript ಆಗಿವೆ, ಸಂಕೀರ್ಣ ಇಂಟರ್ಫೇಸ್ ವ್ಯಾಖ್ಯಾನಗಳಿಂದ ತುಂಬಿವೆ; ಅಥವಾ Java, ಕೆಲವೊಮ್ಮೆ ಡಜನ್‌ಗಟ್ಟಲೆ ಸಾಲುಗಳ ಆಮದುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಈ "ಪ್ಲೇಟ್‌ಕೋಡ್" ವಾಸ್ತವವಾಗಿ ಟೋಕನ್ ಕೊಲೆಗಾರರು. ಮಧ್ಯಮ ಗಾತ್ರದ ಯೋಜನೆಯು 100 ಫೈಲ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, AI "ಕೋಡ್ ಅನ್ನು ಓದಲು" ಅವಕಾಶ ನೀಡಿದರೆ, ಅದು ನೇರವಾಗಿ 1 ಮಿಲಿಯನ್ ಟೋಕನ್‌ಗಳನ್ನು ಕೊಲ್ಲಬಹುದು.

2. ಟೋಕನ್‌ಗಳ "ಸ್ನೋಬಾಲ್" ಪರಿಣಾಮ

ಟೋಕನ್ ಬಳಕೆಯು ಅತ್ಯಂತ ಭಯಾನಕವಾದದ್ದು ಏಕಕಾಲಿಕ ಸಂಭಾಷಣೆಯಲ್ಲ, ಆದರೆ ಬಹು ಸುತ್ತಿನ ಸಂಭಾಷಣೆಗಳಲ್ಲಿ ಸಂದರ್ಭದ ಸಂಗ್ರಹಣೆ.

LLM ನ ಕಾರ್ಯವಿಧಾನವು ಸ್ಥಿತಿರಹಿತವಾಗಿದೆ. AI ನಿಮ್ಮ ಹಿಂದಿನ ಹೇಳಿಕೆಯನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು, ಸಿಸ್ಟಮ್ ಸಾಮಾನ್ಯವಾಗಿ "ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ + ಹಿಂದಿನ ಸಂಭಾಷಣೆ + ನೀವು ಉಲ್ಲೇಖಿಸಿದ ಫೈಲ್‌ಗಳು/ಕೋಡ್ ತುಣುಕುಗಳು + ಪರಿಕರ ಕರೆ ಔಟ್‌ಪುಟ್ (ಉದಾಹರಣೆಗೆ ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳು, ದೋಷ ಲಾಗ್‌ಗಳು)" ಅನ್ನು ಒಟ್ಟಿಗೆ ಪ್ಯಾಕ್ ಮಾಡಿ ಮಾದರಿಗೆ ಕಳುಹಿಸುತ್ತದೆ. ನೀವು ಕೇವಲ ಒಂದು ಪ್ರಶ್ನೆಯನ್ನು ಕೇಳಿದ್ದೀರಿ ಎಂದು ನೀವು ಭಾವಿಸುತ್ತೀರಿ, ಆದರೆ ನೀವು ಪದೇ ಪದೇ "ಸಂಪೂರ್ಣ ಸಂದರ್ಭ ಪ್ಯಾಕೇಜ್‌ಗೆ" ಪಾವತಿಸುತ್ತಿದ್ದೀರಿ.

• 1 ನೇ ಸುತ್ತು: 10,000 ಟೋಕನ್‌ಗಳನ್ನು ಕಳುಹಿಸಿ, AI 1,000 ಅನ್ನು ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ.

• 2 ನೇ ಸುತ್ತು: (10,000 + 1,000 + ಹೊಸ ಪ್ರಶ್ನೆ) ಕಳುಹಿಸಿ, AI ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ...

• 10 ನೇ ಸುತ್ತು: ನಿಮ್ಮ ಸಂದರ್ಭವು ಈಗಾಗಲೇ 200,000 ಟೋಕನ್‌ಗಳಿಗೆ ಹಿಗ್ಗಿರಬಹುದು.

ಈ ಸಮಯದಲ್ಲಿ, ನೀವು ಕೇವಲ "ವೇರಿಯೇಬಲ್ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಲು ನನಗೆ ಸಹಾಯ ಮಾಡಿ" ಎಂದು ಕೇಳಿದರೂ ಸಹ, ನೀವು 200,000 ಟೋಕನ್‌ಗಳ ಶುಲ್ಕವನ್ನು ಪಾವತಿಸುತ್ತಿದ್ದೀರಿ. ಅದಕ್ಕಾಗಿಯೇ ನೀವು ಏನನ್ನೂ ಮಾಡಿಲ್ಲ ಎಂದು ನಿಮಗೆ ಅನಿಸುತ್ತದೆ, ಆದರೆ ನಿಮ್ಮ ಬಿಲ್ ಏರುತ್ತಿದೆ.

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

II. ಎರಡು ರೀತಿಯ "ಸೋಮಾರಿತನ" ನಿಮ್ಮ ಎಂಜಿನಿಯರಿಂಗ್ ಸಾಮರ್ಥ್ಯವನ್ನು ಹಾಳುಮಾಡುತ್ತಿದೆ

ಕಾಮೆಂಟ್ ವಿಭಾಗದಲ್ಲಿರುವ ಕೆಲವು "ಒಂದು ಕೋಟಿ ಸಹೋದರರನ್ನು" ಪರಿಶೀಲಿಸಿದ ನಂತರ, ಟೋಕನ್‌ಗಳ ಹೆಚ್ಚಳಕ್ಕೆ ಮೂಲ ಕಾರಣವೆಂದರೆ AI ನ ಬಳಕೆಯ ಕಾರ್ಯವಿಧಾನದ ಸಮಸ್ಯೆ ಮಾತ್ರವಲ್ಲ, ಆದರೆ ಜನರ ಸೋಮಾರಿತನವೂ ಆಗಿದೆ.

ಕೆಳಗಿನವು ಎರಡು ವಿಶಿಷ್ಟವಾದ "ಮಾನಸಿಕ ಸೋಮಾರಿತನ".

ಸೋಮಾರಿತನ ಒಂದು: ಹ್ಯಾಂಡ್ಸ್-ಆಫ್ ಮಾಲೀಕತ್ವ

ನೀವು ಈ ಮನಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿದ್ದೀರಾ:

• "ಈ ಹಳೆಯ ಯೋಜನೆಯು ತುಂಬಾ ಗೊಂದಲಮಯವಾಗಿದೆ, ನಾನು ತರ್ಕವನ್ನು ನೋಡಲು ತಲೆಕೆಡಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ, ಅದನ್ನು ನೇರವಾಗಿ AI ಗೆ ಎಸೆಯೋಣ."

• "ಕರ್ಸರ್ ಏಜೆಂಟ್ ಮೋಡ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದೆ, ಅದು ಅದ್ಭುತವಾಗಿದೆ, ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸಲು ಅದನ್ನು ಬಿಡೋಣ."

ಆದ್ದರಿಂದ, ನೀವು ಸಂಪೂರ್ಣ src ಫೋಲ್ಡರ್ ಅನ್ನು ಏಜೆಂಟ್‌ಗೆ ಎಸೆಯುತ್ತೀರಿ ಮತ್ತು ಅಸ್ಪಷ್ಟ ಸೂಚನೆಯನ್ನು ನೀಡುತ್ತೀರಿ: "ನನಗೆ ಬಳಕೆದಾರ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಸಹಾಯ ಮಾಡಿ." ಏಜೆಂಟ್ ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ:

• ಇದು 50 ಫೈಲ್‌ಗಳನ್ನು ಓದುತ್ತದೆ (500,000 ಅನ್ನು ಬಳಸುತ್ತದೆ).

• ಇದು utils ಅನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ ಎಂದು ಅದು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಉಪಕರಣ ವರ್ಗವನ್ನು ಓದಲು ಹೋಗುತ್ತದೆ (200,000 ಅನ್ನು ಬಳಸುತ್ತದೆ).

• ಇದು ಮಾರ್ಪಡಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ದೋಷವನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ದೋಷ ಲಾಗ್ ಅನ್ನು ಓದುತ್ತದೆ (100,000 ಅನ್ನು ಬಳಸುತ್ತದೆ).

• ಇದು ಸರಿಪಡಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಮತ್ತು ಮತ್ತೆ ದೋಷವನ್ನು ಪಡೆಯುತ್ತದೆ...

ಇದು ಹುಚ್ಚುಚ್ಚಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ ಮತ್ತು ಹುಚ್ಚುಚ್ಚಾಗಿ ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸುತ್ತಿದೆ. ಮತ್ತು ನೀವು? ನೀವು ನಿಮ್ಮ ಫೋನ್ ಅನ್ನು ಬ್ರೌಸ್ ಮಾಡುತ್ತಿದ್ದೀರಿ ಮತ್ತು ನೀವು ನಿಜವಾಗಿಯೂ ಪರಿಣಾಮಕಾರಿಯಾಗಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸುತ್ತೀರಿ. ಸತ್ಯವೆಂದರೆ: ನೀವು ಹಣದಿಂದ "ನಕಲಿ ದಕ್ಷತೆಯನ್ನು" ಖರೀದಿಸಿದ್ದೀರಿ, ಅದು ನಂತರ ನೀವು ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಾಗದ ಕೋಡ್‌ನ ಗುಂಪನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಹೆಚ್ಚು ವೃತ್ತಿಪರವಾಗಿ ಹೇಳುವುದಾದರೆ, ಇಲ್ಲಿ ಎರಡು ಪದರಗಳ ನಷ್ಟವಿದೆ:

• ವೆಚ್ಚದ ಪದರ: ಇನ್‌ಪುಟ್ ಟೋಕನ್‌ಗಳು ದೊಡ್ಡದಾಗುತ್ತವೆ, ಪುನರಾವರ್ತನೆಗಳ ಸಂಖ್ಯೆ ಹೆಚ್ಚಾಗುತ್ತದೆ ಮತ್ತು ಶುಲ್ಕಗಳು ರೇಖೀಯವಾಗಿ ಸೇರಿಕೊಳ್ಳುತ್ತವೆ

• ಎಂಜಿನಿಯರಿಂಗ್ ಪದರ: ನೀವು ಸಂದರ್ಭ ಮತ್ತು ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳುವ ಹಕ್ಕನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ "ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸಿದರೆ ಸಾಕು" ಎಂಬ ಅನಿಯಂತ್ರಿತ ವ್ಯವಸ್ಥೆಯನ್ನು ಮಾತ್ರ ಬಿಡಲಾಗುತ್ತದೆ

ಸೋಮಾರಿತನ ಎರಡು: ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಎಸೆಯುವುದು

ನೀವು ದೋಷವನ್ನು ಎದುರಿಸಿದಾಗ, ನೀವು ಅದನ್ನು AI ಗೆ ಹೇಗೆ ಎಸೆಯುತ್ತೀರಿ? ನೀವು ನೇರವಾಗಿ ಸಂಪೂರ್ಣ ದೋಷ ಕನ್ಸೋಲ್ ಅನ್ನು Ctrl+A ನೊಂದಿಗೆ ನಕಲಿಸುತ್ತೀರಾ ಅಥವಾ AI ಸ್ವತಃ ಹುಡುಕಲು @Codebase ಅನ್ನು ಬಳಸುತ್ತೀರಾ?

ಇದನ್ನು "ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಎಸೆಯುವುದು" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಸಮಸ್ಯೆಯ ತಿರುಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ನೀವು ತಲೆಕೆಡಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ, ನಿರ್ಣಾಯಕ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ನೀವು ತಲೆಕೆಡಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ. ನೀವು 99% ರಷ್ಟು ಅಮಾನ್ಯ ಮಾಹಿತಿಯನ್ನು (ಶಬ್ದ) ಮತ್ತು 1% ರಷ್ಟು ಮಾನ್ಯ ಮಾಹಿತಿಯನ್ನು (ಸಂಕೇತ) AI ಗೆ ಎಸೆಯುತ್ತೀರಿ.

AI ಒಂದು ಆಂಪ್ಲಿಫೈಯರ್‌ನಂತೆ.

• ನೀವು ಅದಕ್ಕೆ ಸ್ಪಷ್ಟವಾದ ತರ್ಕವನ್ನು (ಸಂಕೇತ) ನೀಡಿದರೆ, ಅದು ನಿಮ್ಮ ಬುದ್ಧಿವಂತಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಕಡಿಮೆ ಟೋಕನ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪರಿಣಾಮವು ಉತ್ತಮವಾಗಿರುತ್ತದೆ.

• ನೀವು ಅದಕ್ಕೆ ಗೊಂದಲ ಮತ್ತು ಅಸ್ಪಷ್ಟತೆಯನ್ನು ನೀಡಿದರೆ, ಅದು ನಿಮ್ಮ ಗೊಂದಲವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಟೋಕನ್‌ಗಳು ಏರುತ್ತವೆ ಮತ್ತು ಕಸವನ್ನು ಉತ್ಪಾದಿಸಲಾಗುತ್ತದೆ.

III. ಪರಿಹಾರ: AI ಅನ್ನು ಹೇಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವುದು ಮತ್ತು ಟೋಕನ್ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು

ನಿಮ್ಮ ಕೈಚೀಲವನ್ನು ರಕ್ಷಿಸಲು, ನಿಮ್ಮ ಎಂಜಿನಿಯರಿಂಗ್ ನಿಯಂತ್ರಣವನ್ನು ರಕ್ಷಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ, ನಾವು AI ನೊಂದಿಗೆ ಸಹಯೋಗಿಸುವ ವಿಧಾನವನ್ನು ಬದಲಾಯಿಸಬೇಕು.

1. ಕನಿಷ್ಠ ಸಂದರ್ಭ ತತ್ವ

ಇದು AI ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಮೊದಲ ತತ್ವವಾಗಿದೆ. ಪ್ರಸ್ತುತ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು AI ಗೆ ಅನುಗುಣವಾದ ಕನಿಷ್ಠ ಕೋಡ್ ಸೆಟ್ ಅನ್ನು ಮಾತ್ರ ಯಾವಾಗಲೂ ನೀಡಿ.

ಕರ್ಸರ್‌ನಲ್ಲಿ, ಈ ಆಪರೇಟರ್‌ಗಳನ್ನು ಉತ್ತಮವಾಗಿ ಬಳಸಿ:

• @File: ಸಂಪೂರ್ಣ ಫೋಲ್ಡರ್ ಬದಲಿಗೆ ಸಂಬಂಧಿತ ಫೈಲ್ ಅನ್ನು ಮಾತ್ರ ಉಲ್ಲೇಖಿಸಿ.

• Ctrl+L ಕೋಡ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ: ಸಂಪೂರ್ಣ ಫೈಲ್ ಬದಲಿಗೆ ಕರ್ಸರ್‌ನಿಂದ ಆಯ್ಕೆಮಾಡಿದ 50 ಸಾಲುಗಳ ಕೋಡ್ ಅನ್ನು ಮಾತ್ರ ಚಾಟ್‌ಗೆ ಕಳುಹಿಸಿ.

• @Docs: ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ, ಊಹಿಸಲು ಬಿಡುವ ಬದಲು ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಉಲ್ಲೇಖಿಸಿ.

ಇದು ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ರಚನಾತ್ಮಕ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ SOP ಆಗಿದೆ (ನೀವು ಅದನ್ನು ಅನುಸರಿಸಿದರೆ, ಟೋಕನ್‌ಗಳು ಕಣ್ಣಿಗೆ ಕಾಣುವಂತೆ ಕಡಿಮೆಯಾಗುತ್ತವೆ):

ಈ ಮಾತಿನ ಅರ್ಥವೇನೆಂದರೆ: AI ನೊಂದಿಗೆ ಸಹಕರಿಸುವಾಗ, ದಕ್ಷತೆ ಮತ್ತು ನಿಖರತೆಗೆ ಗಮನ ಕೊಡಿ. ನಿರ್ದಿಷ್ಟ ವಿಧಾನಗಳು ಈ ಕೆಳಗಿನಂತಿವೆ:

• ಮೊದಲು ಗುರಿಯನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಿ: AI ಗೆ ಪ್ರಸ್ತುತ ಸಮಸ್ಯೆ ಮತ್ತು ಅಪೇಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮತ್ತು ನಿಖರವಾಗಿ ತಿಳಿಸಿ, ಅದನ್ನು ಊಹಿಸಲು ಬಿಡಬೇಡಿ.

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

• ಕನಿಷ್ಠ ಅಗತ್ಯ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಿ: ಸಂಬಂಧಿತ 1-3 ಫೈಲ್‌ಗಳು, ನಿರ್ಣಾಯಕ ಕಾರ್ಯಗಳು ಮತ್ತು ದೋಷ ಸ್ಟಾಕ್‌ನ ಮೊದಲ ಕೆಲವು ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ನೀಡಿ, ಸಂಪೂರ್ಣ ಮಾಹಿತಿಯನ್ನು ನೀಡಬೇಡಿ.

• ಮಾರ್ಪಾಡುಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು ವಿನಂತಿಸಿ: AI ಎಲ್ಲಿ ಬದಲಾಯಿಸಬೇಕು ಮತ್ತು ಏಕೆ ಬದಲಾಯಿಸಬೇಕು ಎಂದು ಮಾತ್ರ ನಿಮಗೆ ತಿಳಿಸಲು ಬಿಡಿ, ಸಂಪೂರ್ಣ ಕೋಡ್ ಅನ್ನು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ಪುನಃ ಬರೆಯಲು ಬಿಡಬೇಡಿ.

• ಅಂತಿಮವಾಗಿ ನೀವೇ ಪರಿಶೀಲಿಸಿ: ಬದಲಾವಣೆಗಳು ಇತರ ಸ್ಥಳಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸರಳವಾದ ಮೌಲ್ಯೀಕರಣವನ್ನು ಮಾಡಿ.

ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಕನಿಷ್ಠ ಮತ್ತು ನಿರ್ಣಾಯಕ ಮಾಹಿತಿಯೊಂದಿಗೆ AI ಕೆಲಸ ಮಾಡಲು ಬಿಡಿ ಮತ್ತು ಅಂತಿಮ ನಿಯಂತ್ರಣ ಮತ್ತು ತೀರ್ಪನ್ನು ಉಳಿಸಿಕೊಳ್ಳಿ.

2. ಮತ್ತು ಅತ್ಯಂತ ಮುಖ್ಯವಾದದ್ದು: ಮೊದಲು ಯೋಚಿಸಿ, ನಂತರ ಪ್ರಾಂಪ್ಟ್ ಮಾಡಿ, ಮೊದಲು ಯೋಜಿಸಿ, ನಂತರ ಕಾರ್ಯನಿರ್ವಹಿಸಿ

ಎಂಟರ್ ಕೀಲಿಯನ್ನು ಒತ್ತುವ ಮೊದಲು, 10 ಸೆಕೆಂಡುಗಳ ಕಾಲ ನಿಮ್ಮನ್ನು ನಿಲ್ಲಿಸಲು ಒತ್ತಾಯಿಸಿ ಮತ್ತು ನಿಮ್ಮನ್ನು ಮೂರು ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿಕೊಳ್ಳಿ:

• ನಾನು ಯಾವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತಿದ್ದೇನೆ? (ಗಡಿಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ)

• ಈ ಸಮಸ್ಯೆಯು ಯಾವ ಪ್ರಮುಖ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ? (ಸಂದರ್ಭವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ)

• ನಾನು ಸ್ವತಃ ಬರೆಯುತ್ತಿದ್ದರೆ, ನಾನು ಅದನ್ನು ಹೇಗೆ ಬರೆಯುತ್ತೇನೆ? (ಆಲೋಚನೆಗಳನ್ನು ಒದಗಿಸಿ)

ನೀವು 1, AI ನಂತರದ 0. ನೀವು 1 ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ನಂತರದ 0 ಎಷ್ಟು ಇದ್ದರೂ, ಅದು ಅರ್ಥಹೀನ ಬಳಕೆಯಾಗಿದೆ.

ಕೆಲವು ಪ್ರಾಮಾಣಿಕ ಮಾತುಗಳು

"ದಿನಕ್ಕೆ ಒಂದು ಕೋಟಿ ಟೋಕನ್‌ಗಳು" ಕಥೆಯು ಪ್ರತಿಯೊಬ್ಬರ ಜೀವನದಲ್ಲಿ ಸಂಭವಿಸದೇ ಇರಬಹುದು. ಆದರೆ ಟೋಕನ್‌ಗಳನ್ನು ವ್ಯರ್ಥ ಮಾಡುವ ನಡವಳಿಕೆಯನ್ನು AI ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬಳಸುವ ಪ್ರತಿಯೊಬ್ಬ ಪ್ರೋಗ್ರಾಮರ್ ಅನುಭವಿಸುತ್ತಾರೆ.

AI ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಸುಲಭಗೊಳಿಸಿದರೂ, ಇನ್ನೂ ಮಿತಿಗಳಿವೆ. ನಿಜವಾಗಿಯೂ ಬಳಸಲು ತಿಳಿದಿರುವವರು ಮಾತ್ರ ರೆಕ್ಕೆಗಳನ್ನು ಹೊಂದಿರುವ ಹುಲಿಯಂತೆ ಇರುತ್ತಾರೆ.

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