ଏକ ଅର୍କେଷ୍ଟ୍ରେଟର୍, ତିନୋଟି ସିଏଲ୍‌ଆଇ: କୋଡେକ୍ସ ଏବଂ ଜେମିନିକୁ ଦାୟିତ୍ୱ ଦେଲେ କଣ ସତରେ ଆପଣଙ୍କ କ୍ଲୋଡ୍ ଟୋକନ୍ ବଞ୍ଚିପାରିବ?

୨୦୨୬ ମସିହାରେ ବହୁତ ଡେଭେଲପର୍‌ମାନଙ୍କ ଭଳି, ମୁଁ ମଧ୍ୟ ଗୋଟିଏ ମେସିନ୍‌ରେ ତିନୋଟି AI କୋଡିଂ ସିଏଲ୍‌ଆଇ ଇନ୍‌ଷ୍ଟଲ୍ କରିଛି ଏବଂ ପ୍ରତ୍ୟେକଟି ଭିନ୍ନ କାରଣ ପାଇଁ ନିଜର ସ୍ଥାନ ବଜାୟ ରଖିଛି:

• କ୍ଲୋଡ୍ କୋଡ୍ (Claude Code) — ଅର୍କେଷ୍ଟ୍ରେଟର୍-ଗ୍ରେଡ୍ ଏଜେଣ୍ଟ୍। ମଲ୍ଟି-ଷ୍ଟେପ୍ ରିଜୋନିଂ, ଆର୍କିଟେକ୍ଚର୍, ଡିବଗିଂ ଏବଂ ଏକ ବଡ଼ କୋଡ୍‌ବେସ୍‌ରେ କାମ କରିବା ପାଇଁ ସର୍ବୋତ୍ତମ। ଏହାର ଟୋକନ୍‌ଗୁଡ଼ିକ ପାଇଁ ମଧ୍ୟ ମୁଁ ସବୁଠାରୁ ଅଧିକ ଯତ୍ନବାନ ଅଟେ।
• ଓପନ୍‌ଏଆଇ କୋଡେକ୍ସ ସିଏଲ୍‌ଆଇ (OpenAI Codex CLI) — ଏକ ଦକ୍ଷ କୋଡିଂ ଏଜେଣ୍ଟ୍ ଯାହାକୁ ଏକ ସଠିକ୍ ସ୍ପେକ୍ ସହିତ ଏକ ସୁଚିନ୍ତିତ, ସ୍ୱୟଂ-ନିର୍ଭରଶୀଳ କାର୍ଯ୍ୟ ଦେଲେ ଏହା ଅତି ଚମତ୍କାର କାମ କରେ।
• ଗୁଗଲ୍ ଜେମିନି ସିଏଲ୍‌ଆଇ (Google Gemini CLI) — ମଲ୍ଟିମୋଡାଲ୍ ୱାର୍କହର୍ସ। ଇମେଜ୍ ଜେନେରେସନ୍, ଅଡିଓ ଏବଂ ଟିଟିଏସ୍, ଟ୍ରାନ୍ସକ୍ରିପ୍ସନ୍ ଏବଂ ଉଚ୍ଚ ମାନର ଅନୁବାଦ, ବିଶେଷ କରି ଆଞ୍ଚଳିକ ଭାଷାଗୁଡ଼ିକ ପାଇଁ।

କିଛି ସମୟ ପରେ ଏକ ସାଧାରଣ ପ୍ରଶ୍ନ ଆସେ: ଏହି ତିନୋଟି ମଧ୍ୟରୁ ସବୁଠାରୁ ବୁଦ୍ଧିମାନଟି ଦିନସାରା ଚଲାଇବା ପାଇଁ ସବୁଠାରୁ ମହଙ୍ଗା ଅଟେ। ତେଣୁ ମୁଁ ଏହାକୁ ମ୍ୟାନେଜର୍କରିପାରିବି କି? କ୍ଲୋଡ୍‌କୁ ଏକ କାର୍ଯ୍ୟ ଦିଅ, ଏହାକୁ କାମ ବାଣ୍ଟିବାକୁ ଦିଅ, ଖଣ୍ଡଗୁଡ଼ିକ କୋଡେକ୍ସ ଏବଂ ଜେମିନିକୁ ଦିଅ ଏବଂ ସେମାନେ କାମ ଶେଷ ହେବା ପରେ ଏକ ମାର୍କଡାଉନ୍ ଫାଇଲ୍ ସହିତ ରିପୋର୍ଟ ଦିଅନ୍ତୁ — ଯେତେବେଳେ କି କ୍ଲୋଡ୍ କେବଳ କଷ୍ଟକର ଅଂଶ ଏବଂ ଚୂଡ଼ାନ୍ତ ସମୀକ୍ଷା ପାଇଁ ଟୋକନ୍ ଖର୍ଚ୍ଚ କରେ?

ମୁଁ ବର୍ତ୍ତମାନ ଏହି ପ୍ୟାଟର୍ଣ୍ଣକୁ ପ୍ରକୃତ କାର୍ଯ୍ୟର ସପ୍ତାହ ସପ୍ତାହ ଧରି ଚଲାଇଛି — ଏକ ସମ୍ପୂର୍ଣ୍ଣ ମାର୍କେଟିଂ-ସାଇଟ୍ ରିଡିଜାଇନ୍, ଏକାଧିକ ଏଆଇ-ଜେନେରେଟେଡ୍ ହିରୋ ଇମେଜ୍, ଆଠଟି ଭାଷାରେ ଅନୁବାଦ, ୟୁଟିଲିଟି ସ୍କ୍ରିପ୍ଟ୍, ବହୁଳ କଣ୍ଟେଣ୍ଟ୍ କାମ। ଏହି ପୋଷ୍ଟ୍‌ଟି ହେଉଛି ସମ୍ପୂର୍ଣ୍ଣ ନିୟମାବଳୀ: ପ୍ୟାଟର୍ଣ୍ଣଟି କିପରି କାମ କରେ, ମୁଁ ବ୍ୟବହାର କରୁଥିବା ସଠିକ୍ ପ୍ରମ୍ପ୍ଟ୍ ଆକାର, ରିପୋର୍ଟ ଚୁକ୍ତି ଯାହା ଏହାକୁ ସଠିକ୍ ରଖେ, ସଞ୍ଚୟ ପ୍ରକୃତରେ କେଉଁଠାରେ ଅଛି ଏବଂ ଦୁଇଟି ଲୁଚି ରହିଥିବା ଖର୍ଚ୍ଚ ଯାହା ସ୍ଥିର କରେ କି ଏହି ସବୁ କିଛି ମୂଲ୍ୟବାନ କି ନୁହେଁ।

ଛୋଟ ଉତ୍ତରଟି ହେଲା: ହଁ, ପ୍ୟାଟର୍ଣ୍ଣଟି କାମ କରେ, ଏବଂ ସଞ୍ଚୟଟି ପ୍ରକୃତ — କିନ୍ତୁ କେବଳ ଯଦି ଆପଣ ହ୍ୟାଣ୍ଡଅଫ୍‌ଗୁଡ଼ିକୁ ସଠିକ୍ ଭାବରେ ଇଞ୍ଜିନିୟରିଂ କରନ୍ତି। ଲମ୍ବା ଉତ୍ତରଟି ତଳେ ଥିବା ସବୁକିଛି ଅଟେ।

ପ୍ରଥମେ, ଆପଣ ପ୍ରକୃତରେ କେଉଁଥିପାଇଁ ଟଙ୍କା ଦେଉଛନ୍ତି ତାହା ବୁଝନ୍ତୁ

କୌଣସି ରଣନୀତି ଅର୍ଥପୂର୍ଣ୍ଣ ହେବା ପୂର୍ବରୁ, ଏକ ଏଜେଣ୍ଟିକ୍ ସିଏଲ୍‌ଆଇ ସେସନ୍‌ରେ ଟୋକନ୍‌ଗୁଡ଼ିକ କେଉଁଠାକୁ ଯାଏ ତାର ଏକ ସ୍ପଷ୍ଟ ଚିତ୍ର ଦରକାର। ପ୍ରାୟ ଚାରୋଟି ବକେଟ୍ ଅଛି:

1. ଇନ୍‌ପୁଟ୍ ଟୋକନ୍ (Input tokens) — ମଡେଲ୍ ପଢୁଥିବା ସବୁକିଛି: ଆପଣଙ୍କ ପ୍ରମ୍ପ୍ଟ୍, ଫାଇଲ୍ ବିଷୟବସ୍ତୁ, ଟୁଲ୍ ଆଉଟପୁଟ୍, ପୂର୍ବର ବାର୍ତ୍ତାଳାପ। ଏକ ଲମ୍ବା କୋଡିଂ ସେସନ୍‌ରେ ଏହା ଅନ୍ୟ ସବୁକିଛି ତୁଳନାରେ ବହୁତ ବଡ଼ ହୋଇଯାଏ, କାରଣ ଏଜେଣ୍ଟ୍ ପ୍ରତିଟି ପର୍ଯ୍ୟାୟରେ କଣ୍ଟେକ୍ସଟ୍ ପୁଣି ପଢ଼େ।
2. ଆଉଟପୁଟ୍ ଟୋକନ୍ (Output tokens) — ମଡେଲ୍ ଲେଖୁଥିବା ସବୁକିଛି: କୋଡ୍, ଗଦ୍ୟ, ଟୁଲ୍ କଲ୍। ସାଧାରଣତଃ ଇନ୍‌ପୁଟ୍ ଅପେକ୍ଷା ଏହାର ହାର ଅଧିକ ଥାଏ।
3. ରି-ରିଡ୍ସ (Re-reads) — ନୀରବ ଘାତକ। ପ୍ରତିଥର ଜଣେ ଏଜେଣ୍ଟ୍ ଏକ ୧,୦୦୦-ଲାଇନ୍ ଫାଇଲ୍ କୁ "କେବଳ କିଛି ଯାଞ୍ଚ କରିବା ପାଇଁ" ଖୋଲିଲେ, ଆପଣ ସେହି ୧,୦୦୦ ଲାଇନ୍ ପାଇଁ ପୁଣି ଥରେ ଇନ୍‌ପୁଟ୍ ଭାବରେ ମୂଲ୍ୟ ଦିଅନ୍ତି।
4. ରିୱାର୍କ (Rework) — କମ୍ପାଉଣ୍ଡିଂ ଘାତକ। ଏକ ଭୁଲ୍ ବୁଝାଯାଇଥିବା କାର୍ଯ୍ୟ ପାଇଁ ଆପଣଙ୍କୁ ପ୍ରଥମ ଚେଷ୍ଟା, ଏହାକୁ ଧରିଥିବା ସମୀକ୍ଷା ଏବଂ ଦ୍ୱିତୀୟ ଚେଷ୍ଟାର ମୂଲ୍ୟ ଦେବାକୁ ପଡେ।

ପ୍ରତିନିଧିତ୍ୱ (Delegation) ବକେଟ୍ ୧ ଏବଂ ୨ ଉପରେ ଆକ୍ରମଣ କରେ: ସବ୍-ଏଜେଣ୍ଟ୍‌ର ଜେନେରେସନ୍ ଘଟେ ଏହାର ବିଲ୍ ଉପରେ (ଏକ ଭିନ୍ନ ସବସ୍କ୍ରିପସନ୍, ଏକ ଶସ୍ତା ମଡେଲ୍ କିମ୍ବା ଏକ ମାଗଣା ଟିଅର୍), ଏବଂ ଅର୍କେଷ୍ଟ୍ରେଟର୍ କେବଳ ଏକ ସଂକ୍ଷିପ୍ତ ସାରାଂଶ ପଢ଼େ। କିନ୍ତୁ ଖରାପ ଭାବରେ କରାଯାଇଥିବା ପ୍ରତିନିଧିତ୍ୱ ବଢ଼ାଇଦିଏ ବକେଟ୍ ୩ ଏବଂ ୪ କୁ — ଏବଂ ଏହା ହିଁ ଏହି ପ୍ରବନ୍ଧର ସମ୍ପୂର୍ଣ୍ଣ ଟେନସନ୍।

ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପ୍ୟାଟର୍ଣ୍ଣ, ସଠିକ୍ ଭାବରେ ବ୍ୟାଖ୍ୟା କରାଯାଇଛି

ଏହାର ସରଳ ରୂପରେ ଆର୍କିଟେକ୍ଚର୍ ଏଠାରେ ଅଛି:

            ┌─────────────────────────┐
            │   YOU (one instruction)  │
            └───────────┬─────────────┘
                        ▼
            ┌─────────────────────────┐
            │  CLAUDE (orchestrator)   │
            │  plans · splits · specs  │
            │  reviews · integrates    │
            └─────┬──────────────┬────┘
        spec + exact output path │
              ▼                  ▼
   ┌─────────────────┐  ┌─────────────────┐
   │  CODEX (coder)   │  │ GEMINI (media)   │
   │ scoped modules,  │  │ images, audio,   │
   │ tests, boiler-   │  │ translation      │
   │ plate, scripts   │  │                  │
   └────────┬────────┘  └────────┬────────┘
            │  artifacts → disk   │
            │  report.md (≤40 ln) │
            ▼                     ▼
            ┌─────────────────────────┐
            │  CLAUDE reads reports,   │
            │  verifies, fixes/retries │
            │  or integrates & ships   │
            └─────────────────────────┘

ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଚାରୋଟି ଜିନିଷର ମାଲିକାନା ନିଏ ଏବଂ କେବଳ ଚାରୋଟି ଜିନିଷ: ଏହି ଯୋଜନା (plan), ଏହି ସ୍ପେକ୍ସ (specs), ଏହି ସମୀକ୍ଷା (review), ଏବଂ ଏହି ଇଣ୍ଟିଗ୍ରେସନ୍ (integration)। ଅନ୍ୟ ସବୁକିଛି ବଡ଼ ଏବଂ ଯାନ୍ତ୍ରିକ ଜିନିଷକୁ ତଳକୁ ଠେଲି ଦିଆଯାଏ, ଦୁଇଟି ଅପରିବର୍ତ୍ତନୀୟ ନିୟମ ସହିତ:

ନିୟମ ୧ — ଆର୍ଟିଫାକ୍ଟ୍‌ଗୁଡ଼ିକ ଏକ ସଠିକ୍ ପାଥ୍‌ରେ ଡିସ୍କକୁ ଯାଏ। ସବ୍-ଏଜେଣ୍ଟ୍ କେବେବି ବାର୍ତ୍ତାଳାପରେ ଏହାର ଆଉଟପୁଟ୍ ପେଷ୍ଟ କରେ ନାହିଁ। ଏହା ଫାଇଲ୍ ଲେଖେ। ଅର୍କେଷ୍ଟ୍ରେଟର୍‌ର କଣ୍ଟେକ୍ସଟ୍ ପରିଷ୍କାର ରହେ।

ନିୟମ ୨ — ଉତ୍ତରଟି ପ୍ରାୟ କିଛି ବି ନୁହେଁ। ଆଦର୍ଶଗତ ଭାବରେ ଗୋଟିଏ ଶବ୍ଦ ସହିତ ଏକ ଛୋଟ ମାର୍କଡାଉନ୍ ରିପୋର୍ଟ। ଅର୍କେଷ୍ଟ୍ରେଟର୍ କେବଳ ରିପୋର୍ଟଟି ପଢିବାର ନିଶ୍ଚିତତା ରହିଛି। କେବଳ ଏତିକି ହିଁ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପଢ଼ିବାକୁ ଗ୍ୟାରେଣ୍ଟି ଦିଆଯାଇଛି।

ଯଦି ଆପଣ ଏହି ପ୍ରବନ୍ଧରୁ ଆଉ କିଛି ମନେ ନ ରଖନ୍ତି: ପ୍ରତିନିଧିତ୍ୱ ପ୍ରମ୍ପ୍ଟ୍ ଏବଂ ରିପୋର୍ଟ ହେଉଛି କେବଳ ଦୁଇଟି ସ୍ଥାନ ଯେଉଁଠାରେ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଏକ ପ୍ରତିନିଧିତ୍ୱ କରାଯାଇଥିବା କାର୍ଯ୍ୟରେ ଟୋକନ୍ ଖର୍ଚ୍ଚ କରେ। ବାକି ସବୁକିଛି ଅନ୍ୟ କାହାର ବିଲ୍। ଆପଣଙ୍କର ସମ୍ପୂର୍ଣ୍ଣ ଅପ୍ଟିମାଇଜେସନ୍ ସର୍ଫେସ୍ ହେଉଛି ଏହି ଦୁଇଟି ଡକ୍ୟୁମେଣ୍ଟ୍।

ୱାକ୍‌ଥ୍ରୁ #୧: ଇମେଜ୍ ଜେନେରେସନ୍‌କୁ ଜେମିନିକୁ ହସ୍ତାନ୍ତର କରିବା

ଏହା ମୁଁ ଚଲାଉଥିବା ସର୍ବୋଚ୍ଚ-ମୂଲ୍ୟର ପ୍ରତିନିଧିତ୍ୱ, କାରଣ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ସତରେ ଏହା କରିପାରିବ ନାହିଁ — କ୍ଲୋଡ୍ କୋଡ୍ ପଛରେ କୌଣସି ଇମେଜ୍ ମଡେଲ୍ ନାହିଁ। କ୍ଲୋଡ୍ ଲେଖୁଥିବା ଏବଂ ଜେମିନି ସିଏଲ୍‌ଆଇ ରେ ଫାୟାର୍ କରୁଥିବା ପ୍ରମ୍ପ୍ଟ୍‌ର ପ୍ରକୃତ ଆକାର ଏଠାରେ ଅଛି:

Generate a single photorealistic editorial corporate portrait.
Concept: <detailed art direction — subject, pose, wardrobe,
lighting, background, composition>.

CRITICAL: the entire subject must be fully inside the frame with
generous margin on all sides — do not crop arms or held objects.
Plain seamless light-grey studio background for easy cutout.
No text, no watermark, no logos, no props.

Save the image to /tmp/work/hero-cyber.png (overwrite if it exists).
Then reply only DONE.

ଏହି ପ୍ରମ୍ପ୍ଟ୍‌ରେ ଥିବା ଇଞ୍ଜିନିୟରିଂ ପ୍ରତି ଧ୍ୟାନ ଦିଅନ୍ତୁ:

• ଆଉଟପୁଟ୍ ପାଥ୍ ସଠିକ୍ ଅଟେ। କୌଣସି "ଏହାକୁ କେଉଁଠାରେ ସେଭ୍ କରନ୍ତୁ" ନାହିଁ — ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଠିକ୍ ଜାଣେ କେଉଁଠାରେ ଦେଖିବ, ତେଣୁ କୌଣସି ଆଗପଛ ନାହିଁ।
• "କେବଳ DONE ଉତ୍ତର ଦିଅନ୍ତୁ।" ଜେମିନି ସିଏଲ୍‌ଆଇ ଆନନ୍ଦରେ ୪୦୦ ଟୋକନ୍ ପାଇଁ ନିଜର ସୃଜନଶୀଳ ପ୍ରକ୍ରିୟା ବର୍ଣ୍ଣନା କରିବ। ଆମେ ଏହା ଚାହୁଁନାହୁଁ। ଗୋଟିଏ ଶବ୍ଦ।
• ପ୍ରତିବନ୍ଧକଗୁଡ଼ିକ ଯାନ୍ତ୍ରିକ ଭାବରେ ବର୍ଣ୍ଣନା କରାଯାଇଛି ("ସମ୍ପୂର୍ଣ୍ଣ ରୂପେ ଫ୍ରେମ୍ ଭିତରେ," "କୌଣସି ୱାଟରମାର୍କ ନାହିଁ") କାରଣ ଆପଣ ଲେଖୁନଥିବା ପ୍ରତ୍ୟେକ ପ୍ରତିବନ୍ଧକ ନାହିଁ ଏହା ଏକ ରିୱାର୍କ ରୁଲେଟ୍ ସ୍ପିନ୍ ଅଟେ। ମୁଁ ସେହି ପ୍ରତ୍ୟେକ ଲାଇନ୍‌କୁ ଏକ ବିଫଳତାରୁ ଶିଖିଲି — ଏହା ବିଷୟରେ ତଳେ ଅଧିକ ଦିଆଯାଇଛି।

ତାପରେ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଏକ କ୍ୱାଲିଟି ଗେଟ୍ ଚଲାଏ ଇମେଜ୍ କୁ ଦେଖିବା ପୂର୍ବରୁ — ଏକ ଶସ୍ତା, ଯାନ୍ତ୍ରିକ ଯାଞ୍ଚ:

# does the file exist and is it non-trivial?
test -s /tmp/work/hero-cyber.png || echo "FAILED: missing/empty"

# entropy gate: catches blank/placeholder images without
# spending any model tokens at all
python3 -c "
from PIL import Image; import sys
img = Image.open('/tmp/work/hero-cyber.png')
# a flat placeholder has near-zero entropy; a real photo is > 4
print(img.entropy())
"

ଗେଟ୍ ପାସ୍ ହେବା ପରେ ହିଁ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପ୍ରକୃତରେ ଦେଖେ ଇମେଜ୍ କୁ ଥରେ — ଗୋଟିଏ ଭିଜନ୍ କଲ୍ — ଯାହା ଏକ ସ୍କ୍ରିପ୍ଟ୍ କରିପାରିବ ନାହିଁ ତାହା ଯାଞ୍ଚ କରିବା ପାଇଁ: କମ୍ପୋଜିସନ୍, ଆର୍ଟିଫାକ୍ଟ୍ସ, ବ୍ରାଣ୍ଡ୍-ସେଫ୍ଟି। ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପାର୍ଶ୍ୱରେ ଏହା ହେଉଛି ସମ୍ପୂର୍ଣ୍ଣ ଟୋକନ୍ ମୂଲ୍ୟ: ଗୋଟିଏ ଛୋଟ ପ୍ରମ୍ପ୍ଟ୍ ବାହାରକୁ, ଗୋଟିଏ ଶବ୍ଦ ଫେରିଆସେ, ଗୋଟିଏ ଇମେଜ୍ ଭ୍ୟୁ।

ଏଗୁଡ଼ିକୁ ବ୍ୟାକଗ୍ରାଉଣ୍ଡ୍‌ରେ ଚଲାନ୍ତୁ। ଇମେଜ୍ କାମ ଏକରୁ ପାଞ୍ଚ ମିନିଟ୍ ନେଇଥାଏ। ଏକ ବ୍ଲକିଂ ୱେଟ୍ ର ଅର୍ଥ ହେଉଛି ଆପଣଙ୍କ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଏହାର ସମ୍ପୂର୍ଣ୍ଣ କଣ୍ଟେକ୍ସଟ୍ ମେମୋରୀରେ ଧରି ଖାଲି ବସିଥାଏ। କାମ ଆରମ୍ଭ କରନ୍ତୁ, ଅନ୍ୟ କାମ ସହିତ ଆଗକୁ ବଢ଼ନ୍ତୁ, ଫାଇଲ୍ ଆସିବା ପରେ ଫେରି ଆସନ୍ତୁ। ପ୍ରତ୍ୟେକ ଗମ୍ଭୀର ଏଜେଣ୍ଟ୍ ସିଏଲ୍‌ଆଇ ବର୍ତ୍ତମାନ ବ୍ୟାକଗ୍ରାଉଣ୍ଡିଂ ସମର୍ଥନ କରୁଛି; ଏହାକୁ ବ୍ୟବହାର କରନ୍ତୁ।

ୱାକ୍‌ଥ୍ରୁ #୨: କୋଡିଂ କାର୍ଯ୍ୟ କୋଡେକ୍ସକୁ ଦେବା

କୋଡିଂ ହସ୍ତାନ୍ତର ଅଧିକ କଷ୍ଟକର, କାରଣ ଫେଲ୍ୟୁର୍ ମୋଡ୍ ଏକ ଖରାପ ଇମେଜ୍ ନୁହେଁ ଯାହାକୁ ଆପଣ ଏକ ଝଲକରେ ଦେଖିପାରିବେ — ଏହା ଯୁକ୍ତିଯୁକ୍ତ ଲାଗୁଥିବା କୋଡ୍ ଯାହା ଆପଣଙ୍କ କୋଡ୍‌ବେସ୍‌ରେ ଖାପ ଖାଏ ନାହିଁ। ସମାଧାନ ହେଉଛି ଏକ ସ୍ପେକ୍ ଏତେ କଠିନ ଯେ "ସମ୍ପୂର୍ଣ୍ଣ" ହେଉଛି ମେସିନ୍-ଯାଞ୍ଚଯୋଗ୍ୟ:

TASK: Write a standalone Node script at scripts/import-legacy.mjs

SPEC:
- Reads ./data/legacy-export.csv (papaparse is already a dependency)
- Maps columns per the table below … (exact mapping)
- Writes ./data/import-ready.json, an array of objects
- Node 22, ESM, no new dependencies
- Handle: missing fields → skip row + count; duplicate IDs → last wins

ACCEPTANCE (all must pass):
- node scripts/import-legacy.mjs runs clean on the sample file
- node --test tests/import-legacy.test.mjs passes (write these tests)
- npx eslint scripts/import-legacy.mjs → zero errors

REPORT: write REPORT-import.md (max 40 lines) with status, files
created, how to verify, and up to 5 gotchas. Do not paste file
contents into the report.

ତିନୋଟି ଗୁଣ ଏହାକୁ ହସ୍ତାନ୍ତରଯୋଗ୍ୟ କରିଥାଏ ଯେଉଁଠାରେ ଅଧିକାଂଶ କୋଡିଂ କାର୍ଯ୍ୟ ହୋଇନଥାଏ:

1. ସ୍ୱୟଂ-ସମ୍ପୂର୍ଣ୍ଣ (Self-contained) — ଗୋଟିଏ ନୂତନ ଫାଇଲ୍, ବିଦ୍ୟମାନ ମଡ୍ୟୁଲ୍‌ରେ କୌଣସି ପରିବର୍ତ୍ତନ ନାହିଁ, କୌଣସି ଆର୍କିଟେକ୍ଚରାଲ୍ ନିଷ୍ପତ୍ତି ନାହିଁ।
2. ମେସିନ୍-ଯାଞ୍ଚଯୋଗ୍ୟ ଗ୍ରହଣଯୋଗ୍ୟତା — ଅର୍କେଷ୍ଟ୍ରେଟର୍ ତିନୋଟି କମାଣ୍ଡ୍ ସହିତ ଯାଞ୍ଚ କରେ, କୋଡ୍‌କୁ ଲାଇନ୍-ବାଇ-ଲାଇନ୍ ପଢି ନୁହେଁ।
3. ସୀମିତ ଇଣ୍ଟରଫେସ୍ (Bounded interface) — ଇନ୍‌ପୁଟ୍ ଫାଇଲ୍, ଆଉଟପୁଟ୍ ଫାଇଲ୍, ସମ୍ପୂର୍ଣ୍ଣ। ସବ୍-ଏଜେଣ୍ଟ୍ କୋଡ୍‌ବେସ୍‌ର ବାକି ଅଂଶରେ ବୁଲି ପାରିବ ନାହିଁ।

ଯେତେବେଳେ ରିପୋର୍ଟ ଆସେ, ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଏକ୍ସେପ୍ଟାନ୍ସ କମାଣ୍ଡ୍ସ ଚଲାଏ (ଶସ୍ତା), ଗଟ୍‌ଚାସ୍ ଉପରେ ନଜର ପକାଏ (ଶସ୍ତା), ଏବଂ ଯଦି କିଛି ବିଫଳ ହୁଏ କିମ୍ବା ଭୁଲ ଲାଗେ ତେବେ କେବଳ ପ୍ରକୃତ କୋଡ୍ ଖୋଲେ। ଏକ କ୍ଲିନ୍ ପାସ୍ ଉପରେ, ଅର୍କେଷ୍ଟ୍ରେଟର୍ କେବେବି ସେହି ୩୦୦ ଲାଇନ୍ ପଢେ ନାହିଁ ଯାହା ଏହା ଅନ୍ୟଥା ଲେଖିଥାନ୍ତା — ତାହା ହିଁ ସଞ୍ଚୟ।

ସଞ୍ଚୟ ପ୍ରକୃତରେ କେଉଁଠାରେ ଅଛି — ମୋଟାମୋଟି ହିସାବ ସହିତ

୧. ବଲ୍କ୍ ଜେନେରେସନ୍ (Bulk generation)। ଧରିନିଅନ୍ତୁ ଏକ କାର୍ଯ୍ୟ ୨,୦୦୦ ଲାଇନ୍‌ର ଆଉଟପୁଟ୍ ଦିଏ (~୨୫k ଟୋକନ୍)। ସିଧାସଳଖ କଲେ, ଅର୍କେଷ୍ଟ୍ରେଟର୍ ~୨୫k ଆଉଟପୁଟ୍ ଟୋକନ୍ ଏବଂ ଏହାର ଚାରିପାଖରେ ଥିବା ସମସ୍ତ କଣ୍ଟେକ୍ସଟ୍ ପଢିବାର ମୂଲ୍ୟ ଦିଏ। ପ୍ରତିନିଧିତ୍ୱ କରାଗଲେ, ଅର୍କେଷ୍ଟ୍ରେଟର୍ ମୂଲ୍ୟ ଦିଏ: ଏକ ~୩୦୦-ଟୋକନ୍ ସ୍ପେକ୍, ଏକ ~୪୦୦-ଟୋକନ୍ ରିପୋର୍ଟ ପଠନ, ଏବଂ ଯାଞ୍ଚ କମାଣ୍ଡ୍ ପାଇଁ କିଛି ଶହ ଟୋକନ୍। ଏହାକୁ କୁହନ୍ତୁ ~୩୦k ବିପକ୍ଷରେ ~୧k ଟୋକନ୍ — ଏକ ୯୫%+ ହ୍ରାସ ସେହି କାର୍ଯ୍ୟ ଉପରେ, ଯେଉଁଥିରେ ଜେନେରେସନ୍ ନିଜେ ସବ୍-ଏଜେଣ୍ଟ୍‌ର କୋଟାକୁ ବିଲ୍ କରାଯାଏ।

୨. ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଯେକୌଣସି ପ୍ରକାରେ କରିପାରିବ ନାହିଁ। ପ୍ରତ୍ୟେକ ଇମେଜ୍, ପ୍ରତ୍ୟେକ ଅଡିଓ ଫାଇଲ୍, ଆଠ-ଭାଷାର ଅନୁବାଦ ବ୍ୟାଚ୍‌ର ପ୍ରତ୍ୟେକଟି ଯାହା ମୁଁ ନିକଟରେ ଦେଇଛି, ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଲେଖିଥିବା ଏକ ସ୍ପେକ୍‌ରୁ ଜେମିନି ସିଏଲ୍‌ଆଇ ଦ୍ୱାରା ତିଆରି କରାଯାଇଥିଲା। ତୁଳନା କରିବାକୁ କୌଣସି କ୍ଲୋଡ୍-ନେଟିଭ୍ ବିକଳ୍ପ ନାହିଁ — ଏହା ହେଉଛି ଶୁଦ୍ଧ ଦକ୍ଷତା ଲାଭ, ଏବଂ ଟୋକନ୍ ମୂଲ୍ୟ ହେଉଛି କେବଳ ସ୍ପେକ୍ + ରିପୋର୍ଟ।

୩. ଏକ ସଠିକ୍ ସ୍ପେକ୍ ସହିତ ଲମ୍ବା ଯାନ୍ତ୍ରିକ ଆଉଟପୁଟ୍। ଟେଷ୍ଟ୍ ସ୍କାଫୋଲ୍ଡିଂ, ଡାଟା ମାଇଗ୍ରେସନ୍, ବଏଲରପ୍ଲେଟ୍ ମଡ୍ୟୁଲ୍, ଫର୍ମାଟ୍ କନଭର୍ସନ୍, ଏକ ଆଉଟଲାଇନ୍‌ରୁ ଡକ୍ ଡ୍ରାଫ୍ଟ୍। ଏକ ସାଧାରଣ ସୂତ୍ର: କମ୍ ବିଚାର, ଅଧିକ ପରିମାଣ (low judgment, high volume)। ଆଉଟପୁଟ୍ ଟୋକନ୍ ଠିକ୍ ଭାବରେ ପରିମାଣର ମୂଲ୍ୟ ନିର୍ଦ୍ଧାରଣ କରେ; ବିଚାର ହେଉଛି ତାହା ଯାହା ଶସ୍ତା ଏଜେଣ୍ଟ୍‌ରେ ନଥାଏ। ପରିମାଣକୁ ହସ୍ତାନ୍ତର କରନ୍ତୁ, ବିଚାରକୁ ରଖନ୍ତୁ।

ସଞ୍ଚୟ କେଉଁଠାରେ ଉଭେଇ ଯାଏ — ଦୁଇଟି ଟ୍ୟାକ୍ସ ଏବଂ ଗୋଟିଏ ଓଭରହେଡ୍

ଯାଞ୍ଚ ଟ୍ୟାକ୍ସ (The verification tax)

ଏହା ହେଉଛି ସେହି ମୂଲ୍ୟ ଯାହାକୁ କେହି ହିସାବ କରନ୍ତି ନାହିଁ, ତେଣୁ ମୁଁ ଆପଣଙ୍କୁ ମୋ ନିଜ ପ୍ରୋଜେକ୍ଟ୍‌ରୁ ରସିଦ୍ ଦେଉଛି — ଏକ ୱେବସାଇଟ୍ ପାଇଁ ଏଆଇ-ଜେନେରେଟେଡ୍ ହିରୋ ପୋର୍ଟ୍ରେଟ୍‌ର ଏକ ବ୍ୟାଚ୍:

• ଗୋଟିଏ ଇମେଜ୍ ଆସିଲା ଯେଉଁଥିରେ ପ୍ରତିଦ୍ୱନ୍ଦ୍ୱୀଙ୍କର ଚିହ୍ନିହେଲା ଭଳି ଲାପଟପ୍ ଲୋଗୋ ସଟ୍‌ରେ ଛପା ହୋଇଥିଲା। ଆଇନଗତ ଏବଂ ବ୍ରାଣ୍ଡ୍ ଦୃଷ୍ଟିରୁ ଏହାକୁ ବ୍ୟବହାର କରିହେବ ନାହିଁ। ପୁନଃ ସୃଷ୍ଟି କରନ୍ତୁ — ନା ଅପେକ୍ଷା କରନ୍ତୁ, ପ୍ରକୃତରେ ଏହାକୁ ପ୍ୟାଚ୍ କରି କାଢ଼ନ୍ତୁ ଏକ ଇମେଜ୍ ଟୁଲ୍ ସହିତ, ତାପରେ ପୁନଃ-ଯାଞ୍ଚ କରନ୍ତୁ।
• ଆଉ ଏକ ସେଟ୍‌ରେ କୋଣଗୁଡ଼ିକ ଥିଲା ଯାହା ଟ୍ରାନ୍ସପାରେଣ୍ଟ ବୋଲି ଦାବି କରୁଥିଲା କିନ୍ତୁ ନଥିଲା — ଏକ ଅସ୍ପଷ୍ଟ ପାଖାପାଖି ଧଳା ଯାହା କେବଳ ରଙ୍ଗୀନ ବ୍ୟାକଗ୍ରାଉଣ୍ଡ୍‌ରେ ଦେଖାଯାଉଥିଲା। ବିଳମ୍ବରେ ଧରାପଡ଼ିଲା, ଫ୍ଲଡ୍-ଫିଲ୍ ପାସ୍ ସହିତ ଠିକ୍ କରାଗଲା, ପୁନଃ-ଯାଞ୍ଚ କରାଗଲା।
• ତୃତୀୟଟିରେ ଥିବା ପ୍ରଡକ୍ଟ୍ ଟାବଲେଟ୍ ଅଧା ଫ୍ରେମ୍ ବାହାରେ ଜେନେରେଟ୍ ହୋଇଥିଲା — ମଡେଲ୍ ସେହି ବସ୍ତୁଟିକୁ କ୍ରପ୍ କରିଦେଲା ଯାହାକୁ ଦେଖାଇବା ପାଇଁ ଇମେଜ୍ ଟି ଥିଲା। ଏକ ନୂତନ "ସବୁକିଛି ସମ୍ପୂର୍ଣ୍ଣ ରୂପେ ଫ୍ରେମ୍ ଭିତରେ" ପ୍ରତିବନ୍ଧକ ଲାଇନ୍ ସହିତ ସମ୍ପୂର୍ଣ୍ଣ ପୁନଃ-ସୃଷ୍ଟି।

ସେହି ପ୍ରତ୍ୟେକ ଇମେଜ୍ ପାସ୍ କଲା ଶସ୍ତା ଯାନ୍ତ୍ରିକ ଗେଟ୍‌ଗୁଡ଼ିକୁ। ତଥାପି ପ୍ରତ୍ୟେକଟି ପାଇଁ ଅର୍କେଷ୍ଟ୍ରେଟର୍‌କୁ ପ୍ରକୃତରେ ଦେଖିବା, ବିଚାର କରିବା ଏବଂ ଏକ ଫିକ୍ସ୍ ରାଉଟ୍ କରିବା ଦରକାର ଥିଲା। ପ୍ରତିନିଧିତ୍ୱ ସମୀକ୍ଷା ପଦକ୍ଷେପକୁ ହଟାଇଲା ନାହିଁ — ଏହା ଜେନେରେସନ୍ ମୂଲ୍ୟକୁ ଅନ୍ୟ କେଉଁଠାକୁ ଘୁଞ୍ଚାଇଲା ଏବଂ ସମୀକ୍ଷା ମୂଲ୍ୟକୁ ଠିକ୍ ସେହିଠାରେ ଛାଡିଦେଲା ଯେଉଁଠାରେ ଏହା ଥିଲା।

ଏବଂ ଯେତେବେଳେ ଏକ ପ୍ରତିନିଧିତ୍ୱ କରାଯାଇଥିବା କାର୍ଯ୍ୟ ସମୀକ୍ଷାରେ ବିଫଳ ହୁଏ, ଆପଣ ଦିଅନ୍ତି ତିନି ଗୁଣ: ପ୍ରତିନିଧିତ୍ୱ, ଏହାକୁ ଧରିଥିବା ସମୀକ୍ଷା ଏବଂ ରିଡୁ। ସମାନ କାର୍ଯ୍ୟର ଦୁଇଟି ବିଫଳ ପ୍ରତିନିଧିତ୍ୱ ସାଧାରଣତଃ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପ୍ରଥମ ଥର ସିଧାସଳଖ କରିବା ଅପେକ୍ଷା ଅଧିକ ମୂଲ୍ୟ ନେଇଥାଏ। ସେଥିପାଇଁ ମୋର ଇମେଜ୍ ପ୍ରମ୍ପ୍ଟ୍‌ରେ ଥିବା ପ୍ରତ୍ୟେକ ପ୍ରତିବନ୍ଧକ ଲାଇନ୍ ଏକ କ୍ଷତ ପରି ପଢାଯାଏ — ପ୍ରତ୍ୟେକଟି ହେଉଛି ଗୋଟିଏ।

ବଜେଟ୍ ନିୟମ: ଧରିନିଅନ୍ତୁ ଯେ ୨୦-୩୦% ପ୍ରତିନିଧିତ୍ୱ କରାଯାଇଥିବା ସୃଜନଶୀଳ କାର୍ଯ୍ୟ ଏକ ଫିକ୍ସ୍ ସାଇକେଲ୍ ଦରକାର କରେ, ଏବଂ ତାହାକୁ ଆପଣଙ୍କ ନିଷ୍ପତ୍ତିରେ ମୂଲ୍ୟାୟନ କରନ୍ତୁ। ଯଦି କାର୍ଯ୍ୟଟି ଯାଞ୍ଚ କରିବା ଶସ୍ତା ଅଟେ (ଟେଷ୍ଟଗୁଡ଼ିକୁ ଚଲାନ୍ତୁ, ଫାଇଲ୍ ଯାଞ୍ଚ କରନ୍ତୁ), ରିୱାର୍କ ସହିତ ମଧ୍ୟ ପ୍ରତିନିଧିତ୍ୱ ଜିତେ। ଯଦି ଯାଞ୍ଚର ଅର୍ଥ ହେଉଛି "ସବୁକିଛି ଧ୍ୟାନର ସହିତ ପଢନ୍ତୁ," ସଞ୍ଚୟ ଏକ ଭ୍ରମ ଥିଲା।

ଇଣ୍ଟିଗ୍ରେସନ୍ ଟ୍ୟାକ୍ସ (The integration tax)

ଯଦି କାର୍ଯ୍ୟଟି ଅନେକ ଫାଇଲ୍‌କୁ ଛୁଏଁ, ଆପଣଙ୍କ କୋଡ୍‌ବେସ୍‌ର ନିୟମାବଳୀ ସହିତ ମେଳ ଖାଇବା ଆବଶ୍ୟକ, କିମ୍ବା ଅର୍କେଷ୍ଟ୍ରେଟର୍‌ର ମୁଣ୍ଡରେ ଥିବା କଣ୍ଟେକ୍ସଟ୍ ଉପରେ ନିର୍ଭର କରେ — ଆର୍କିଟେକ୍ଚର୍ ନିଷ୍ପତ୍ତି, ଏକ କ୍ରସ୍-ମଡ୍ୟୁଲ୍ ରିଫ୍ୟାକ୍ଟର୍, ଏକ ରେସ୍-କଣ୍ଡିସନ୍ ଡିବଗ୍ — ଏହାକୁ ହସ୍ତାନ୍ତର କରିବା ଏକ ମିଥ୍ୟା ଅର୍ଥନୀତି। ସବ୍-ଏଜେଣ୍ଟ୍ ପାଖରେ ଆପଣଙ୍କ କଣ୍ଟେକ୍ସଟ୍ ନାହିଁ; ସବ୍-ଏଜେଣ୍ଟ୍ ଛୁଇଁଥିବା ସବୁକିଛିକୁ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଶେଷରେ କେବଳ ସୁରକ୍ଷିତ ଭାବରେ ଇଣ୍ଟିଗ୍ରେଟ୍ କରିବା ପାଇଁ ପୁଣି ପଢ଼େ। ଆପଣ ସମାନ ବୁଝାମଣା ପାଇଁ ଦୁଇଥର ଟଙ୍କା ଦେଇଛନ୍ତି: ଥରେ ସବ୍-ଏଜେଣ୍ଟ୍ ଏହାର ନିଜସ୍ୱ ଆଂଶିକ ଚିତ୍ର ତିଆରି କରିବା ପାଇଁ, ଥରେ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ସମ୍ପୂର୍ଣ୍ଣ ଚିତ୍ର ପୁନଃନିର୍ମାଣ କରିବା ପାଇଁ।

କହିବା ସରଳ ଅଟେ: ଯଦି ସ୍ପେକ୍ ଲେଖିବା ପାଇଁ ଆପଣଙ୍କ ଆର୍କିଟେକ୍ଚର୍ ବୁଝାଇବା ଆବଶ୍ୟକ, ତେବେ କାର୍ଯ୍ୟଟି ଦିଅନ୍ତୁ ନାହିଁ। କେବଳ ସ୍ପେକ୍-ଲେଖିବା ସଞ୍ଚୟ ଅପେକ୍ଷା ଅଧିକ ମୂଲ୍ୟ ନିଏ, ଏବଂ ଭୁଲ ବୁଝାମଣାର ବିପଦ ବହୁତ ବଡ଼।

ଓଭରହେଡ୍ ଫ୍ଲୋର୍

ଏକ ଭଲ ପ୍ରତିନିଧିତ୍ୱ ପ୍ରମ୍ପ୍ଟ୍ ଲେଖିବାକୁ ୨୦୦-୪୦୦ ଟୋକନ୍ ଖର୍ଚ୍ଚ ହୁଏ। ଏକ ରିପୋର୍ଟ ପଢିବାକୁ ୩୦୦-୫୦୦ ଟୋକନ୍ ଖର୍ଚ୍ଚ ହୁଏ। ଯାଞ୍ଚ କରିବା, ଆଉ କିଛି ଶହ। ତେଣୁ ଏକ ଫ୍ଲୋର୍ ଅଛି: ଯଦି କାର୍ଯ୍ୟର ସିଧାସଳଖ ଖର୍ଚ୍ଚ ପ୍ରାୟ ୧,୦୦୦-୨,୦୦୦ ଟୋକନ୍ (~୫୦-୧୦୦ ଲାଇନ୍ ଆଉଟପୁଟ୍) ରୁ କମ୍, ଏହାକୁ ପ୍ରତିନିଧିତ୍ୱ କରିବା ପ୍ରତିଥର ଟଙ୍କା ନଷ୍ଟ କରେ। କେବଳ ଏହାକୁ କରନ୍ତୁ।

ମାର୍କଡାଉନ୍ ରିପୋର୍ଟ ଚୁକ୍ତି — ଯେଉଁଠାରେ ସଞ୍ଚୟ ବଞ୍ଚେ କିମ୍ବା ମରେ

ଅଧିକାଂଶ ଲୋକଙ୍କ ପାଇଁ ଏହି ପ୍ୟାଟର୍ଣ୍ଣକୁ କ୍ଲିକ୍ କରୁଥିବା ଧାରଣା ହେଉଛି ରିପୋର୍ଟ ଫାଇଲ୍: ପ୍ରତ୍ୟେକ ସବ୍-ଏଜେଣ୍ଟ୍ ଶେଷ କରେ ଏବଂ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପାଇଁ ଏକ ମାର୍କଡାଉନ୍ ସାରାଂଶ ପକାଇଦିଏ। ଏହା ସଠିକ୍ ପ୍ରବୃତ୍ତି ଅଟେ — ଏବଂ ଏହା ଠିକ୍ ସେହିଠାରେ ଯେଉଁଠାରେ ସମ୍ପୂର୍ଣ୍ଣ ଯୋଜନାଟି ଚୁପଚାପ୍ ବିଫଳ ହୁଏ। ଯଦି କୋଡେକ୍ସ ଏକ ୫୦୦-ଲାଇନ୍ ରିପୋର୍ଟ ଲେଖେ ଏବଂ କ୍ଲୋଡ୍ ଏହାର ସବୁତକ ପଢ଼େ, ଆପଣ ଯେକୌଣସି ପ୍ରକାରେ ମୂଲ୍ୟ ଦେଲେ — କେବଳ ଲେଖିବା ବଦଳରେ ପଢିବାରେ।

ଏଠାରେ ଏକ ଖରାପ ରିପୋର୍ଟ ଅଛି (ଯଦି ଆପଣ ସେମାନଙ୍କୁ ପ୍ରତିବନ୍ଧିତ ନ କରନ୍ତି ତେବେ ଏଜେଣ୍ଟମାନେ ଏହା ହିଁ ଉତ୍ପାଦନ କରନ୍ତି):

ଏକ ୩୪୦-ଲାଇନ୍ ପ୍ରବନ୍ଧ: କାର୍ଯ୍ୟକୁ ପୁନର୍ବାର କୁହେ, ପ୍ରତ୍ୟେକ ନିଷ୍ପତ୍ତିକୁ କ୍ରମାନୁସାରେ ବର୍ଣ୍ଣନା କରେ, ଏହା ତିଆରି କରିଥିବା ଦୁଇଟି ଫାଇଲ୍‌ର ସମ୍ପୂର୍ଣ୍ଣ ବିଷୟବସ୍ତୁକୁ "ରେଫରେନ୍ସ ପାଇଁ" ପେଷ୍ଟ କରେ, ସମ୍ପୂର୍ଣ୍ଣ ଟେଷ୍ଟ ଆଉଟପୁଟ୍ ଅନ୍ତର୍ଭୁକ୍ତ କରେ, ଏବଂ ଭବିଷ୍ୟତର ଉନ୍ନତି ପାଇଁ ସତର୍କବାଣୀ ଏବଂ ପରାମର୍ଶର ତିନୋଟି ପାରାଗ୍ରାଫ୍ ସହିତ ଶେଷ ହୁଏ।

କୋଡ୍ ଲେଖିବା ଅପେକ୍ଷା ତାହା ପଢିବା ପାଇଁ ଅଧିକ ଖର୍ଚ୍ଚ ହୁଏ। ଏଠାରେ ଚୁକ୍ତିଟି ଅଛି ଯାହାକୁ ମୁଁ ବଦଳରେ ଲାଗୁ କରେ:

# Task: import-legacy script
Status: DONE
Files created:
  - scripts/import-legacy.mjs
  - tests/import-legacy.test.mjs
How to verify:
  - node --test tests/import-legacy.test.mjs
  - node scripts/import-legacy.mjs && head data/import-ready.json
Gotchas:
  - 14 rows in the sample CSV had no email; skipped, count logged
  - CSV dates are DD/MM/YYYY, not ISO — parser handles both

ଏବଂ ଚାରୋଟି ନିୟମ ଯାହା ପ୍ରତ୍ୟେକ ରିପୋର୍ଟକୁ ଏହି ଆକାରରେ ରଖେ:

1. ହାଡ୍ କ୍ୟାପ୍: ୪୦ ଲାଇନ୍। ଏହାକୁ ପ୍ରତିନିଧିତ୍ୱ ପ୍ରମ୍ପ୍ଟ୍‌ରେ କୁହନ୍ତୁ। ଷ୍ଟାଟସ୍, ପାଥ୍ସ, ଭେରିଫାଏ କମାଣ୍ଡ୍ସ, ଗଟ୍‌ଚାସ୍ — ଆଉ କିଛି ନୁହେଁ।
2. ପାଥ୍ସ, କେବେବି ବିଷୟବସ୍ତୁ ନୁହେଁ। ଆର୍ଟିଫାକ୍ଟ୍‌ଗୁଡ଼ିକ ଡିସ୍କରେ ଥାଏ; ରିପୋର୍ଟ ସେଗୁଡ଼ିକୁ ସୂଚାଏ। ଅର୍କେଷ୍ଟ୍ରେଟର୍ କେବଳ ସେତେବେଳେ ଏକ ଫାଇଲ୍ ଖୋଲେ ଯେତେବେଳେ ଯାଞ୍ଚ ଏହା ଦାବି କରେ — ଦୁଇଥର ପଢିବା ଏକ ବିକଳ୍ପହୋଇଯାଏ, ଏକ ଡିଫଲ୍ଟ୍ ନୁହେଁ।
3. ଶୁଦ୍ଧ ଜେନେରେସନ୍ ପାଇଁ "କେବଳ DONE ଉତ୍ତର ଦିଅନ୍ତୁ"। ଯେତେବେଳେ ଆର୍ଟିଫାକ୍ଟ୍ ନିଜ ପାଇଁ କହେ (ଏକ ଇମେଜ୍, ଏକ ଅଡିଓ ଫାଇଲ୍), ଏପରିକି ଏକ ରିପୋର୍ଟ ମଧ୍ୟ ବହୁତ ଅଧିକ। ଫାଇଲ୍ ଆସେ, ଗୋଟିଏ ଶବ୍ଦ ଫେରିଆସେ, ଗେଟ୍ ଚାଲେ।
4. ପ୍ରତ୍ୟେକ ସ୍ପେକ୍‌ରେ ମେସିନ୍-ଯାଞ୍ଚଯୋଗ୍ୟ ଗ୍ରହଣଯୋଗ୍ୟତା ମାନଦଣ୍ଡ। "ଏହାକୁ ଭଲ କରନ୍ତୁ" ରିୱାର୍କ ସୃଷ୍ଟି କରେ। "ସମସ୍ତ ଟେଷ୍ଟ୍ ପାସ୍, ଜିରୋ ଲିଣ୍ଟ୍ ଏରର୍, ଆଉଟପୁଟ୍ ହେଉଛି ୨୦୦ KB ରୁ କମ୍ ଏକ ୧୨୦୦x୬୩୦ JPEG" ଏକ ପାସ୍/ଫେଲ୍ ସୃଷ୍ଟି କରେ ଯାହାକୁ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଗୋଟିଏ କମାଣ୍ଡ୍‌ରେ ଯାଞ୍ଚ କରେ। ଆପଣଙ୍କ ଗ୍ରହଣଯୋଗ୍ୟତା ମାନଦଣ୍ଡର ଗୁଣବତ୍ତା ହିଁ ଆପଣଙ୍କ ପ୍ରତିନିଧିତ୍ୱର ଗୁଣବତ୍ତା ଅଟେ।

କାର୍ଯ୍ୟର ବିଭାଜନ: କିଏ କଣ ପାଏ, ଏବଂ କାହିଁକି

କାର୍ଯ୍ୟ	ଏହାକୁ ଦିଅନ୍ତୁ	କାହିଁକି
ଇମେଜ୍, ଅଡିଓ/ଟିଟିଏସ୍, ଟ୍ରାନ୍ସକ୍ରିପ୍ସନ୍	ଜେମିନି ସିଏଲ୍‌ଆଇ — ସର୍ବଦା	ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଏଗୁଡିକ ଆଦୌ କରିପାରିବେ ନାହିଁ; ଶୁଦ୍ଧ ଲାଭ
ଅନୁବାଦ (ବିଶେଷକରି ଆଞ୍ଚଳିକ ଭାଷାଗୁଡ଼ିକ)	Gemini CLI	ଦୃଢ ଗୁଣବତ୍ତା, ଉଚ୍ଚ ପରିମାଣ, ନମୁନା ସଂଗ୍ରହ ଦ୍ୱାରା ସହଜରେ ଯାଞ୍ଚଯୋଗ୍ୟ
ଏକ କଠୋର ସ୍ପେକ୍ ସହିତ ସ୍ୱୟଂ-ସମ୍ପୂର୍ଣ୍ଣ ସ୍କ୍ରିପ୍ଟ/ମଡ୍ୟୁଲ୍	Codex CLI	ଉଚ୍ଚ ପରିମାଣ, କମ୍ ବିଚାର, ମେସିନ୍-ଦ୍ୱାରା ଯାଞ୍ଚଯୋଗ୍ୟ
ଟେଷ୍ଟ୍ ସ୍କାଫୋଲ୍ଡିଂ, ମାଇଗ୍ରେସନ୍, ବଏଲର୍‌ପ୍ଲେଟ୍	Codex CLI	ଯାନ୍ତ୍ରିକ ଆଉଟପୁଟ୍; ଗ୍ରହଣଯୋଗ୍ୟତା = ଟେଷ୍ଟ୍ ଗୁଡ଼ିକ ନିଜେ
ଆର୍କିଟେକ୍ଚର୍ & ଡିଜାଇନ୍ ନିଷ୍ପତ୍ତି	Claude — କେବେବି ପ୍ରତିନିଧିତ୍ୱ ଦିଅନ୍ତୁ ନାହିଁ	ଶୁଦ୍ଧ ବିଚାର; ସ୍ପେକ୍ ର ମୂଲ୍ୟ କାର୍ଯ୍ୟ ଅପେକ୍ଷା ଅଧିକ ହେବ
ମଲ୍ଟି-ଫାଇଲ୍ ରିଫ୍ୟାକ୍ଟର୍, ଇଣ୍ଟିଗ୍ରେସନ୍ କାର୍ଯ୍ୟ	Claude	ଇଣ୍ଟିଗ୍ରେସନ୍ ଟ୍ୟାକ୍ସ ପ୍ରତିନିଧିତ୍ୱକୁ ଏକ ମିଥ୍ୟା ଅର୍ଥନୀତିରେ ପରିଣତ କରେ
ଡିବଗିଂ	Claude	ସଞ୍ଚିତ ପ୍ରସଙ୍ଗ ଆବଶ୍ୟକ କରେ; ସବ୍-ଏଜେଣ୍ଟ୍ ଶୂନରୁ ଆରମ୍ଭ କରେ
ପ୍ରତିନିଧିତ୍ୱ ଦିଆଯାଇଥିବା ସବୁକିଛିର ଅନ୍ତିମ ସମୀକ୍ଷା	Claude	ପ୍ରିମିୟମ୍ ମଡେଲ୍ ପାଇଁ ଆପଣ ଯେଉଁ କାମ ପାଇଁ ଅର୍ଥ ପ୍ରଦାନ କରୁଛନ୍ତି, ଏହା ପ୍ରକୃତରେ ସେହି କାମ

ଉଲ୍ଲେଖ କରିବା ଯୋଗ୍ୟ ଗୋଟିଏ ସୂକ୍ଷ୍ମ କଥା: ଏହା ନୁହେଁ ଯେ "Claude ଭଲ, ଅନ୍ୟମାନେ ଖରାପ।" ଏହା ହେଉଛି ପରିମାଣ ବନାମ ବିଚାର. Codex ଚମତ୍କାର ସ୍ୱୟଂ-ସମ୍ପୂର୍ଣ୍ଣ କୋଡ୍ ଲେଖେ; Gemini ର ଚିତ୍ର ଏବଂ ଅନୁବାଦ ଗୁଣବତ୍ତା ପ୍ରକୃତ ଉତ୍ପାଦନ କାର୍ଯ୍ୟ ବହନ କରେ। ବିଭାଜନ ହେଉଛି ପ୍ରତ୍ୟେକ ସିଟ୍ ର ମୂଲ୍ୟ କେତେ ଏବଂ ପ୍ରତ୍ୟେକ କାର୍ଯ୍ୟ ପାଇଁ କ'ଣ ଆବଶ୍ୟକ।

ଅପରେସନାଲ୍ ପ୍ଲେବୁକ୍

କିଛି ଅଭ୍ୟାସ ଯାହା ସଞ୍ଚୟକୁ ବୃଦ୍ଧି କରେ:

ମନ୍ଥର ହେଉଥିବା ସବୁକିଛିକୁ ବ୍ୟାକଗ୍ରାଉଣ୍ଡ୍ ରେ ଚଲାନ୍ତୁ। ଜେନେରେସନ୍ କାର୍ଯ୍ୟଗୁଡ଼ିକ ଏକରୁ ପାଞ୍ଚ ମିନିଟ୍ ଚାଲେ। ସେଗୁଡିକୁ ଅଲଗା ଭାବରେ ଚଲାନ୍ତୁ, ଅର୍କେଷ୍ଟ୍ରେଟର୍ କୁ ଅନ୍ୟ କିଛି ଉପରେ କାର୍ଯ୍ୟ କରିବାକୁ ଦିଅନ୍ତୁ, ଫାଇଲ୍ ଆସିବା ପରେ ଫଳାଫଳ ପ୍ରକ୍ରିୟାକରଣ କରନ୍ତୁ। ମୂଲ୍ୟବାନ ଏଜେଣ୍ଟକୁ କେବେବି ବ୍ଲକ୍-ୱେଟ୍ କରିବାକୁ ଦିଅନ୍ତୁ ନାହିଁ।

ଆକ୍ରାମକ ଭାବରେ ବ୍ୟାଚ୍ କରନ୍ତୁ। ଛଅଟି ବାର୍ତ୍ତାଳାପ ଭାବରେ ଛଅଟି ଚିତ୍ର ହେଉଛି ଛଅ ରାଉଣ୍ଡର ପ୍ରମ୍ପ୍ଟ+ରିପୋର୍ଟ ଓଭରହେଡ୍। ଗୋଟିଏ ପ୍ରମ୍ପ୍ଟ ଯାହା ଏକ ନାମକରଣ ସମ୍ମିଳନୀ ସହିତ ଛଅଟି ଫାଇଲ୍ ପ୍ରସ୍ତୁତ କରେ (hero-01.png … hero-06.png), ଗୋଟିଏ ରିପୋର୍ଟ, ଗୋଟିଏ ସମୀକ୍ଷା ପାସ୍। ଅନୁବାଦଗୁଡ଼ିକ ପାଇଁ ସମାନ: ଗୋଟିଏ ପ୍ରତିନିଧିମଣ୍ଡଳୀରେ ସମସ୍ତ ଆଠୋଟି ଭାଷା।

ବୁଦ୍ଧିମାନ ଭାବରେ ସମୀକ୍ଷା କରିବା ପୂର୍ବରୁ ଯାନ୍ତ୍ରିକ ଭାବରେ ଗେଟ୍ କରନ୍ତୁ। ଫାଇଲ୍ ବିଦ୍ୟମାନ ଅଛି → ଆକାର ଠିକ୍ ଅଛି → ଏଣ୍ଟ୍ରୋପି/ଲିଣ୍ଟ୍/ଟେଷ୍ଟ୍ ଗୁଡ଼ିକ ପାସ୍ ହୁଏ → ତାପରେ ବିଚାର ଉପରେ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଟୋକେନ୍ ଖର୍ଚ୍ଚ କରନ୍ତୁ। ଗେଟ୍ ଧରୁଥିବା ପ୍ରତ୍ୟେକ ବିଫଳତା ହେଉଛି ଏକ ମଡେଲ୍-ସମୀକ୍ଷା ଯାହା ପାଇଁ ଆପଣ ଅର୍ଥ ପ୍ରଦାନ କରିନାହାଁନ୍ତି।

ଶୀଘ୍ର ବିଫଳ ହୁଅନ୍ତୁ, ଥରେ ଏସ୍କାଲେଟ୍ କରନ୍ତୁ। ଯଦି ଏକ ପ୍ରତିନିଧିତ୍ୱ ଭୁଲ୍ ଆସେ, ତେବେ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପାଏ ଗୋଟିଏ ତୀକ୍ଷ୍ଣ ସୀମାବଦ୍ଧତା ସହିତ ସଂଶୋଧନମୂଳକ ପୁନଃପ୍ରୟାସ ("ପୂର୍ବ ପ୍ରୟାସ ଟ୍ୟାବଲେଟ୍ କୁ କ୍ରପ୍ କରିଥିଲା — ସମ୍ପୂର୍ଣ୍ଣ ଟ୍ୟାବଲେଟ୍ ଦୃଶ୍ୟମାନ ହେବା ଆବଶ୍ୟକ")। ଯଦି ପୁନଃପ୍ରୟାସ ମଧ୍ୟ ବିଫଳ ହୁଏ, ସେହି କାର୍ଯ୍ୟର ପ୍ରତିନିଧିତ୍ୱ ବନ୍ଦ କରନ୍ତୁ; ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଏହାକୁ ସିଧାସଳଖ କରେ କିମ୍ବା ଏହା ଚାରିପାଖରେ ରାସ୍ତା ଖୋଜେ। ଅସୀମ ପୁନଃପ୍ରୟାସ ଲୁପ୍ ଗୁଡିକ ହେଉଛି କୌଣସି କାର୍ଯ୍ୟ କରିବା ପାଇଁ ପ୍ରତିନିଧିତ୍ୱ କିପରି ସବୁଠାରୁ ମହଙ୍ଗା ଉପାୟ ହୋଇଯାଏ।

ଅର୍କେଷ୍ଟ୍ରେଟର୍ ର ସେସନ୍ କୁ ସଫା ରଖନ୍ତୁ। ଦୀର୍ଘ ସମୟ ଧରି ଚାଲୁଥିବା ଅର୍କେଷ୍ଟ୍ରେଟର୍ ସେସନ୍ ଗୁଡ଼ିକ ପ୍ରସଙ୍ଗ ସଂଗ୍ରହ କରେ, ଏବଂ ପ୍ରସଙ୍ଗ ହେଉଛି ଇନପୁଟ୍-ଟୋକେନ୍ ଭଡ଼ା ଯାହା ଆପଣ ପ୍ରତ୍ୟେକ ଥର ପ୍ରଦାନ କରନ୍ତି। ପ୍ରତିନିଧିତ୍ୱ ସଠିକ୍ ଭାବରେ ସାହାଯ୍ୟ କରେ କାରଣ ଆର୍ଟିଫ୍ୟାକ୍ଟଗୁଡ଼ିକ ବାର୍ତ୍ତାଳାପ ପରିବର୍ତ୍ତେ ଡିସ୍କରେ ରହେ — ଏହା ଦ୍ୱାରା ତାହାକୁ ନଷ୍ଟ କରନ୍ତୁ ନାହିଁ cat"ଦେଖିବା ପାଇଁ" ଚାଟ୍ ରେ ଫାଇଲ୍ ଗୁଡ଼ିକୁ -ing କରିବା।

ଟେମ୍ପଲେଟ୍ ଗୁଡ଼ିକରେ ଆପଣ ଶିଖିଥିବା ସୀମାବଦ୍ଧତାଗୁଡ଼ିକୁ ଲେଖନ୍ତୁ। ପ୍ରତ୍ୟେକ ପୁନଃକାର୍ଯ୍ୟ ଆପଣଙ୍କୁ ଏକ ପ୍ରମ୍ପ୍ଟ ଲାଇନ୍ ଶିଖାଏ ("କୌଣସି ୱାଟରମାର୍କ ନାହିଁ," "ଫ୍ରେମ୍ ଭିତରେ ସମ୍ପୂର୍ଣ୍ଣ ରୂପେ," "କୌଣସି ନୂତନ ନିର୍ଭରଶୀଳତା ନାହିଁ")। ଟେମ୍ପଲେଟ୍ ଗୁଡିକ ହେଉଛି ଆପଣ କିପରି ସମାନ ଶିକ୍ଷା ପାଇଁ ଦୁଇଥର ଅର୍ଥ ପ୍ରଦାନ କରିବା ବନ୍ଦ କରନ୍ତି।

ଏହାର ଏକ ସପ୍ତାହ ପ୍ରକୃତରେ କିପରି ଦେଖାଯାଏ

ଗୁଣାତ୍ମକ ଭାବରେ, ଏକ ପ୍ରକୃତ ପ୍ରୋଜେକ୍ଟ ସପ୍ତାହରେ ପ୍ୟାଟର୍ଣ୍ଣ ଚଲାଇବା ପରେ: ଅର୍କେଷ୍ଟ୍ରେଟର୍ ର ପ୍ରସଙ୍ଗ ଛୋଟ ରହିଲା ଏବଂ ଏହାର ଟର୍ଣ୍ଣଗୁଡ଼ିକ ଦ୍ରୁତ ରହିଲା, କାରଣ ବଲ୍କ ଆଉଟପୁଟ୍ କେବେବି ବାର୍ତ୍ତାଳାପରେ ପ୍ରବେଶ କଲା ନାହିଁ। ଦୃଶ୍ୟମାନ ଟୋକେନ୍ ଖର୍ଚ୍ଚ ପ୍ରାୟ ସମ୍ପୂର୍ଣ୍ଣ ରୂପେ ସ୍ପେକ୍, ରିପୋର୍ଟ ଏବଂ ସମୀକ୍ଷାକୁ ସ୍ଥାନାନ୍ତରିତ ହେଲା — ଯାହା ଠିକ୍ ସେହି ସ୍ଥାନ ଯେଉଁଠାରେ ଆପଣ ଚାହାଁନ୍ତି ପ୍ରିମିୟମ୍ ମଡେଲ୍ ଏହାର ଧ୍ୟାନ ଖର୍ଚ୍ଚ କରୁ। ସବ୍-ଏଜେଣ୍ଟମାନେ ପରିମାଣ ଉପରେ ସେମାନଙ୍କର ନିଜସ୍ୱ କୋଟା ଖର୍ଚ୍ଚ କଲେ। ଏବଂ ବିଫଳତାଗୁଡିକ ବାସ୍ତବ ଥିଲା କିନ୍ତୁ ସୀମିତ ଥିଲା: ସୃଜନଶୀଳ ପିଢ଼ିର ପ୍ରାୟ ଏକ ଚତୁର୍ଥାଂଶରେ ଏକ ଫିକ୍ସ ସାଇକେଲ୍, କଠୋର ଭାବରେ ସ୍ପେକ୍ କରାଯାଇଥିବା କୋଡ୍ କାର୍ଯ୍ୟଗୁଡ଼ିକରେ ପ୍ରାୟ ଶୂନ ପୁନଃକାର୍ଯ୍ୟ, ଏବଂ ଗୋଟିଏ କାର୍ଯ୍ୟ (ଏକ କ୍ରସ୍-କଟିଂ ରିଫ୍ୟାକ୍ଟର୍) ଯାହାକୁ ମୁଁ ସଠିକ୍ ଭାବରେ ଅର୍କେଷ୍ଟ୍ରେଟର୍ ପାଖରେ ରଖିଥିଲି ଯେତେବେଳେ ସ୍ପେକ୍ ଡ୍ରାଫ୍ଟ ଏକ ଆର୍କିଟେକ୍ଚର୍ ଡକ୍ୟୁମେଣ୍ଟ୍ ରେ ପରିଣତ ହେବାକୁ ଲାଗିଲା।

ପ୍ୟାଟର୍ଣ୍ଣ ମହଙ୍ଗା ମଡେଲକୁ ଶସ୍ତା କରିନଥିଲା। ଏହା ମୋତେ ଏହାକୁ ଏକ ଟାଇପିଷ୍ଟ ଭାବରେ ବ୍ୟବହାର କରିବା ବନ୍ଦ କରାଇଲା।

ରାୟ, ଏବଂ ଏକ ଚେକ୍ ଲିଷ୍ଟ୍

ରଣନୀତି ଠିକ୍ କି? ପ୍ରାୟତଃ, ହଁ। ଜେନେରେସନ୍-ଭାରୀ କାର୍ଯ୍ୟ ପାଇଁ ସଞ୍ଚୟ ବାସ୍ତବ ଏବଂ ବଡ଼ ଅଟେ — ତାହା ହେଉଛି ପ୍ରତିନିଧିତ୍ୱ ଆଉଟପୁଟ୍, ଏବଂ ଆଉଟପୁଟ୍ ହେଉଛି ଯାହା ପାଇଁ ଆପଣ ଅର୍ଥ ପ୍ରଦାନ କରନ୍ତି। ବିଚାର-ଭାରୀ କାର୍ଯ୍ୟ ପାଇଁ ସଞ୍ଚୟ ଏକ ଭ୍ରମ ଅଟେ — ତାହା ହେଉଛି ପ୍ରତିନିଧିତ୍ୱ ବୁଝିବା, ଏବଂ ବୁଝିବା ସର୍ବଦା ଅର୍କେଷ୍ଟ୍ରେଟର୍ ର ବିଲ୍ ଉପରେ ପଡ଼େ, ସାଧାରଣତଃ ସୁଧ ସହିତ।

ମହଙ୍ଗା CLI କୁ ଏକ ବହୁତ ଭଲ, ଶସ୍ତା ଟିମ୍ ସହିତ ଏକ ଖୁତଖୁତିଆ ଟେକ୍ ଲିଡ୍ ଭାବରେ ବ୍ୟବହାର କରନ୍ତୁ: ଏହା ସ୍ପେକ୍ ଲେଖେ, ଛୋଟ ରିପୋର୍ଟ ସମୀକ୍ଷା କରେ, ଏବଂ କେବଳ ସେତେବେଳେ ହୁଡ୍ ଖୋଲେ ଯେତେବେଳେ କିଛି ଭୁଲ୍ ଥିବାର ସନ୍ଦେହ ହୁଏ।

ଆପଣ ଏକ କାର୍ଯ୍ୟ ଅର୍ପଣ କରିବା ପୂର୍ବରୁ, ଚେକ୍ ଲିଷ୍ଟ୍ ଚଲାନ୍ତୁ:

• ଆଉଟପୁଟ୍ କ'ଣ ବଡ଼ (>100 ଲାଇନ୍ / >2k ଟୋକେନ୍) କିମ୍ବା ଏପରି କିଛି ଯାହା ଅର୍କେଷ୍ଟ୍ରେଟର୍ ଆଦୌ ପ୍ରସ୍ତୁତ କରିପାରିବ ନାହିଁ?
• ମୁଁ ସ୍ପେକ୍ ଲେଖିପାରିବି କି? ମୋର ଆର୍କିଟେକ୍ଚର୍ ବ୍ୟାଖ୍ୟା ନକରି?
• "ସମ୍ପନ୍ନ" କ'ଣ ମେସିନ୍-ଦ୍ୱାରା ଯାଞ୍ଚଯୋଗ୍ୟ "ସବୁକିଛି ଯତ୍ନର ସହ ପଢନ୍ତୁ" ପରିବର୍ତ୍ତେ (ଟେଷ୍ଟ୍, ଲିଣ୍ଟ୍, ଫାଇଲ୍ ପ୍ରପର୍ଟିଜ୍)?
• ଆଉଟପୁଟ୍ ପାଥ୍ କ'ଣ ସଠିକ୍, ଏବଂ ଉତ୍ତର ଏଥିରେ ସୀମିତ କି DONE + ଏକ ≤40-ଲାଇନ୍ ରିପୋର୍ଟ?
• ମୁଁ ବଜେଟ୍ କରିଛି କି ଗୋଟିଏ ଫିକ୍ସ ସାଇକେଲ୍ — ଏବଂ ଯଦି ଏହା ଦୁଇଥର ବିଫଳ ହୁଏ ତେବେ କ'ଣ ହେବ ତାହା ସ୍ଥିର କରିଛି କି?

ପାଞ୍ଚଟି ହଁ: ଏହାକୁ ପ୍ରତିନିଧିତ୍ୱ ଦିଅନ୍ତୁ, ବ୍ୟାକଗ୍ରାଉଣ୍ଡ୍ କରନ୍ତୁ, ଗେଟ୍ କରନ୍ତୁ ଏବଂ ଗଣିତକୁ ଉପଭୋଗ କରନ୍ତୁ। ଯେକୌଣସି ନା: ପ୍ରିମିୟମ୍ ମଡେଲ୍ ଏହାକୁ ସିଧାସଳଖ କରେ — କାରଣ ଆପଣ ଖର୍ଚ୍ଚ କରୁଥିବା ସବୁଠାରୁ ମହଙ୍ଗା ଟୋକେନ୍ ହେଉଛି ତାହା ଯାହାକୁ ଦୁଇଥର ଖର୍ଚ୍ଚ କରାଯାଏ।