ಕ್ಲಾಡ್ ಕೋಡ್ ಸ್ವಯಂಚಾಲಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನೈಜ ಪ್ರಕರಣವೊಂದರ ಆಧಾರದ ಮೇಲೆ, ಕೆಲವು ಪ್ರಾಂಪ್ಟ್ ಟಿಪ್ಪಣಿ ತಂತ್ರಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುವುದು

ಈ ಲೇಖನವು, ಒಂದು ನೈಜ ಪ್ರಕರಣದ ಮೂಲಕ, ನಿಮಗೆ ಕ್ಲಾಡ್ ಕೋಡ್ ನ ನೈಜ ಬಳಕೆಯ ಪ್ರಕರಣವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತದೆ. ಹಂಚಿಕೊಳ್ಳುವ ಮೊದಲು, ಒಂದು ಸಣ್ಣ ಸಮೀಕ್ಷೆ ಮಾಡೋಣ

ಮೂಲ ಅಗತ್ಯತೆ: ಒಬ್ಬ ಗೌರವಾನ್ವಿತ ಪಾವತಿಸುವ ಬಳಕೆದಾರರು, ನಾನು ಲೇಖನಗಳಲ್ಲಿ, ಲೇಖನದ ಬದಲಾವಣೆ ಸಮಯವನ್ನು ಸೇರಿಸಬೇಕೆಂದು ಬಯಸಿದ್ದರು

ಈ ಅಗತ್ಯತೆಯನ್ನು ಒಮ್ಮೆ ನೋಡಿದರೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸ್ವಲ್ಪ ಕಷ್ಟವಾಗಿದೆ. ಏಕೆಂದರೆ ನನ್ನ ವೆಬ್ಸೈಟ್ ಲೇಖನಗಳು, ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲ್ಪಟ್ಟಿಲ್ಲ, ಎಲ್ಲವೂ next.js ನ SSG ಅನ್ನು ಬಳಸಿ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಅದಕ್ಕೆ ನವೀಕರಣ ಸಮಯವೇ ಇಲ್ಲ.

ಇಲ್ಲಿ ಒಂದು ತಂತ್ರವೆಂದರೆ: ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವಾಗ, ನಾವು ಮೂಲ ಅಗತ್ಯತೆಯನ್ನು ನೇರವಾಗಿ Claude Code ಗೆ ನೀಡಬಾರದು, ಕೆಳಗಿನ ಕಾರಣಗಳಿಗಾಗಿ

1. ಮೂಲ ಅಗತ್ಯತೆ ತುಲನಾತ್ಮಕವಾಗಿ ಅಸ್ಪಷ್ಟವಾಗಿದೆ, ಅದು ತಪ್ಪಾಗಿ ಅರ್ಥೈಸಿಕೊಳ್ಳಬಹುದು, ಒಮ್ಮೆ ಅದು ತಪ್ಪಾಗಿ ಅರ್ಥೈಸಿಕೊಂಡರೆ, ಅಂತಿಮವಾಗಿ ಅದು ನಿಮಗೆ ಸಮಯವನ್ನು ಸೇರಿಸಿದರೂ, ಆ ಸಮಯವು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿರದೆ ಇರಬಹುದು

2. ಕ್ಲಾಡ್ ಕೋಡ್ ನ ಟೋಕನ್ ಬಳಕೆ ನಿಜವಾಗಿಯೂ ತುಂಬಾ ದುಬಾರಿಯಾಗಿದೆ, ಆದ್ದರಿಂದ, ಅಸ್ಪಷ್ಟ ಅಗತ್ಯತೆಯು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಟೋಕನ್ ಗಳನ್ನು ಅರ್ಥಹೀನವಾಗಿ ಬಳಸಲು ಕಾರಣವಾಗಬಹುದು

ಆದ್ದರಿಂದ, ನಾವು ಮೂಲ ಅಗತ್ಯತೆಯನ್ನು ಒಮ್ಮೆ ವಿಭಜಿಸಬೇಕು, ನಾನು ಮೊದಲು deepseek ನಲ್ಲಿ ಸಲಹೆ ಕೇಳಿದೆ, deepseek ನನಗೆ ಎರಡು ಯೋಜನೆಗಳನ್ನು ನೀಡಿತು

1. ಫೈಲ್ ನಿರ್ಮಾಣ ಸಮಯ, ಪ್ರತಿ ಬಾರಿ build ಮಾಡುವಾಗ, ನಮಗೆ ಫೈಲ್ ನ ನಿರ್ಮಾಣ ಸಮಯವನ್ನು ಪಡೆಯಬೇಕು, ಆದರೆ turbopack ನ ಪ್ಯಾಕೇಜಿಂಗ್ ತಂತ್ರವು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ, ಅದು ಪ್ರತಿ ಬಾರಿ ನಿರ್ಮಿಸುವಾಗ, ಫೈಲ್ ನ hash ಮೌಲ್ಯವು ಬದಲಾಗುತ್ತದೆ, ಈ ನಿರ್ಮಾಣ ಸಮಯವು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿರದೆ ಇರಬಹುದು

2. git ಸಲ್ಲಿಕೆ ಸಮಯ, ನಾನು ಯೋಚಿಸಿದೆ, ಇದು ತುಲನಾತ್ಮಕವಾಗಿ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿರಬೇಕು

ಸ್ಥೂಲ ಪರಿಹಾರ ದಿಕ್ಕನ್ನು ಪಡೆದ ನಂತರ, ನನಗೆ ಈ ಸರಳ ಪ್ರಾಂಪ್ಟ್ ಇತ್ತು: git ಸಲ್ಲಿಕೆ ಸಮಯವನ್ನು ಪ್ರತಿ .mdx ಲೇಖನದ ತಲೆಯಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡಿ

Claude Code ತುಲನಾತ್ಮಕವಾಗಿ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿದೆ, ಪ್ರಾಂಪ್ಟ್ ಟಿಪ್ಪಣಿ ನಿಖರವಾಗಿದ್ದರೆ, ಒಟ್ಟಾರೆಯಾಗಿ ಯಾವ ತೊಂದರೆಯೂ ಇಲ್ಲ, ಅದು ಕೇವಲ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸಿತು

7 ಡಾಲರ್ ನ ನನ್ನ ಕೋಟಾವನ್ನು ಖರ್ಚು ಮಾಡಿದ ನಂತರ, ಸುಮಾರು 20 ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಂಡು, ಅಂತಿಮವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಯಶಸ್ವಿಯಾಯಿತು.

ಯಾವುದೇ ಅನಿರೀಕ್ಷಿತ ಸಮಸ್ಯೆ ಇಲ್ಲದಿದ್ದರೆ, ಅನಿರೀಕ್ಷಿತ ಸಮಸ್ಯೆ ಉದ್ಭವಿಸಿತು, ಅದು 171 ಫೈಲ್ ಗಳ ಬದಲಾವಣೆಯನ್ನು ಬಿಟ್ಟುಬಿಟ್ಟಿತು.

ಇಲ್ಲಿ ಒಂದು ತೊಂದರೆಯ ಸ್ಥಳವೆಂದರೆ ಇಲ್ಲಿದೆ, ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿ ಬಿಟ್ಟುಬಿಟ್ಟ ಫೈಲ್ ಗಳು, ಕೇವಲ ಹೆಚ್ಚುವರಿ pass ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಮಾತ್ರ ಪಡೆದುಕೊಂಡಿವೆ, ಉಳಿದವುಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದೇ ಆಗಿವೆ

<PostLayout pass>...

ಆದರೆ ಅದು ಮಾರ್ಪಾಡು ಮಾಡಿಕೊಳ್ಳಲು ತಿಳಿದಿರಲಿಲ್ಲ, ಹೆಚ್ಚುವರಿಯಾಗಿ ಪಾಸ್ ಮಾಡಿದ ಈ ಹೆಚ್ಚುವರಿ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು, ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನವಾದ ಕಸ್ಟಮ್ ಕಾಂಪೋನೆಂಟ್ ಆಗಿ ವ್ಯಾಖ್ಯಾನಿಸಿತು. ನಂತರ ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸದೆ ಬಿಟ್ಟುಬಿಟ್ಟಿತು ～ ～

import Layout from 'components/post-layout';
import { getGitFileInfo } from '@/utils/git-info';
export default function Article({ children }: any) {
  const gitInfo = getGitFileInfo('src/app/your-path/page.mdx');
  return (
    
      {children}
    
  );
}

ಆದರೆ ನಿಜವಾದ ಪರಿಸ್ಥಿತಿಯೆಂದರೆ, ನನಗೆ ಬೇಕಾದ ಫಲಿತಾಂಶವು ಹೀಗಿದೆ, ಚಲಾಯಿಸಿದ ಫಲಿತಾಂಶವು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದೇ ಆಗಿದೆ.

import MdxLayout from 'components/mdx-layout';
export default function Article({ children }: any) {
  return (
    
      {children}
    
  );
}

ನಂತರ ಈ ಸಮಯದಲ್ಲಿ, ನಾನು ಪ್ರಾಂಪ್ಟ್ ಟಿಪ್ಪಣಿಯಲ್ಲಿ, ಒಂದು ತೊಂದರೆಯನ್ನು ಎದುರಿಸಿದೆ

ನಾನು ಮತ್ತೆ ಪ್ರಾಂಪ್ಟ್ ಟಿಪ್ಪಣಿಯನ್ನು ನಮೂದಿಸಿದೆ: ಮೇಲಿನಂತೆಯೇ ರೀತಿಯಲ್ಲಿ ಬಿಟ್ಟುಬಿಟ್ಟ 171 ಫೈಲ್ ಗಳನ್ನು ಮರುರೂಪಿಸಿ

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

ಈ ಸ್ವಲ್ಪ ಅಸ್ಪಷ್ಟತೆಯು, ನೇರವಾಗಿ ನನಗೆ ಬೇಡವಾದ ಯೋಜನೆಯ ಪ್ರಕಾರ ಅದು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸಲು ಕಾರಣವಾಯಿತು, ಮಧ್ಯೆ 2 ಬಾರಿ ದೋಷಗಳು ಸ್ವಯಂ-ಸರಿಪಡಿಸಿಕೊಂಡವು, ನನ್ನ ಟೋಕನ್ ಗಳನ್ನು ಬಲವಾಗಿ ನುಂಗಿತು, ಎರಡು ರೀತಿಯ ಅಸ್ಪಷ್ಟತೆಗಳು ಹೋರಾಡಲು ಪ್ರಾರಂಭಿಸಿ ದೋಷಕ್ಕೆ ಕಾರಣವಾಯಿತು.

ಅಂತಿಮವಾಗಿ ನಾನು ಮತ್ತೆ ಈ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ತ್ಯಜಿಸಬೇಕಾಯಿತು, ನನ್ನ ಅರ್ಥವನ್ನು ಮತ್ತೆ ಸ್ಪಷ್ಟಪಡಿಸಬೇಕಾಯಿತು.

ಸಾರಾಂಶ

1. ಪ್ರಾಂಪ್ಟ್ ಟಿಪ್ಪಣಿಯಲ್ಲಿ, ತುಲನಾತ್ಮಕವಾಗಿ ಸ್ಥಿರ ಮತ್ತು ನಿಖರವಾದ ಪರಿಹಾರ ಯೋಜನೆಯನ್ನು ಒಳಗೊಂಡಿರುವುದು ಉತ್ತಮ, AI ಯು ಕಡಿಮೆ ಯೋಚಿಸಿದಷ್ಟೂ ಉತ್ತಮ, ಇದು ಭ್ರಮೆಯ ದರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

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

3. ನೈಸರ್ಗಿಕ ಭಾಷೆಯ ನಿರ್ಬಂಧಗಳು ಕೋಡ್ ನಷ್ಟು ನಿಖರವಾಗಿರುವುದಿಲ್ಲ, ಪ್ರಾಂಪ್ಟ್ ಟಿಪ್ಪಣಿಯಲ್ಲಿ, ಫೈಲ್ ಹೆಸರು, ಕೋಡ್ ವೇರಿಯಬಲ್, ಕೋಡ್ ನ ವಿಶೇಷ ಪದಗಳು, ತಾಂತ್ರಿಕ ಪರಿಭಾಷೆಗಳು ಮುಂತಾದವುಗಳನ್ನು ಒಳಗೊಂಡಿರುವುದು, ಕ್ಲಾಡ್ ಕೋಡ್ ನ ಭ್ರಮೆಯನ್ನು ಬಹಳವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ