ನಿಮ್ಮ ಕೋಡ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬರೆಯಲ್ಪಟ್ಟರೆ ಎಷ್ಟೆಂದು ಕನಸು ನೋಡಿದೀರಾ?
ನೀವು ಪರದೆ ಮುಂದೆ ನಿಂತು 'ಕೇವಲ API ಕರೆ ಮಾಡು' ಎಂದು ಮನಸ್ಸಿನಲ್ಲಿ ಹೇಳುವಾಗ, ಕಂಪ್ಯೂಟರ್ ತಕ್ಷಣ ನಿಮ್ಮ ಕೇಳುವ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ಮುಂದಾಗದೆ ಬಿಟ್ಟ ಒಂದು ಬೆಕ್ಕಿನಂತೆ ನೋಡಿದ ಕ್ಷಣವನ್ನು ನೀವೇನು ಎದುರಿಸಿದ್ದೀರಾ? ಅಲ್ಲಿ AI ಕೋಡಿಂಗ್ ಸಹಾಯಕರು ಕೇಪಿನೊಂದಿಗೆ ನাচಿಸುತ್ತಾರೆ. ಇಂದು ನಮ್ಮ ನಾಯಕ: Claude. ಮತ್ತು 19ನೇ ಶತಮಾನದಲ್ಲಿನ ತತ್ವಚಿಂತಕ ಕವಿ ಅಲ್ಲ—ನೀವು ನೀಡಿದ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ಆಗಿ ಪರಿವರ್ತಿಸುವ AI ಮಾದರಿ, ಅಸಾಮಾನ್ಯ ಹಿತೈಷಿ ನಿರೀಕ್ಷೆಯೊಂದಿಗೆ.
ನಾನು ಒಂದು ವಾರ Claude ತರಗತಿಯ ಸೌಜನ್ಯSous-chef ಹಾಗೆ ಅವನಿಗೆ ಸೂಚನೆ ನೀಡುತ್ತಿದ್ದೆ. “Claude, ಈ JSON ಅನ್ನು ಕತ್ತರಿಸು.” “Claude, ಈ SQL ಅನ್ನು ಸೇರ್ ಮಾಡು.” “Claude, ಯುನಿಟ್ ಟೆಸ್ಟ್ಗಳನ್ನು ಹಾಳು ಮಾಡಬೇಡ.” ಅಂತೆಯೇ ಕೊನೆಗೆ ನಾನು ಒಂದು ಸರಳ ಸತ್ಯವನ್ನು ತಿಳಿದುಕೊಂಡೆ: Claude Code ನಿಂದ ಉತ್ತಮ ಫಲಿತಾಂಶ ಪಡೆಯುವುದು ಜಾದೂ ಅಲ್ಲ, ಮತ್ತಷ್ಟು ಅದರೊಂದಿಗೆ ನೀವು ಹೇಗೆ ಮಾತಾಡುತ್ತೀರೋ ಅದರ ಮೇಲೆ.
ಇದು ನಿಮ್ಮ ಸ್ನೇಹಪೂರ್ಣ, ಸ್ವಲ್ಪ ಕ್ಯಾಫಿನ್ ಕಲವು ಹೊಂದಿರುವ Claude Code ಸಲಹೆಗಳ ಮಾರ್ಗದರ್ಶಿ—ಪ್ರಾಂಪ್ಟ್ ಇಂದ ಕೋಡ್ ನಿರ್ವಹಣೆಯವರೆಗಿನ, ನಿಮ್ಮ ಮುಂದಿನ ಅಧಿವೇಶನವು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಮೂಲಕ ಮುಗಿಯಲಿ, ಹುಷಾರ್ ಆಗದೆ.
Claude ಏನು ಮತ್ತು ನೀವು ಅದನ್ನು ಯಾಕೆ ಗಮನಿಸಬೇಕು?
Claude ಎಂಬುದು Anthropic ನಿಂದ ಹತ್ತಿರದಂತೆ ಓದುವದು, ವಿವೇಚಿಸುವದು ಮತ್ತು ಪಠ್ಯಕ್ಕಾಗಿಯೂ ಸಹ ಕೋಡ್ ರಚಿಸುವದುಳ್ಳ AI ಮಾದರಿ. ಇದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಕೆಲಸ ಮಾಡುವ ಸಹಾಯಗಾರನಂತೆ ಭಾವಿಸಬಹುದು, ಇದು ಫಂಕ್ಷನ್ ಬರೆಯಲು ಸಂತೋಷವಾಗಿದ್ದು, ನಿಮ್ಮ ಸ್ಟ್ಯಾಕ್ ಟ್ರೇಸ್ ಅನ್ನು ಕಥೆಯಂತೆ ವಿವರಿಸುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಸ್ಪಾಗೆಟ್ಟಿ ಕೋಡ್ ಅನ್ನು ಲింగ್ವಿನಿ ಆಗಿ ಬದಲಿಸುತ್ತದೆ.
ಅದರ ವಿಶೇಷತೆಗಳು:
- ಸಾದಾ ಇಂಗ್ಲಿಷ್ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು Python, JavaScript/TypeScript, Go ಮುಂತಾದ ಭಾಷೆಗಳ ಕೋಡ್ ತುಂಡುಗಳಿಗೆ ಪರಿವರ್ತಿಸುವದು.
- ನೀವು ಸರಿಯಾದ ರೀತಿಯಲ್ಲಿ ಕೇಳಿದರೆ ಎಡ್ಜ್ ಕೇಸ್ ಗಳು ಮತ್ತು ಟೆಸ್ಟ್ಗಳನ್ನು ಯೋಚಿಸುವದು.
- ನಿಮ್ಮ ರೆಪೊವಿನ ದೊಡ್ಡ ಭಾಗಗಳನ್ನು (ಪ್ರಸಂಗ ಮಿತಿ ಒಳಗೆ) ಓದಿ, ಅವ್ಯವಸ್ಥೆಯನ್ನು ಸಾರಾಂಶಗೊಳಿಸುವದು.
ಅಲ್ಲಿ ಸಹಾಯ ಬೇಕಾಗುವದ್ದು:
- ಅಸ್ಪಷ್ಟ ಪ್ರಾಂಪ್ಟ್ಗಳು ಅಸ್ಪಷ್ಟ ಕೋಡ್ಗೆ ದಾರಿತీస್ಕೋಬಹುದು. (ಇದು ಭವಿಷ್ಯವಾಣಿ ಮಾಡೋದಲ್ಲ; ಇದು ಔಪಚಾರಿಕವಾಗಿದೆ.)
- ನೀವು ರನ್ ಟೈಮ್ ಅಥವಾ ಫ್ರೇಮ್ವರ್ಕ್ ಆವೃತ್ತಿಗಳನ್ನು ನಿಯತಪಡಿಸದಿದ್ದರೆ, ತಪ್ಪು ಮೂಲ್ಯಗಳನ್ನು 'ನೋಮಿಕೊಳ್ಳಬಹುದು'.
- ಎಂದಿಗೂ ಊಹಿಸುವಾಗ ಚುರುಕಾಗಿ ಮಾತನಾಡಬಹುದು—ಆದರೆ ನೀವು ಇನ್ನೂ ಟೆಸ್ಟ್ ಮಾಡಿ, ಲಿಂಟ್ ಮಾಡಿ, ಸ್ಥಳೀಯವಾಗಿ ಚಾಲನೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಆ ಹಣವನ್ನು ಮುದ್ರಿಸುವ ಪ್ರಾಂಪ್ಟ್ (ಅಂದರೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್)
ಇದು ನಾನೇ ಯಾವಾಗಲೂ ಉಪಯೋಗಿಸುವ ಮೆಥೋಡ್. ಇದು ನನ್ನ Claude Code ಪ್ರಾಂಪ್ಟ್ ಸೆಂಡ್ವಿಚ್: ಪ್ರಸಂಗ, ನಿರ್ಬಂಧಗಳು, ಮತ್ತು ಪರಿಶೀಲನೆಗಳು.
- ಪ್ರಸಂಗ: ನೀವು ನಿರ್ಮಿಸುತ್ತಿರುವದು, ವಾತಾವರಣೆ, ಮತ್ತು ಯಾವುದೇ ಇತರೆ ಕೋಡ್.
- ನಿರ್ಬಂಧಗಳು: ಭಾಷೆ, ಆವೃತ್ತಿಗಳು, ಫ್ರೇಮ್ವರ್ಕ್ಗಳು, ಕಾರ್ಯಕ್ಷಮತೆ ಅಥವಾ ಓದುಗೊಳ್ಳುವಿಕೆಯ ಗುರಿಗಳು.
- ಪರಿಶೀಲನೆಗಳು: ಯಶಸ್ಸು ಪರಿಶೀಲಿಸುವ ವಿಧಾನಗಳು—ಟೆಸ್ಟ್ಗಳು, ಲಾಗ್ಗಳು, ಅಥವಾ ಮಾದರಿ ಇನ್ಪುಟ್/ ಔಟ್ಪುಟ್ಗಳು.
ನೀವು ಶೇಖರಿಸಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್:
“ಪಾತ್ರ: ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಹಿರಿಯ ಎಂಜಿನಿಯರ್.
ಗುರಿ: Y ಮಾಡಿ X ಅನ್ನು ನಿರ್ಮಿಸು.
ವಾತಾವರಣೆ: Node 20, Express 4, PostgreSQL 15. Render ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ. TypeScript ಬಳಸಿ.
ಇಂಟರ್ಫೇಸ್ಗಳು: ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ ವಿನಂತಿ/ಪ್ರತಿಕ್ರಿಯೆ ಇದೆ.
ನಿರ್ಬಂಧಗಳು: ಪ್ರಾಮಾಣಿಕ ಲೈಬ್ರರಿ ಆಯ್ಕೆಮಾಡಿ. ಬಾಹ್ಯ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಅತ್ಯಾವಶ್ಯಕತೆ ಕಂಡಾಗ ಮಾತ್ರ ಬಿಡಿ.
ಡಿಲಿವರೆಬಲ್ಸ್:
- ಒಂದು ಕೆಲಸದ ನಿರ್ದೇಶನ
ಪರಿಶೀಲನೆ: ಪರಿಶೀಲನೆಗಾಗಿ ನಾನು ಪೇಸ್ಟ್ ಮಾಡಬಹುದಾದ ಮಾದರಿ ಇನ್ಪುಟ್/ ಔಟ್ಪುಟ್ ಒದಗಿಸಿ.”
ಈಗ ಗಮನಿಸಿ ಹೇಗೆ ಇದು ಸರಳ 'API ರಚಿಸಿ'ಯನ್ನು ಶಸ್ತ್ರಚಿಕಿತ್ಸಕನ ತಾಳಿಕೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಪ್ರಾಂಪ್ಟ್ ಇಂದ ಕೋಡ್ ಕಾರ್ಯಗತಿಗೆ: ಹ್ಯಾಂಡ್ಸ್-ಆನ್ ಮಾರ್ಗದರ್ಶಿ
ನೀವು ಒಂದು ಸಣ್ಣ ಸೇವೆಯನ್ನು ರಚಿಸಲು ಬಯಸಿದರೆ ಅದು Markdown ನ್ನು HTML ಗೆ ಸ್ವಲ್ಪ ಶುದ್ಧೀಕರಣ ಸಹಿತ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಪ್ರಾಂಪ್ಟ್ ಸೆಂಡ್ವಿಚ್ ಉಪಯೋಗಿಸುವಾಗ ಸಂಭವಿಸುವುದೇನು ನೋಡಿ.
ಪ್ರಾಂಪ್ಟ್ (ಸಂತುಷ್ಟ):
“Node 20 + Express 4 (TypeScript) ನಲ್ಲಿ POST /render ಕೊಡೆ ಕೊಡು. ಇನ್ಪುಟ್: { markdown: string }. ಔಟ್ಪುಟ್: { html: string }. ಭಾರೀ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ತಪ್ಪಿಸಿ; ಮೂಲ ಸಂಗ್ರಹಿಸಿದ ಟ್ಯಾಗ್ಗಳನ್ನು ಶುದ್ಧೀಕರಿಸಿ; Jest ಟೆಸ್ಟ್ ಸೇರಿಸಿ; ಚಾಲನೆಗಾಗಿ ಏಕಡಯ ಆಜ್ಞೆ; ಮತ್ತು curl ಉದಾಹರಣೆ ನೀಡಿ.”
ನಿಮ್ಮ ಸ್ಪಷ್ಟತೆಯಲ್ಲಿ Claude ನೀಡುವದು:
- TypeScript ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಒಗ್ಗೂಡಿದ Express ಸರ್ವರ್
- ಸರಳ ಶುದ್ಧೀಕರಣ ಸಾಧನ (ಅಥವಾ ವಿವೇಚನೆ ಕೂಡಿದ ಡಿಪೆಂಡೆನ್ಸಿ)
- Jest ಟೆಸ್ಟ್ಗಳು: ಖಾಲಿ ಇನ್ಪುಟ್, ದೀರ್ಘ ಇನ್ಪುಟ್, ದುಷ್ಟ ಟ್ಯಾಗ್ಗಳ ಮೇಲೆ
- Curl ಆದೇಶಗಳು:
curl -X POST -H "Content-Type: application/json" -d '{"markdown":"# Hello "}'
ಆಂತರಿಕ ಸಲಹೆ: ಪ್ರತಿಯೊಂದು ಹಂತದ ಕಾರಣವನ್ನು ವಿವರಿಸುವ ಕಾಮೆಂಟ್ಗಳನ್ನು ಕೋಡ್ನಲ್ಲಿ ಕೇಳಿ. ಅದೇ ನಿಮಗೆ 10 ನಿಮಿಷದ ಕನಸು ಉಳಿಸುವುದು ಮತ್ತು ಭವಿಷ್ಯ ನೀವುಗಳಿಗೆ ಸ್ಲ್ಯಾಕ್ ಸಂದೇಶ ಕಳುಹಿಸುವುದನ್ನು ತಪ್ಪಿಸುವುದು.
Claude Code ಸಲಹೆಗಳು, ಪರಿಣಾಮಕಾರಿಯಾದವು
1) ಆವೃತ್ತಿಗಳನ್ನು ಶ್ರದ್ಧೆಗೂಡಿಸಿ—ಕ್ಯಾಂಪಿಂಗ್ ಪ್ಯಾಕ್ ಮಾಡುತ್ತಿರುವಂತಿರಲಿ
- ಕೆಟ್ಟ ಉದಾಹರಣೆ: “Flask ಆಪ್ ಮಾಡು.”
- ಚೆನ್ನಾದ ಉದಾಹರಣೆ: “Flask ಆಪ್ (Python 3.11, Flask 3.0) ಮಾಡಿ,
flask run ಮೂಲಕ ಚಾಲನೆ ಮಾಡಿ, ಗ್ಲೋಬಲ್ ಸ್ಟೇಟ್ ಇಲ್ಲ, ಡಿಪೆಂಡೆನ್ಸಿಗಾಗಿಯೂ pip-tools ಬಳಸಿ.”
ಏಕೆ? ಫ್ರೇಮ್ವರ್ಕ್ಗಳು ಬದಲಾಗುತ್ತವೆ, Claude ಬಹಳವನ್ನೇ ತಿಳಿಯುತ್ತದೆ—ಆದರೆ ಅದು ನಿಮ್ಮ ಯಂತ್ರದ ಬಗ್ಗೆ ಎಲ್ಲವನ್ನೂ ತಿಳಿಯದು. ಆವೃತ್ತಿ ಸ್ಪಷ್ಟತೆ ಅಗತ್ಯವಿರಲ್ ಭವಿಷ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
2) ಸಣ್ಣ ಸ್ಪೆಸಿಫಿಕೇಶನ್ ಮತ್ತು ಉದಾಹರಣೆ ನೀಡಿ
“ನೀವು ನೀಡಿದ ಇನ್ಪುಟ್ಗೆ ಸರಿಯಾದ ಔಟ್ಪುಟ್ ನಾವು ನಿರೀಕ್ಷಿಸುತ್ತೇವೆ.” ಕನಿಷ್ಠವಾಗಿ ಸೇರಿಸಬೇಕು:
- ಒಂದು ಎಡ್ಜ್ ಪ್ರಕರಣ (ಖಾಲಿ, ನಲ್, ಮಿತಿ ಬೌಂಡರಿ)
- ಒಂದು ಕೆಟ್ಟ ಪ್ರಕರಣ (ಅಮಾನ್ಯ ಪ್ರಕಾರ, ದುಷ್ಟ ಪೇಲೋಡ್)
Claude ನಿಮ್ಮ ಪರಿಶೀಲನೆಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ. ನೀವು ಅದಕ್ಕೆ ನೀಡಿದ ಮೀಟರ್ ನಿಖರವಾಗಿ ಅಳತೆ ಮಾಡುತ್ತದೆ.
3) ಟೆಸ್ಟ್ಗಳನ್ನು ಪ್ರಾರಂಭದಲ್ಲಿ ಕೇಳಿ, ಡೆಸರ್ಟ್ ಆಗิಲ್ಲ
ನೀವು 'ನಾವು ಹಿಂದುಗಡೆಸಿದರೆ Jest ಟೆಸ್ಟ್ಗಳು ವಿಫಲವಾಗಬೇಕು' ಎಂದು ಹೇಳುವಾಗ, ನೀವು ದುಡಿಬಂದಿರುವ ಬಂಧನ ಸಿಗಬಲ್ಲಾಗುತ್ತದೆ. Claude ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ರೂಪದಲ್ಲಿದ್ದ ಟೆಸ್ಟ್ಗಳನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅಕಸ್ಮಿಕವಾಗಿ ಅದೇತೆಡೆಗೆ ಕೇಳುವ ತರಹದ ಹಲ್ಲುಗಳನ್ನು ಹಿಡಿದಿಡುತ್ತದೆ.
4) ರನ್/ಪರಿಶೀಲಿಸುವ ಸೆಕ್ಷನ್ ಬೇಡಿಕೊಳ್ಳಿ
ಚೆನ್ನಾದ ಪ್ರಾಂಪ್ಟ್ಗಳು: “ಪಸ್ವಪ್ಸ ಪಧ್ದತಿಯಲ್ಲಿ ಚಾಲನೆ ಹಾಗೂ ಪರಿಶೀಲನಾ ಆಜ್ಞೆ ಸೇರಿಸು” ಅಂತ್ಯಗೊಳ್ಳುತ್ತವೆ. ನಿಮ್ಮ ಭವಿಷ್ಯದ ತಾನು ಡಾಕರ್, ಪೋಯಟ್ರಿ ಅಥವಾ ನೋಡ್ಗಳ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಎದುರಿಸಿದಾಗ ಕೃತಜ್ಞತೆಯೊಂದಿಗೆ ಮುಗಿಸಲಿದ್ದಾರೆ.
5) ನಿಮ್ಮ ಇತರೆ ಕೋಡ್ ತೋರಿಸಿ, ಆದರೆ ಇರುವುದು ಮಾತ್ರ ಬಿಡಿ
ಒಟ್ಟು ರೆಪೊ ಹಂಚಿಕೊಳ್ಳುವುದು ಖಾದ್ಯಕ್ಕೆ ಲೈಬ್ರರಿ ನೀಡುತ್ತಿರುವಂತಿದೆ. ಸಂಬಂಧಪಟ್ಟ ಫೈಲ್ಗಳು ಮಾತ್ರ ಮತ್ತು ಪ್ಯಾಕೇಜ್.json ಅಥವಾ pyproject ಸೇರಿಸಿ. ನೀವು ಗ್ರಹಿಸುವ ಫೈಲ್ಗಳಲ್ಲಿ ಮಾತ್ರ ಪರಿಷ್ಕರಣೆ ಕೇಳಿ—ಫಲಿತಾಂಶಕ್ಕೂ ಸಹಾಯ.
6) ಬದಲಾವಣೆಗಳನ್ನು ಡಿಫ್ ರೀತಿಯಿಂದ ಅಲೋಚಿಸಿ
ನೀವು ಕೋಡ್ವನ್ನು ಪರಿಷ್ಕರಿಸಿದರೆ: “ಫೈಲ್ X ಮತ್ತು Y ಗೆ ಯುನಿಫೈಡ್ ಡಿಫ್ ಪ್ಯಾಚ್ ನೀಡಿ, ಕೋಡ್ ಬ್ಲಾಕ್ ನಲ್ಲಿ ಯಾವುದೇ ಟಿಪ್ಪಣಿ ಇಲ್ಲ, ಮತ್ತು ನಂತರ ವಿವರಣೆ ವಿಭಜನೆ ನೀಡು.” ಇದು ಪ್ರತಿನಕಲಿಸುವುದಕ್ಕೆ ಅನುಕೂಲ ಮತ್ತು ಎಲ್ಲೆಡೆ ಹಾಕುದು ನಿಲ್ಲಿಸುತ್ತದೆ.
7) ಸರಳ ಇಂಗ್ಲಿಷ್ನಲ್ಲಿ ಸ್ವತಃ ವಿವರಿಸಲು ಹೇಳಿ
“ಕೋಡ್ಗಿಂತ ಮೊದಲು 5 ಗುಂಡಿಗಳಲ್ಲಿ ಆಲೋಚನೆ ವಿವರಿಸು. ಕೋಡ್ನಂತರ ವ್ಯತ್ಯಾಸಗಳನ್ನು ವಿವರಿಸು.” Claude ಯೋಜನೆಯನ್ನು ವಿವರಿಸುವಾಗ ನೀವು ತಪ್ಪು ದಿಕ್ಕಿಗೆ ಕನ್ನಡಿಸುವ ಮುನ್ನ ಮಾರ್ಗದರ್ಶಕನಾಗಬಹುದು.
8) ಮಿತಿಗಳನ್ನು ನಿರ್ಧರಿಸಿ
“ನಾನು ಒಪ್ಪದಿದ್ದರೆ 3ನೇ ಪಕ್ಷ ಡಿಪೆಂಡೆನ್ಸಿ ಸೇರಿಸಬೇಡ. ಬೇಕಾದರೆ, 2 ಆಯ್ಕೆಗಳು ಪ್ರಯೋಜನ/ಅಪಾಯಗಳ ಜೊತೆ ನೀಡು.” ಈಗ ನೀವು ವಾಸ್ತವಶಾಸ್ತ್ರಜ್ಞ, ನಿರೀಕ್ಷಕ ಅಲ್ಲ.
9) ಭದ್ರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಕಡೆಗೂ ತರುವಂತೆ ಕೇಳಿ
ಪ್ರಾಂಪ್ಟ್ಗಳಿಗೆ ಸೇರಿಸಿ:
- “ಎಲ್ಲಾ ಇನ್ಪುಟ್ ಪರಿಶೀಲಿಸಿ; >1MB ಪೇಲೋಡ್ ತಿರಸ್ಕರಿಸು.”
- “ಔಟ್ಪುಟ್ ಎಸ್ಕೇಪ್ ಮಾಡು; ಶತ್ರುತ್ವಪೂರ್ಣ ಇನ್ಪುಟ್ಗಳನ್ನು ಊಹಿಸು.”
- “ಮುಖ್ಯ ಮಾರ್ಗಕ್ಕೆ Big-O ಗುರಿ: O(n log n) ಅಥವಾ ಉತ್ತಮ.”
- “ಸುರಕ್ಷಿತ, non-PII ಮೆಟಾಡೇಟಾ ಮಾತ್ರ ಲಾಗ್ ಮಾಡು.”
Claude ಈ ಅಪೇಕ್ಷೆಗಳಿಗೆ ತಕ್ಕಂತೆ ಏರಬಹುದು (ಅಥವಾ ಬುದ್ಧಿವಂತ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಬಹುದು).
10) ವ್ಯಕ್ತಿತ್ವ ನೀಡಿ—ಫಲಕಾರಿ, ಮಗುಮಾತ್ರವಲ್ಲ
“ಸಂಕುಚಿತವಾಗಿರು, ಕೋಡಿಂಗ್ ಮಾಡುವ ಮುನ್ನ ಸ್ಪಷ್ಟೀಕರಣ ಪ್ರಶ್ನೆ ಕೇಳು, ಊಹೆ ತ್ಯಜಿಸು.” ಈ ಒಂದು ವಾಕ್ಯ ಕೆಲ ಸಾರಿ ದಾರಿತಪ್ಪುವಿಕೆಗಳನ್ನು ಅರ್ಧಕ್ಕಿಂತ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಎರಡು ಪ್ರಾಂಪ್ಟ್ ಕಥೆ
- ಕಡಿಮೆಯಾದ ಪ್ರಾಂಪ್ಟ್: “ನನ್ನ CSV ಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ರಚಿಸು.”
ಫಲಿತಾಂಶ: ಒಂದು CSV (ಏಕವಚನ) ಸ್ವಚ್ಛಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್, ಕಾಂಮಾಗಳನ್ನು ಊಹಿಸುವದು, ಸೆಮಿಕೋಲನ್ಗಳಲ್ಲಿ ತೊಂದರೆ, Unicode ತಪ್ಪಿಸಿಕೊಳ್ಳುವದು 1999 ನಂತೆ.
- Claude Code ವಿಶೇಷ: “Python 3.11 ಸ್ಕ್ರಿಪ್ಟ್
clean_csv.py ರಚಿಸು:
- CLI ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳಾಗಿ ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಫೈಲ್ ಪಥಗಳನ್ನು ಸ್ವೀಕರಿಸುವದು
- ಡಿಲಿಮಿಟರ್ಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವದು (ಕಾಂਮਾ/ಸೆಮಿಕೋಲನ್/ಟ್ಯಾಬ್)
- ಹೆಡರ್ಗಳನ್ನು snake_case ನಲ್ಲಿ ಸಾಮಾನ್ಯೀಕರಿಸುವದು
- BOM ತೆಗೆದು ಹಿಡಿದು, ಶೇದ್ರತೆ ತೆಗೆದುಹಾಕುವದು
- ಕೊಟಿಂಗ್ ಉಳಿಸುವದು; UTF-8 ನ್ನು ನಿರ್ವಹಿಸುವದು
pytest ಜೊತೆ 3 ಮಾದರಿ ಫಿಕ್ಸ್ಚರ್ಗಳ ಪಟ್ಟಿಯುಳ್ಳ ಟೆಸ್ಟ್ಗಳನ್ನು ಸೇರಿಸುವದು
Makefile ಗುರಿ make test ಮತ್ತು make run ಒದಗಿಸುವದು.”
ಆ ಎರಡನೇದು ಸ್ವಯಂ ಸ್ಥಾಪಿತವಾಗುವ ಹಾಗೆ ಇದೆ.
ಕೋಡ್ ನಿರ್ವಹಣೆ: ಐದು ನಿಮಿಷಗಳಲ್ಲಿ, ಯಾವುದೇ ಕಷ್ಟವಿಲ್ಲದ ತಾಳಿಕೆ ಪಟ್ಟಿಕೆ
ನೀವು Claude ಕೋಡ್ ಪಡೆದಿದ್ದೀರಾ. ಈಗ ಏನು? ಇಲ್ಲಿದೆ ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಕ್ರಿಯಾಪದ್ಧತಿ, ಇದು 80% “ಚಾಲನೆಯಾಗುತ್ತಿಲ್ಲ” ಪಾತ್ರಗಳನ್ನೂ ನಿವಾರಿಸುತ್ತದೆ.
- Node ಇದ್ದರೆ: node_modules ಅಳಿಸಿ,
npm ci (ಅಥವಾ pnpm i --frozen-lockfile) ಚಾಲನೆ ಮಾಡಿ. Python ಇದ್ದರೆ: ಹೊಸ ವರ್ಚುಯಲ್ environment ಮಾಡಿ + pip install -r requirements.txt (ಅಥವಾ Poetry). Go ಇದ್ದರೆ: go mod tidy.
- ESLint/Prettier ಅಥವಾ Black/Ruff ಚಲಾಯಿಸಿ. ಅನುಸರಿಸಿ ಕಲ್ರೆ Claude ಗೆ ಕಾನ್ಫಿಗ್ರೇಶನ್ ಸೇರಿಸಲು ಕೇಳಿ. ನಿರಂತರ ಶೈಲಿ 'ಫ್ಯಾಂಟಮ್' ವ್ಯತ್ಯಾಸಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
- ಅಪ್ಲಿಕೇಶನ್ ಮೊದಲು ಟೆಸ್ಟ್ ಚಲಾಯಿಸಿ. ತಪ್ಪಾದರೆ, Claude ಗೆ ದೋಷಗಳನ್ನು ನಕಲಿಸಿ: “ನಿರ್ಣಯ ಮಾಡಿ ಮತ್ತು ಕನಿಷ್ಟ ಡಿಫ್ ನೀಡು.”
- Claude ನೀಡಿದ ನಿಖರ ಸ್ಟಾರ್ಟ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ. ಮರೆತು ಹೋಚಿದ್ರೆ, ಅದನ್ನು ಸೇರ್ಪಡೆ ಮಾಡಲು ಹೇಳಿ.
- ಮಾದರಿ curl ಅಥವಾ CLI ಇನ್ಪುಟ್ ಪೇಸ್ಟ್ ಮಾಡಿ. ಔಟ್ಪುಟ್ ಪರಿಶೀಲಿಸಿ. ಇಲ್ಲದಿದ್ದರೆ, ವ್ಯತ್ಯಾಸವನ್ನು Claude ಗೆ ನೀಡಿ, ಕೋಡ್ ಹಾಗೂ ಸ್ಪೆಕ್ ಹೊಂದಿಸಲು ಕೇಳಿ.
- ನಿಮ್ಮ ಬದಲಾವಣೆಗಳು ಸಣ್ಣಮಟ್ಟದಿರಲಿ. ಡಿಫ್ ಕೇಳಿ. ಟೆಸ್ಟ್ ಪುನರಾವರ್ತಿಸಿ. ಮರು ಎಂಬಿ. ಹೋಯಿತು ಹತ್ತು ಮಾತುಕತೆ: ಅನ್ಯಾಯವಾದರೂ ಜೀವ ಉಳಿಸುವ ಕೆಲಸ.
ಡೆಬಗಿಂಗ್ ನೃತ್ಯ: ದೋಷಗಳನ್ನು Claude ಗೆ ಹೇಗೆ ಹಂಚಿಕೊಳ್ಳುವುದು
Claude ನಿಮ್ಮದಾಗಿಯೇ ಕೆಲಸ ಮಾಡುವ ಪ್ರೋಗ್ರಾಮರ್ ಜೋಡಿ ಹಾಗೇ ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ನಿಮ್ಮ ಕೀಪಾಡ್ ನಲ್ಲಿಸುವುದಿಲ್ಲ.
- ಸರಿಯಾದ ದೋಷಗಳನ್ನು, ಸ್ಟ್ಯಾಕ್ ಟ್ರೇಸ್ ಮತ್ತು ಸಾಲಿನ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಪೇಸ್ಟ್ ಮಾಡಿ.
- ಬೇರೆಯಾಗುವ ಫೈಲ್ನ 20-40 ಸಾಲು ಸುತ್ತಲಿನ ಸಂಕೇತಗಳನ್ನು ಸೇರಿಸಿ.
- ನೀವು ಪರೀಕ್ಷಿಸಿರುವುದಾಗಿ ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಿ: “ನಾನು X ರನ್ ಮಾಡಿದೆ; Y ನಿರೀಕ್ಷಿಸಿದ್ದேನು; Z ಸಿಕ್ಕಿತು.”
- ಕನಿಷ್ಠ ಜೋಡಣೆಯನ್ನು ಕೇಳಿ: “ಕನಿಷ್ಠ ಡಿಫ್ ಪ್ಯಾಚ್ ನೀಡು.”
ಬೋನಸ್: ನಿಮ್ಮ OS ಮತ್ತು ಶೆಲ್ ತಿಳಿಸಿ. ಬಹುತೆಕ “ರಹಸ್ಯ” ದೋಷಗಳು Windows ಪಾತ್ ಮತ್ತು POSIX ಅಥವಾ zsh ಎಸ್ಕೇಪಿಂಗ್ ಸಮಸ್ಯೆಗಳು.
Claude ಮತ್ತು ವಾಸ್ತವ: ಮೂರು ಸಾಮಾನ್ಯ ಅಡ್ಡಿಬಾರ್ (ಮತ್ತು ಪರಿಹಾರ)
- ಲಕ್ಷಣ: ನೀವು ಇನ್ಸ್ಟಾಲ್ ಮಾಡದ ಗ್ರಂಥಾಲಯಕ್ಕೆ “ModuleNotFoundError”.
- ಪರಿಹಾರ: “package.json/requirements.txt ನಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡದ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಊಹಿಸಬೇಡಿ. ಅಗತ್ಯವಿದ್ದರೆ, ಎರಡು ಆಯ್ಕೆಗಳಿಗೆ ಪ್ರಯೋಜನ/ಅಪಾಯ ಸಂಭವಿಸುವುದು ಮತ್ತು ಅನುಮತಿ ಕೇಳಿ.”
- ಲಕ್ಷಣ: ಕೋಡ್ Express 5 API ಗಳು ಬಳಸುತ್ತಿದೆ ಆದರೆ ನೀವು 4.x ಬಳಕೆ ಮಾಡುತ್ತಿದ್ದೀರಿ.
- ಪರಿಹಾರ: “ಕೆವಲ Express 4.18 API ಗಳು ಬಳಸಿ; 5.x ಬೇಕಾದರೆ ಪರ್ಯಾಯ ಮತ್ತು ವಿವರಣೆ ನೀಡಿ.”
- ಅತಿಯಾದ ತಾಂತ್ರಿಕಗೊಳಿಸುವಿಕೆ
- ಲಕ್ಷಣ: ಎರಡು ಫ್ಯಾಕ್ಟರಿಗಳು, ವಿಸಿಟರ್ ಪ್ಯಾಟರ್ನ್, ಮತ್ತು ಸಣ್ಣ 'Hello' ಅಳವಡಿಕೆಯ ವೈಯಕ್ತಿಕ ಸಂಕಟ.
- ಪರಿಹಾರ: “ಪ್ರಾಮಾಣಿಕ ಲೈಬ್ರರಿ ಪ್ರಾಧಾನ್ಯ ನೀಡಿ; ಜೀವಂತಿಕೆ ಕಡಿಮೆಮಾಡಿ; 50 ಸಾಲುನಂತರ ಕಾರ್ಯಗಳನ್ನು ಜೋಡಿಸಬೇಡಿ; ಓದುಗೊಳ್ಳುವಿಕೆ ಮೇಲು.”
Claude ನ್ನು ನಿಮ್ಮ ಕೋಡ್ ವಿಮರ್ಶಕನಾಗಿಸಿ (ನೀವು ಇನ್ನೂ ನಿರ್ದೇಶಕರು)
ಇದನ್ನು ಪ್ರಯತ್ನಿಸಿ:
“ಕೆಳಗಿನ ಡಿಫ್ ಪರಿಶೀಲಿಸಿ: ಸ್ಪಷ್ಟತೆ, ಭದ್ರತೆ, ಕಾರ್ಯಕ್ಷಮತೆ, ಟೆಸ್ಟ್ಗಳಿಗೆ.
ಹಿಂತಿರುಗಿಸಿ:
- ವೇಗವಾಗಿ ಬದುಕು ನೀಡುವ 5 ಯೋಜನೆಗಳು
- ನನ್ನಲ್ಲಿ ಇಲ್ಲದ ಸೂಚಿಸಲಾದ ಯುನಿಟ್ ಟೆಸ್ಟ್ಗಳು
- ನಾನು PR ಗೆ ಪೇಸ್ಟ್ ಮಾಡಬಹುದಾದ ಸಂಕ್ಷಿಪ್ತ ಸ್ನೇಹಪೂರ್ಣ ಸಾರಾಂಶ.”
Claude ನಿಮ್ಮ ದೃಷ್ಟಿಪಥದಿಂದ ತಪ್ಪಿದ ವಿಷಯಗಳನ್ನು 5:52 ಸಂಜೆ ಹಿಡಿಯಬಹುದು, ಉದಾ: DB ಕುರ್ಸರ್ ಮುಚ್ಚಲು ಮರೆತಿರುವುದು ಅಥವಾ anyವನ್ನು ಯುಗಾದಿಹುಟ್ಟು ಹಿಂಸೆಗೆ ಬಳಸುವುದು.
ಸಂದರ್ಭ ವಿಂಡೋಗಳೊಂದಿಗೆ ಜೋಡಿ программಿಂಗ್: ಏನು ಸೇರಿಸಬೇಕು, ಏನು ಬಿಟ್ಟಿಡಬೇಕು
ಸಂದರ್ಭವು Claude ನ ಕೆಲಸದ ಸ್ಮೃತಿ. ಅದನ್ನು ಕೇರ್-ಆನ್ ಲಗೇಜ್ ಅಂತ ಭಾವಿಸಿ: ಅಮೂಲ್ಯ ಮತ್ತು ಸೀಮಿತ.
ಸೇರಿಸಲು:
- ನೀವು ಬದಲಾಯಿಸಲು ಬಯಸುವ ಫೈಲ್ (ಪೂರ್ಣ)
- ಅವಳ ಅವಪರ/import ಮಾಡುತ್ತಿರುವ ತಕ್ಷಣದ ನೆರವು ಫೈಲ್ಗಳು
- ರನ್ ಟೈಮ್ ರೂಪಿಸುವ ಕಾನ್ಫಿಗ್ (tsconfig, package.json, pyproject)
ಬಿಟ್ಟುಹೋಗಲು:
- ಬಿಲ್ಡ್ ಆರ್ಕಿಟೆಕ್ಟ್, ವುಂಡೆಡ್ ಡಿಪೆಂಡೆನ್ಸಿಗಳು, ಲಾಕ್ಫೈಲ್ಗಳು (ಇನ್ಸ್ಟಾಲ್ ಸಮಸ್ಯೆಗಳಿಗೆ ಹೊರತುಪಡಿಸಿ)
- ದೊಡ್ಡ ಡೇಟಾ ಫೈಲ್ಗಳು (ರಚನೆಯನ್ನು ಸಾರಾಂಶ ಮಾಡಿ ಬದಲು)
ನೀವು ದೊಡ್ಡ ರೆಪೊ ಅನ್ನು ಸಂಚಾಲಿಸಲು ಬಯಸಿದರೆ, ಮೊದಲು Claude ಗೆ ಮರುರೂಪಣೆಯ ಯೋಜನೆ ಕೇಳಿ. “ಮೂರು ಹಂತಗಳಲ್ಲಿ ಡಿಫ್ ಯೋಜನೆ ಮಾಡು. ಈಗ ಹಂತ 1 ನಿರ್ವಹಿಸೋಣ.”
ಭದ್ರತೆ, ಗೌಪ್ಯತೆ, ಮತ್ತು “ನಾನು ಇದನ್ನು ಪೇಸ್ಟ್ ಮಾಡಬೇಕೇ?” ಪ್ರಶ್ನೆ
Claude ನೀವು ಹಂಚಿಕೆಯೇನಿಲ್ಲದುವುದನ್ನು ಲೀಕ್ ಮಾಡಬಹುದು ಅಲ್ಲ. ಕೋಡ್ ಪೇಸ್ಟ್ ಮಾಡುವ ಮೊದಲು:
- ರಹಸ್ಯಗಳು ತೆಗೆದುಹಾಕಿ: API ಕೀ, ಟೋಕನ್, ಖಾಸಗಿ URL ಗಳು.
- ನಿಜವಾದ ಡೇಟಾ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ನಕಲಿ ಡೇಟಾ ಗೆ ಬದಲಿಸಿ.
- ನೀವು ನಿಯಂತ್ರಿತ ಪರಿಸರದಲ್ಲಿದ್ದರೆ, ಆನ್-ಪ್ರೇಮ್ ಅಥವಾ ಅನುಮೋದಿತ ಡಿಪ್ಲಾಯ್ಮೆಂಟ್ ಬಳಸಿ.
ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ಗೆ ನೀತಿ ಸೇರಿಸಿ: “ಎಲ್ಲಾ ಇನ್ಪುಟ್ಗಳಿಗೆ ಸಂವೇದಿ; ರಹಸ್ಯಗಳನ್ನು ಲಾಗ್ ಮಾಡಬೇಡಿ; ಪರಿಸರ ವ್ಯಾರುಗಳು ಸುರಕ್ಷಿತವಾಗಿ ಸಂಗ್ರಹಿಸುವ ಸ್ಥಳವನ್ನು ತೋರಿಸಿ.” Claude ಸಂತೋಷದಿಂದ ಪಾಲಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಅದು ಡೇಟಾ ಲೋಪಗಳನ್ನು ಇಷ್ಟಪಡದು.
Claude Code + ನಿಮ್ಮ ಉಪಕರಣಗಳು: ಸಂಯೋಜಿಸಿ ಚಲಿಸುವುದು
- Git ಜೊತೆ: Conventional Commits ಅನುಸರಿಸುವ ಸಂಯೋಜನೆ ಸಂದೇಶಗಳನ್ನು ಮತ್ತು GitHub ಗೆ ಪೇಸ್ಟ್ ಮಾಡಲು ಒಂದೆರಡು ಸಾಲಿನ ಸಾರಾಂಶ ಕೇಳಿ.
- Docker ಜೊತೆ: “ಸಣ್ಣ ಮತ್ತು ಉತ್ಪಾದನಾ ಸಿದ್ಧ ಡೋಕರ್ ಫೈಲ್ ಮತ್ತು ಮಲ್ಟಿ-ಸ್ಟೇಜ್ ಬಿಲ್ಡ್ ರಚಿಸಿ; ವ್ಯತ್ಯಾಸಗಳನ್ನು ವಿವರಿಸಲು.”
- CI ಜೊತೆ: “Node 20 ಮತ್ತು 22 ನಲ್ಲಿ ಟೆಸ್ಟ್ಗಳನ್ನು ನಡೆಸುವ GitHub Actions ವರ್ಕ್ಫ್ಲೋ ರಚಿಸಿ; ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡಿ; ಲಿಂಟ್ ವಿಫಲವಾದರೆ ನಿಲ್ಲಿಸು.”
- ದಾಖಲೆಗಳೊಂದಿಗೆ: “ನೀವು ಬರೆದ ಕೋಡ್ ಆಧರಿಸಿದ README ಸರಳ ಶುರು ಮತ್ತು ‘ಟ್ರಬಲ್ಶೂಟಿಂಗ್’ ವಿಭಾಗ ಬರೆಯಿರಿ.”
ಇದು ಕೇವಲ ಕೋಡ್ ರಚನೆಯಲ್ಲ; ಕಾಗದ ನೋವುಗಳಿಲ್ಲದೆ ಪ್ರಾಜೆಕ್ಟ್ ಸಿದ್ಧತೆಕೂಡ ಆಗುತ್ತದೆ.
Claude ನ್ನು ಎತ್ತಿ ನಂಬಿ ಮತ್ತು ಎப்போது ಜಾಗ್ರತೆ ಇರಲಿ
- Claude ನ್ನು ಕರಡು: CRUD ಹ್ಯಾಂಡ್ಲರ್ಗಳು, ಇನ್ಪುಟ್ ಪರಿಶೀಲನೆ, ಮೂಲಭೂತ ಪ್ರಾಮಾಣಿಕತೆ, CLI ಉಪಕರಣಗಳು, ರೂಪಾಂತರ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು, ಯುನಿಟ್ ಟೆಸ್ಟ್ಗಳು ರಚಿಸುವುದಕ್ಕಾಗಿ ನಂಬಿ.
- ಕೋಡ್ರಿಪ್ಟ್ಗಳು: ಕ್ರಿಪ್ಟೋಗ್ರಫಿ, ಪಾವತಿ ತಂತ್ರ, ಸಂಕೀರ್ಣ ಸಮ್ಮೇಳನ, ಯಾವುದೇ ಅನುಸರಣೆ ಅಗತ್ಯಗಳು, ಬೃಹತ್ ತಂತ್ರವನ್ನು ಕೇಳಿ ಮತ್ತು ಮಾನವ ಪರಿಶೀಲನೆಯೊಂದಿಗೆ ಯಶಸ್ವಿಯಾಗಿ ಅನುಷ್ಠಾನ ಮಾಡಿ.
ಸರಳ ನಿಯಮ: ನೀವು ಅನಧಿಕೃತ ಫೋರಂನ ಕೋಡ್ ನಕಲಿಸದಿದ್ದರೆ, AI ತಯಾರಿಸಿದ ಕೋಡ್ ಅನ್ನು ಅಂಧವಾಗಿ ಒಪ್ಪಿಕೊಳ್ಳಬೇಡಿ. Claude ಸಹಾಯಕರಾಗಿದ್ದು, ಜಾದೂಗಾರನು ಅಲ್ಲ.
ಲಘು ಮಾರ್ಗ: Sider.AI Claude ಚಕ್ರವನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ
ಇದು ಆಘಾತಕಾರಿ: Sider.AI ಬಹಳವಿಲ್ಲದಹಾಗಿದ್ದರೋ ಅದ್ಭುತವಾಗುತ್ತದೆ — ನೀವು ಅದು ನಿರ್ಮಿಸಿದ್ದಕ್ಕೆ ಗುರಿಯಾದರೆ. ನಿಮ್ಮ ಕಾರ್ಯಪಟು: “Claude ಗೆ ಪ್ರಾಂಪ್ಟ್, ಕೋಡ್ ರನ್, ದೋಷಗಳನ್ನು ಪೇಸ್ಟ್ ಮಾಡಿ, ಪುನರಾವರ್ತನೆ” ಆದರೆ Sider.AI ಕೋಡ್ ಜೊತೆಗೆ ಮಾತನಾಡುವ ಅನುಭವದ ಮೂಲಕ ಆ ಚಕ್ರವು ಗಟ್ಟಿಯಾಗುತ್ತದೆ. ಇದು ಫೈಲ್ಗಳನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು, ಸಂಭಾಷಣಾ ಸಂಧಿಗಳನ್ನು ಉಳಿಸಬಹುದು ಮತ್ತು ಆರು ಕಿಟಕಿ ನಡುವೆ ಹಾರಾಡದೆ ಬದಲಾವಣೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇದು ಸಂಪೂರ್ಣ ಅಲ್ಲ—ಯಾವುದೇ ಸಾಧನ ಸಂಪೂರ್ಣವಲ್ಲ—ಆದರೆ ಪ್ರಾಂಪ್ಟ್ ಇಂದ ಕಾರ್ಯಗತಿಗೆ ಚಕ್ರಗಳಲ್ಲಿ ಆರಾಮದಾಯಕ ಕೋಕ್ಪಿಟ್ ಆಗಿದೆ. ಸಣ್ಣ ಪಠ್ಯಪುತ್ತಳಿ: ನೀವು ವಾರಕ್ಕೆ ಹತ್ತಿರ ಉಪಯೋಗಿಸುವ ಐದು ಪ್ರಾಂಪ್ಟ್ಗಳು
“Node 20 + Express 4 TypeScript ಸೇವೆ ರಚಿಸಿ—POST /health ಮತ್ತು GET /version ಎಂಡ್ಪಾಯಿಂಟ್ಗಳೊಂದಿಗೆ. tsconfig, eslint, jest, npm ರಚನೆ/ಟೆಸ್ಟ್/ಆರಂಭ ಆಜ್ಞೆಗಳು, ಡೋಕರ್ಫೈಲ್ ಮತ್ತು GitHub Actions ಸೇರಿಸು. ಪರಿಶೀಲನೆಗಾಗಿ curl ಆಜ್ಞೆ ಒದಗಿಸು.”
“ಕೆಳಗಿನ ಫಂಕ್ಷನ್ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ಟೆಸ್ಟಬಿಲಿಟಿಗಾಗಿ ಮರುರೂಪಿಸು. ವರ್ತನೆ ಒಂದೇಲಿ ಇರಿ. 3 ಯುನಿಟ್ ಟೆಸ್ಟ್ ಸೇರಿಸಿ, ಅತಿ ಆಕಸ್ಮಿಕ ಕೇಸ್ಗಳನ್ನು ಹಿಡಿದಿಡಿ. ಪ್ರತಿ ಬದಲಾವಣೆಯ ವಿವರಣೆಯನ್ನು ಒಂದು ವಾಕ್ಯದಲ್ಲಿ ನೀಡಿ.”
- ಡೇಟಾಬೇಸ್ ಸ್ಕೀಮಾ + ಮೈಸ್ಗ್ರೇಷನ್ಗಳು
“PostgreSQL 15 ಸ್ಕೀಮಾ ರಚಿಸಿ: ಬಳಕೆದಾರರು, ನೋಟ್ಸ್, ಟ್ಯಾಗ್ಗಳು, note_tags. CREATE TABLE ಹೇಳಿಕೆಗಳು, ಸೂಚ್ಯಾಂಕಗಳು, ಮೈಸ್ಗ್ರೇಷನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಮಾದರಿ ಸೀಡ್ ಒದಗಿಸು. ಪ್ರಾತ್ಯಕ್ಷಿಕೆಗಾಗಿ ಸೂಚ್ಯಂಕಗಳನ್ನು ನ್ಯಾಯೋಚಿತಗೊಳಿಸಿ.”
“ಈ ನಿಧಾನವಾದ ಫಂಕ್ಷನ್ ಮತ್ತು ಅದರ ಪ್ರೊಫೈಲರ್ ರಿಪೋರ್ಟ್ ಆಧರಿಸಿ, ತ್ವರಿತ ಮಾರ್ಗಗಳನ್ನು ಸೂಚಿಸು. 2x ವೇಗ ಗುರಿಯಾಗಿರಲಿ. ಬೆಂಚ್ಮಾರ್ಕ್ ಹಾರ್ನೆಸ್ ನೀಡಿ ಮತ್ತು ವ್ಯತ್ಯಾಸಗಳನ್ನು ವಿವರಿಸು.”
“ಈ API ಗೆ ಇನ್ಪುಟ್ ಪರಿಶೀಲನೆ, ದರ ನಿಯಂತ್ರಣ, ವಿನಂತಿ ಲಾಗಿಂಗ್ ಸೇರಿಸು. ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಕಡಿಮೆ ಇರುವುದು. ಸುರಕ್ಷಿತ ಡೀಫಾಲ್ಟ್, ಪರಿಸರ ವ್ಯಾರು ಮೂಲಕ ಸಂರಚನೆ, ಮತ್ತು ಹಂತ ದರ ನಿಯಂತ್ರಣವನ್ನು ದೃಢಪಡಿಸುವ ಟೆಸ್ಟ್ಗಳು ಇರಲಿ.”
ನಕಲಿಸಿ, ಪೇಸ್ಟ್ ಮಾಡಿ, ಮರುಮಿಳಿಸಿ, ರವಾನಿಸು.
ಸಮಸ್ಯೆ ಪರಿಹಾರ ಪಕ್ಕಾಂಶ: Claude ದಾರಿತಪ್ಪಿದಾಗ
- ಲಕ್ಷಣ: ನೀವು ಒಂದು ಸಾಲು ಬದಲಾವಣೆ ಕೇಳಿದ್ದೀರಾ, ಆದರೆ ಅದು ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಫೈಲ್ ಮರುಬರೆಯುತ್ತದೆ.
ಪರಿಹಾರ: “ಬದಲಾಯಿಸಿದ ಸಾಲುಗಳ ಯುನಿಫೈಡ್ ಡಿಫ್ ಮಾತ್ರ ಒದಗಿಸಿ. ಕೋಡ್ ಬ್ಲಾಕ್ ಒಳಗೆ ಹೆಚ್ಚುವರಿ ಟಿಪ್ಪಣಿ ನೀಡಬೇಡಿ.”
- ಲಕ್ಷಣ: ತಪ್ಪು ಫ್ರೇಮ್ವರ್ಕ್ ಮಾದರಿಯನ್ನು ನಿರಂತರವಾಗಿ ಆರಿಸಿಕೊಂಡಿದೆ.
ಪರಿಹಾರ: “ಫೈಲಿನ ಪ್ರಸ್ತುತ ಶೈಲಿಯನ್ನು ಅನುಸರಿಸು. ನಾನು ಕೇಳದೇ ಇದ್ದರೆ ಕ್ಲಾಸುಗಳು/hooks/async ಗೆ ಪರಿವರ್ತಿಸಬೇಡಿ.”
- ಲಕ್ಷಣ: ನಿಮ್ಮ ಟೆಸ್ಟ್ಗಳನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ.
ಪರಿಹಾರ: “ಟೆಸ್ಟ್ಗಳನ್ನು ಸತ್ಯ ಮೂಲವನ್ನಾಗಿ ಮಾಡಿ; ಕೋಡ್ ಅವರಿಗೆ ತಕ್ಕಂತೆ ಹೊಂದಿಕೊಳ್; ಟೆಸ್ಟ್ಗಳು ಸ್ಪೆಕ್ ವಿರುದ್ಧವಾದರೆ, ಹೊಂದಿಕೆಯ ಮಾರ್ಗವನ್ನೇ ಸೂಚಿಸು.”
- ಲಕ್ಷಣ: ಅನುಮತಿಸಲಾದ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಬಳಸುತ್ತಿಲ್ಲ.
ಪರಿಹಾರ: “ಪ್ರಾಮಾಣಿಕ ಲೈಬ್ರರಿಯನ್ನು ಮಾತ್ರ ಬಳಸಿ. ಅಗತ್ಯವಿದ್ದರೆ, ಸ್ಥಗಿತ ಮಾಡಿ, ಎರಡು ಆಯ್ಕೆಗಳನ್ನು ಪ್ರಯೋಜನ/ಅಪಾಯಗಳೊಂದಿಗೆ ಒದಗಿಸಿ ಮತ್ತು ಅನುಮತಿ ಕೇಳಿ.”
ದೃಷ್ಟಾಂತ ಮಾಹಿತಿ ಕುರಿತ ಸೌಮ್ಯ ಮಾತು
Claude ನ್ನು ರಚಿಸಲು ಕೇಳಿ:
- ನಿಮ್ಮ ರೆಪೊನ ನಿಜವಾದ ಆಜ್ಞೆಗಳ ಅನುಕುರೂಪವಾದ-ತ್ವರಿತ ಪ್ರಾರಂಭ
- ನಿಮ್ಮ ಟೆಸ್ಟ್ ದೋಷಗಳಿಂದ ಉಂಟಾದ ‘ಟ್ರಬಲ್ಶೂಟಿಂಗ್’ ವಿಭಾಗ
- ಸುಕ್ರಿಲೇ ಮತ್ತು ಮರ್ಮಾರ್ಥಗಳನ್ನು ಇಂಗ್ಲಿಷ್ಗೆ ಅನುವಾದಿಸುವ ಶಬ್ದಕೋಶ
- ವಿವರಣೆ ಮಾತ್ರವಲ್ಲ, ಕಾರಣಕ್ಕೂ ಸ್ಪಷ್ಟತಾ ಅನುಸರಿಸಿ ಡೋಕ್ಯುಮೆಂಟ್ ಸ್ಟ್ರಿಂಗ್ಗಳು
ದಾಖಲೆಗಳು ಡೆಸರ್ಟ್ ಅಲ್ಲ; ಅವು ಪಾತ್ರೆ. ಇದು ಇಲ್ಲದಿರುವುದು ಗಮನ ಸೆಳೆಯುತ್ತದೆ.
ನೀವು ರವಾನಿಸುವ ಮುನ್ನ 10 ಸೆಕೆಂಡು ಪರೀಕ್ಷಾ ಪಟ್ಟಿಕೆ
- ಟೆಸ್ಟ್ಗಳು ಸ್ಥಳೀಯ ಮತ್ತು CI ಯಲ್ಲಿ ನಡೆಯುತ್ತವೆಯೇ?
- ಡಿಪೆಂಡೆನ್ಸಿಗಳು ಸೂಕ್ತ ಆವೃತ್ತಿಯ ಹಾಗೂ ಕಡಿಮೆಮಟ್ಟದಲ್ಲಿವೆಯೇ?
- ರೆಪೊ ಇತಿಹಾಸದಲ್ಲಿ ರಹಸ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಿದ್ದೀರಾ?
- ದೋಷ ಸಂದೇಶಗಳು ಸಹಾಯಕ (ಕ್ರಮ ಮತ್ತು ಸೂಚನೆ) ಮತ್ತು ಆಂತರಿಕ ದತ್ತಾಂಶ ಲீಕ್ ಮಾಡುತ್ತವೆಯೇ?
- ರೋಲ್ಬ್ಯಾಕ್ ಯೋಜನೆ ಅಥವಾ ವೈಶಿಷ್ಟ್ಯಧ್ವಜವಿದೆಯೇ?
ನೀವು ಅವುಗಳಿಗೆ ಹೌ ಎಂದು ಉತ್ತರಿಸದಿದ್ದರೆ, Claude ಗಾಗಿ ಸಹಾಯ ಕೇಳಿ. ನಾವು ತಡಮಾಡುವ ವಿಷಯಗಳನ್ನು ಬರೆಯಲು ಅದ್ಭುತವಾಗಿದೆ.
ಅಂತಿಮ ತೀರ್ಮಾನ: ನೀವು ಧ್ವನಿಯಾಗಿರು, Claude ನಿರ್ಮಿಸಿ― ನೀವು ಮಧ್ಯಸ್ಥ
Claude Code ಅನ್ನು ನಿದ್ರಿಸದ, ನಿಮ್ಮ ಕಸೂತಿಯಂತೆ ಆಕ್ಷೇಪಣೆ ಮಾಡದ ಪ್ರತಿಭಾವಂತರ ಜೂನಿಯರ್ ಡೆವಲಪರ್ನ್ನು ನೇಮಕಮಾಡಿದಂತೆ ಭಾವಿಸಬಹುದು. ನೀವು ಆವೃತ್ತಿಗಳು, ಉದಾಹರಣೆಗಳು, ನಿರ್ಬಂಧಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳ ಬಗ್ಗೆ ಸ್ಪಷ್ಟವಾಗಿದ್ದರೆ, ಅವನು ತಯಾರಿಸುವ ಕೋಡ್ ಮೊದಲ ಬಾರಿಗೆ ಕೆಲಸಮಾಡುತ್ತದೆ. ನೀವು ದೋಷಗಳನ್ನು ಸ್ಟ್ಯಾಕ್ ಟ್ರೇಸ್, ಸಂಕೇತ ತುಂಡು, ನಿರೀಕ್ಷಿತಕ್ಕಿಂತ ವ್ಯತ್ಯಾಸದಿಂದ ಫೀಡ್ ಬ್ಯಾಕ್ ಮಾಡಿದರೆ, ಇದು “AI ಊಹಿಸಲು” ಬದಲು “AI ಸಹಕಾರ” ಆಗುತ್ತದೆ.
ಹೀಗಾಗಿ ಸರಳ ನುಡಿಗೆ: ಸ್ಪಷ್ಟ ಪ್ರಾಂಪ್ಟ್ಗಳು, ಸೂಕ್ತ ಗಾರ್ಡ್ರೇಲ್, ಮೊದಲು ಟೆಸ್ಟ್ಗಳು, ಸಣ್ಣ ಲೂಪ್ಸ್ ಇವು. ಸ್ವಲ್ಪ ಶಂಕಾ ಹಾಗೂ Sider.AI ಜೊತೆ ಸಡಿಲ ಚಲನೆ ನೀಡಲು ಸೇರಿಸಿದರೆ, ನೀವು ಪ್ರಾಂಪ್ಟ್ ಇಂದ ಕೋಡ್ ಕಾರ್ಯಗತಿಗೆ ಕಣ್ಣೀರು ಬಾರದಂತೆ ಸಾಗಬಹುದು. ಆದರೆ, ಲಿಂಟರ್ ‘ಕಠಿಣ’ ಮರುವ್ಯವಸ್ಥೆಯಿದ್ದರೆ…ಒಂದು ಕಣ್ಣೀರೋದು ಸಾಧ್ಯ. ಒಂದು ಕೊನೆಯ ಮಾತು: ನಿಮ್ಮ ಉತ್ತಮ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ನಿಮ್ಮ ರೆಪೊದಲ್ಲಿ /prompts/claude.md ಎಂಬ ಫೈಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ. ಹಾಗಿದ್ದರೆ ಪ್ರತಿಯೊಂದು ಹೊಸ ಸದಸ್ಯ ಆದರೂ ಆರಂಭದ ಹಂತದಲ್ಲಿ ಸಹಾಯವಾಗುತ್ತದೆ, AI ಸಹ. ಭವಿಷ್ಯದ ನೀವು ಭೂತಕಾಲದ ನಿಮ್ಮನ್ನು ಕೈಹಿಡಿದುಗೊಳ್ಳುತ್ತೀರಿ, ಮತ್ತು ವರ್ತಮಾನ ನೀವು ಅಂತಿಮವಾಗಿ ಪ್ರಾರ್ಥನೆ ದಿನಭೋಜನಕ್ಕೇ ಬೇಕಾದರೆ ಹೋಗುತ್ತೀರಿ.
ಪೃಹ್ಛೆಗಳ ಉತ್ತರ
Q1: ವೇಗವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕೋಡ್ ಪಡೆಯಲು ಉತ್ತಮ Claude Code ಸಲಹೆಗಳು ಯಾವುವು?
ಆವೃತ್ತಿಗಳ ಬಗ್ಗೆ ನಿಖರವಾಗಿರಿ, ಇನ್ಪುಟ್/ಔಟ್ಪುಟ್ ಉದಾಹರಣೆಗಳನ್ನು ನೀಡಿರಿ ಮತ್ತು ಮೊದಲೇ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ರನ್ ಸೂಚನೆಗಳನ್ನು ಕೇಳಿರಿ. Claude ಅನ್ನು ಜಾಗರೂಕ ಸಹಯೋಗಿಯಾಗಿ ವರ್ತಿಸಿ: ಸಣ್ಣ ಬದಲಾವಣೆಗಳು, ನಿಖರವಾದ ದೋಷಗಳನ್ನು ಪೇಸ್ಟ್ ಮಾಡಿ ಮತ್ತು ಕ್ರಮವಾಗಿ ಸುಧಾರಿಸಿರಿ. ಈ Claude Code ಸಲಹೆಗಳು ಸಂಖ್ಯಾನೂತನವನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಪ್ರಾಂಪ್ಟ್ನಿಂದ ಕೋಡ್ ನಡನೆಗೆ ವೇಗವನ್ನು ನೀಡುತ್ತವೆ.
Q2: Claude ರಚಿಸುವ ಕೋಡ್ ಅನ್ನು ನಾನು ಹೇಗೆ ರನ್ ಮಾಡಿ ಪರಿಶೀಲಿಸಬಹುದು?
ನಿರ್ಭಂಧಗಳನ್ನು ಸ್ವಚ್ಛವಾಗಿ ಸ್ಥಾಪಿಸಿ, ಲಿಂಟ್/ಪರೀಕ್ಷೆಗಳು ನಡೆಸಿ, ನಂತರ ನಿಖರವಾದ ಪ್ರಾರಂಭ ಆದೇಶ ಮತ್ತು ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿ ಕೇಳಿದ ಮಾದರಿ ಕर्ल್ ಅನ್ನು ಬಳಸಿ ರನ್ ಮಾಡಿ. ಆದ್ಯತೆಗಳಿಗೆ ಹೊಂಚು ಕೊಡುವ ಫಲಿತಾಂಶವಿಲ್ಲದಿದ್ದರೆ, ವ್ಯತ್ಯಾಸವನ್ನು Claude ಗೆ ಪೇಸ್ಟ್ ಮಾಡಿ ಸಣ್ಣ ಬದಲಾವಣೆ ಮೂಲಕ ಅದನ್ನು ಸರಿಪಡಿಸುವಂತೆ ಕೇಳಿರಿ. ಸರಳ ಪರಿಶೀಲನೆ ಕ್ರಮಗಳು Claude ನ ಕೋಡನ್ನು ನಂಬಿಗಸ್ತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಷನ್ಗಳಾಗಿಸುತೆವೆ.
Q3: Claude ಯಿಂದ ಯಾದೃಚ್ಛಿಕ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರ್ಪಡೆ ಮಾಡಿಕೊಳ್ಳುವುದನ್ನು ನಾನು ಹೇಗೆ ನಿಲ್ಲಿಸಬಹುದು?
ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿ ನಿಯಮವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಿ: ಅನುಮೋದನೆ ಇಲ್ಲದೆ ಮಾತ್ರ ಮಾನದಂಡ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸು. ಅವಲಂಬನೆಯು ಅಗತ್ಯ ಎಂದು ತೋರೆತರೆ, Claude ನಿಂದ ನಿಲಿಸಿ, ಎರಡು ಆಯ್ಕೆಗಳು ಹಾಗೂ ಅವುಗಳ ಲಾಭ/ಹಾನಿಗಳನ್ನು ನೀಡುವಂತೆ ಕೇಳಿರಿ. ಈ ನಿಯಂತ್ರಣ Claude ನ ಕೋಡ್ ಅನ್ನು ಸೂಕ್ಷ್ಮವಾಗಿರಿಸಲು ಮತ್ತು ಅಚ್ಚರಿಯುತ ಆಮದುಗಳಿಂದ ತಪ್ಪಿಸಲು ಸಹಾಯಕ.
Q4: Claude ಡಿಬಗ್ ಮತ್ತು ಪರೀಕ್ಷೆಗಳ ಜೊತೆ ಸಹ ಸಹಾಯ ಮಾಡಬಹುದೇ?
ಖಂಡಿತವಾಗಿಯೂ—ಸ್ಟಾಕ್ ಟ್ರೇಸ್ಗಳನ್ನು, ವಿಫಲವಾಗಿರುವ ಪರೀಕ್ಷೆಗಳನ್ನು ಮತ್ತು ಸಂಬಂಧಿತ ಕೋಡ್ ತುಣುಕನ್ನು ಪೇಸ್ಟ್ ಮಾಡಿ ಕನಿಷ್ಠ ಪ್ಯಾಚ್ ಕೇಳಿರಿ. ವರ್ತನೆಗೆ ದಾಖಲೆ ಹಾಕುವ ಮತ್ತು ಪುನರಾವೃತ್ತಿಗಳನ್ನು ತಡೆಯುವ ಯುನಿಟ್ ಟೆಸ್ಟ್ಗಳನ್ನು ರಚಿಸುವಲ್ಲಿ Claude ಅತ್ಯುತ್ತಮ, ಇದು ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ನಿಂದ ಕಾರ್ಯಾಚರಣೆಯ ವಲಯವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ.
Q5: ಕೋಡ್ ಕೆಲಸವೊಂದಗೂ Claude ಜೊತೆಗೆ Sider.AI ಉಪಯುಕ್ತವೆಯೇ?
ಹೌದು—Sider.AI ಯ ಸೈಡ್-ಬೈ-ಸೈಡ್ ನಿಮ್ಮ ಕೋಡಿನೊಂದಿಗೆ ಚಾಟ್ ವ್ಯವಸ್ಥೆ ಸಂಧರ್ಭವನ್ನು ಕೈಯಲ್ಲಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಉಪಕರಣ ಬದಲಾವಣೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಅದು ಎಲ್ಲವನ್ನೂ ಸುಲಭಗೊಳಿಸುವ ಉಪಕರಣವಲ್ಲ, ಆದರೆ Claude Code ಸಲಹೆಗಳು ಮತ್ತು ಪ್ರಾಂಪ್ಟ್ನಿಂದ ಕೋಡ್ ನಡನೆಗೆ ತ್ವರಿತ ಪುನರಾವೃತ್ತಿಗೆ ಇದು ಒಂದಿಷ್ಟು ಆರಾಮದಾಯಕ ವಿಧಾನ. 
