ਨਿਸ਼ਾਨਾ ਪਾਠਕ: ਉਹ ਡਿਵੈਲਪਰ ਜੋ AI ਪ੍ਰੋਗਰਾਮਿੰਗ ਟੂਲਸ (ਜਿਵੇਂ ਕਿ ਕਰਸਰ, ਵਿੰਡਸਰਫ, ਟ੍ਰੇ...) ਵਰਤ ਰਹੇ ਹਨ, ਅਤੇ ਉਹ ਤਕਨੀਕੀ ਪ੍ਰਬੰਧਕ ਜਿਨ੍ਹਾਂ ਨੂੰ AI ਲਾਗਤਾਂ ਬਾਰੇ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ।

ਮੁੱਖ ਵਿਚਾਰ: ਟੋਕਨ ਸਿਰਫ਼ ਇੱਕ ਸਧਾਰਨ ਬਿਲਿੰਗ ਇਕਾਈ ਨਹੀਂ ਹੈ, ਸਗੋਂ ਇੱਕ "ਧਿਆਨ ਸਰੋਤ" ਅਤੇ ਇੱਕ "ਕੰਪਿਊਟਿੰਗ ਪਾਵਰ ਮੁਦਰਾ" ਹੈ। ਏਜੰਟ ਮੋਡ ਦੀ ਦੁਰਵਰਤੋਂ ਕਰਨਾ ਅਤੇ ਸੰਦਰਭ ਪ੍ਰਬੰਧਨ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨਾ ਅਸਲ ਵਿੱਚ ਰਣਨੀਤਕ ਆਲਸ (ਆਪਣੇ ਆਪ ਨੂੰ ਨਾ ਸੋਚਣਾ) ਨੂੰ ਢੱਕਣ ਲਈ ਰਣਨੀਤਕ ਮਿਹਨਤ (AI ਨੂੰ ਬੇਕਾਰ ਕੰਮ ਕਰਨ ਦੇਣਾ) ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ।

ਤੁਹਾਡਾ "AI ਖਰਚਾ" ਤੁਹਾਡੀ ਤਨਖਾਹ ਨਾਲੋਂ ਵੀ ਵੱਧ ਹੋ ਸਕਦਾ ਹੈ

ਕੁਝ ਦਿਨ ਪਹਿਲਾਂ, ਮੈਂ ਆਪਣੇ ਟੋਕਨ ਬਿੱਲ ਦੀ ਜਾਂਚ ਕੀਤੀ। ਜਦੋਂ ਮੈਂ ਉਹ ਨੰਬਰ ਦੇਖਿਆ, ਤਾਂ ਮੈਂ ਥੋੜ੍ਹਾ ਹੈਰਾਨ ਹੋਇਆ: 10 ਮਿਲੀਅਨ ਟੋਕਨ। ਧਿਆਨ ਦਿਓ, ਇਹ ਇੱਕ ਮਹੀਨੇ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਹੈ, ਇਹ ਇੱਕ ਦਿਨ ਦੀ ਹੈ।

ਮੈਂ ਸੋਚਿਆ ਕਿ ਇਹ ਬਹੁਤ ਬੇਤੁਕਾ ਹੈ। ਬਾਅਦ ਵਿੱਚ ਮੈਂ ਟੋਕਨ ਗਣਨਾ ਨਾਲ ਸਬੰਧਤ ਇੱਕ ਛੋਟੀ ਵੀਡੀਓ ਪੋਸਟ ਕੀਤੀ।

ਨਤੀਜੇ ਵਜੋਂ, ਟਿੱਪਣੀ ਖੇਤਰ ਨੇ ਮੈਨੂੰ ਦਿਖਾਇਆ ਕਿ "ਅਸਮਾਨ ਤੋਂ ਪਰੇ ਵੀ ਅਸਮਾਨ ਹੈ" ਦਾ ਕੀ ਮਤਲਬ ਹੈ।

ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਉਪਭੋਗਤਾ "ਓਲਡ ਕੇ ਡੇਲੀ" ਦੁਆਰਾ ਇੱਕ ਦਿਨ ਵਿੱਚ ਦੋ ਸੌ ਮਿਲੀਅਨ ਟੋਕਨਾਂ ਦੀ ਖਪਤ ਦੇ ਰਿਕਾਰਡ ਦਾ ਸਕ੍ਰੀਨਸ਼ੌਟ ਹੈ:

ਪਹਿਲਾਂ ਤਾਂ ਮੈਨੂੰ ਲੱਗਾ ਕਿ ਇਹ ਇੱਕ ਅਲੱਗ ਮਾਮਲਾ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਜਦੋਂ ਬਹੁਤ ਸਾਰੇ ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਟਿੱਪਣੀ ਕੀਤੀ ਕਿ ਉਹ ਹਰ ਰੋਜ਼ 100 ਮਿਲੀਅਨ ਟੋਕਨ ਖਪਤ ਕਰਦੇ ਹਨ, ਤਾਂ ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਇਹ ਇੱਕ ਬਹੁਤ ਆਮ ਵਰਤਾਰਾ ਹੈ।

ਇੱਕ ਸੌ ਮਿਲੀਅਨ ਟੋਕਨ ਕੀ ਹੈ? ਜੇਕਰ ਅਸੀਂ "ਕੁਝ ਮੁੱਖ ਧਾਰਾ ਦੇ ਵਪਾਰਕ ਮਾਡਲਾਂ" ਦੇ ਆਮ ਬਿਲਿੰਗ ਪੈਮਾਨੇ (ਇਨਪੁਟ/ਆਉਟਪੁੱਟ ਦੋਵਾਂ ਲਈ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਬਿਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਕੁੱਲ ਮਿਲਾ ਕੇ ਲਗਭਗ $10 ਪ੍ਰਤੀ ਮਿਲੀਅਨ ਟੋਕਨ ਦੇ ਪੈਮਾਨੇ 'ਤੇ ਅੰਦਾਜ਼ਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ) ਦੇ ਅਨੁਸਾਰ ਗਣਨਾ ਕਰੀਏ, ਤਾਂ ਇਹ ਇੱਕ ਦਿਨ ਵਿੱਚ $1000 ਸਾੜ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਦਿਨ ਵਿੱਚ 7000 ਯੂਆਨ ਸਾੜ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਬਹੁਤ ਸਾਰੇ ਜੂਨੀਅਰ ਪ੍ਰੋਗਰਾਮਰਾਂ ਦੀ ਇੱਕ ਮਹੀਨੇ ਦੀ ਤਨਖਾਹ ਸ਼ਾਇਦ AI ਨੂੰ ਇੱਕ ਦਿਨ ਲਈ "ਸੋਚਣ" ਲਈ ਵੀ ਕਾਫ਼ੀ ਨਹੀਂ ਹੋਵੇਗੀ।

(ਨੋਟ: ਵੱਖ-ਵੱਖ ਮਾਡਲਾਂ/ਵਿਕਰੇਤਾਵਾਂ ਦੀਆਂ ਕੀਮਤਾਂ ਵਿੱਚ ਬਹੁਤ ਵੱਡਾ ਅੰਤਰ ਹੈ, ਅਤੇ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਦੀਆਂ ਇਕਾਈ ਕੀਮਤਾਂ ਵੀ ਅਕਸਰ ਵੱਖਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੱਥੇ ਉਦੇਸ਼ ਦਸ਼ਮਲਵ ਸਥਾਨ ਤੋਂ ਬਾਅਦ ਦੋ ਅੰਕਾਂ ਤੱਕ ਸਹੀ ਗਣਨਾ ਕਰਨਾ ਨਹੀਂ ਹੈ, ਸਗੋਂ ਪਹਿਲਾਂ "ਪੈਮਾਨੇ ਦੀ ਭਾਵਨਾ" ਸਥਾਪਤ ਕਰਨਾ ਹੈ।)

ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਨੂੰ ਦੁਬਾਰਾ ਗਣਨਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇੱਥੇ ਇੱਕ ਆਮ ਫਾਰਮੂਲਾ ਹੈ (ਕੈਸ਼/ਛੋਟਾਂ ਅਤੇ ਹੋਰ ਵਿਸ਼ੇਸ਼ ਨਿਯਮਾਂ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਦੇ ਹੋਏ): ਲਾਗਤ ≈ (ਇਨਪੁਟ ਟੋਕਨ / 1,000,000) × ਯੂਨਿਟ ਕੀਮਤ_ਇਨ + (ਆਉਟਪੁੱਟ ਟੋਕਨ / 1,000,000) × ਯੂਨਿਟ ਕੀਮਤ_ਆਉਟ

ਇਹ ਗੱਲ ਬਹੁਤ ਹੀ ਅਸਹਿਜ ਹੈ। ਅਸੀਂ ਹਮੇਸ਼ਾ ਸੋਚਦੇ ਹਾਂ ਕਿ AI ਸਸਤਾ ਹੈ, ਅਤੇ OpenAI ਕੀਮਤਾਂ ਨੂੰ ਵੀ ਘਟਾ ਰਿਹਾ ਹੈ। ਪਰ ਅਸਲ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ, ਟੋਕਨਾਂ ਦੀ ਖਪਤ ਘਾਤਕ ਰੂਪ ਵਿੱਚ ਕਿਉਂ ਵਧਦੀ ਹੈ?

ਅੱਜ, ਮੈਂ ਤੁਹਾਡੇ ਨਾਲ ਇਸ "ਟੋਕਨ ਬਲੈਕ ਹੋਲ" ਦੇ ਪਿੱਛੇ ਦੇ ਤਰਕ ਨੂੰ ਡੂੰਘਾਈ ਨਾਲ ਸਮਝਾਵਾਂਗਾ, ਅਤੇ ਅਸੀਂ ਨੁਕਸਾਨ ਨੂੰ ਕਿਵੇਂ ਰੋਕ ਸਕਦੇ ਹਾਂ।

1. ਟੋਕਨ "ਘਾਤਕ ਰੂਪ ਵਿੱਚ" ਕਿਉਂ ਵਧਦੇ ਹਨ?

ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਨੂੰ ਟੋਕਨਾਂ ਦੇ ਆਕਾਰ ਬਾਰੇ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ। ਉਹ ਸੋਚਦੇ ਹਨ: "ਓਹ, ਕੀ ਇਹ ਸਿਰਫ਼ ਕੁਝ ਕੋਡ ਦੇ ਟੁਕੜੇ ਭੇਜਣ ਦੀ ਗੱਲ ਨਹੀਂ ਹੈ? ਇਹ ਕਿੰਨਾ ਹੋ ਸਕਦਾ ਹੈ?"

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 ਨੂੰ "ਕੋਡ ਪੜ੍ਹਨ" ਦੇਣ ਨਾਲ ਹੀ 100 ਮਿਲੀਅਨ ਟੋਕਨ ਖਤਮ ਹੋ ਸਕਦੇ ਹਨ।

2. ਟੋਕਨਾਂ ਦਾ "ਸਨੋਬਾਲ" ਪ੍ਰਭਾਵ

ਟੋਕਨ ਖਪਤ ਦਾ ਸਭ ਤੋਂ ਭਿਆਨਕ ਹਿੱਸਾ ਇੱਕ ਵਾਰਤਾਲਾਪ ਨਹੀਂ ਹੈ, ਸਗੋਂ ਕਈ ਵਾਰਤਾਲਾਪਾਂ ਵਿੱਚ ਸੰਦਰਭ ਦਾ ਇਕੱਠਾ ਹੋਣਾ ਹੈ।

LLM ਦਾ ਵਿਧੀ ਸਟੇਟਲੈੱਸ ਹੈ। AI ਨੂੰ ਇਹ ਯਾਦ ਰੱਖਣ ਲਈ ਕਿ ਤੁਸੀਂ ਪਿਛਲੀ ਵਾਰ ਕੀ ਕਿਹਾ ਸੀ, ਸਿਸਟਮ ਆਮ ਤੌਰ 'ਤੇ "ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ + ਇਤਿਹਾਸਕ ਵਾਰਤਾਲਾਪ + ਤੁਹਾਡੀਆਂ ਹਵਾਲਾ ਦਿੱਤੀਆਂ ਫਾਈਲਾਂ/ਕੋਡ ਸਨਿੱਪਟ + ਟੂਲ ਕਾਲ ਆਉਟਪੁੱਟ (ਜਿਵੇਂ ਕਿ ਖੋਜ ਨਤੀਜੇ, ਗਲਤੀ ਲੌਗ)" ਨੂੰ ਇਕੱਠੇ ਪੈਕ ਕਰਕੇ ਮਾਡਲ ਨੂੰ ਭੇਜਦਾ ਹੈ। ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਸਵਾਲ ਪੁੱਛਿਆ ਹੈ, ਪਰ ਅਸਲ ਵਿੱਚ ਤੁਸੀਂ ਵਾਰ-ਵਾਰ "ਪੂਰੇ ਸੰਦਰਭ ਪੈਕੇਜ" ਲਈ ਭੁਗਤਾਨ ਕਰ ਰਹੇ ਹੋ।

• ਦੌਰ 1: 10,000 ਟੋਕਨ ਭੇਜੋ, AI 1,000 ਨਾਲ ਜਵਾਬ ਦਿੰਦਾ ਹੈ।

• ਦੌਰ 2: (10,000 + 1,000 + ਨਵਾਂ ਸਵਾਲ) ਭੇਜੋ, AI ਜਵਾਬ ਦਿੰਦਾ ਹੈ...

• ਦੌਰ 10: ਤੁਹਾਡਾ ਸੰਦਰਭ ਸ਼ਾਇਦ 200,000 ਟੋਕਨਾਂ ਤੱਕ ਫੈਲ ਗਿਆ ਹੈ।

ਇਸ ਸਮੇਂ, ਭਾਵੇਂ ਤੁਸੀਂ ਸਿਰਫ਼ "ਮੇਰੇ ਲਈ ਇੱਕ ਵੇਰੀਏਬਲ ਨਾਮ ਬਦਲਣ ਵਿੱਚ ਮਦਦ ਕਰੋ" ਪੁੱਛਦੇ ਹੋ, ਤਾਂ ਵੀ ਇਸਦੀ ਕੀਮਤ 200,000 ਟੋਕਨ ਹੋਵੇਗੀ। ਇਸ ਲਈ ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੁਝ ਨਹੀਂ ਕੀਤਾ, ਪਰ ਬਿੱਲ ਵਧਦਾ ਜਾ ਰਿਹਾ ਹੈ।

ਇਸ ਤੋਂ ਵੀ ਮਾੜੀ ਗੱਲ ਇਹ ਹੈ ਕਿ: ਏਜੰਟ ਮੋਡ "ਫਾਈਲਾਂ ਨੂੰ ਸਰਗਰਮੀ ਨਾਲ ਪੜ੍ਹੇਗਾ"। ਤੁਸੀਂ ਇੱਕ ਵਾਕ "ਮੇਰੇ ਉਪਭੋਗਤਾ ਮੋਡੀਊਲ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਮੇਰੀ ਮਦਦ ਕਰੋ" ਕਹਿੰਦੇ ਹੋ, ਅਤੇ ਇਹ ਪਹਿਲਾਂ ਸੰਬੰਧਿਤ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਸਕੈਨ ਕਰ ਸਕਦਾ ਹੈ, ਫਿਰ ਨਿਰਭਰਤਾਵਾਂ ਦਾ ਪਿੱਛਾ ਕਰ ਸਕਦਾ ਹੈ, ਫਿਰ ਸੰਰਚਨਾਵਾਂ ਦਾ ਪਿੱਛਾ ਕਰ ਸਕਦਾ ਹੈ, ਫਿਰ ਟੈਸਟਾਂ ਦਾ ਪਿੱਛਾ ਕਰ ਸਕਦਾ ਹੈ... ਇਹ ਆਲਸੀ ਨਹੀਂ ਹੈ, ਇਹ "ਡਿਫੌਲਟ ਰਣਨੀਤੀ ਦੇ ਅਨੁਸਾਰ ਆਪਣੀ ਡਿਊਟੀ ਨਿਭਾ ਰਿਹਾ ਹੈ", ਅਤੇ ਡਿਫੌਲਟ ਰਣਨੀਤੀ ਅਕਸਰ ਇਹ ਹੁੰਦੀ ਹੈ: ਹੋਰ ਪੜ੍ਹੋ, ਹੋਰ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਹੋਰ ਦੁਹਰਾਓ।

2. ਦੋ ਕਿਸਮਾਂ ਦਾ "ਆਲਸ" ਤੁਹਾਡੀ ਇੰਜੀਨੀਅਰਿੰਗ ਸਮਰੱਥਾ ਨੂੰ ਬਰਬਾਦ ਕਰ ਰਿਹਾ ਹੈ

ਟਿੱਪਣੀ ਖੇਤਰ ਵਿੱਚ ਉਨ੍ਹਾਂ "ਇੱਕ ਸੌ ਮਿਲੀਅਨ ਲੋਕਾਂ" ਦੀ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ ਪਤਾ ਲੱਗਾ ਕਿ ਟੋਕਨਾਂ ਦੇ ਵਧਣ ਦਾ ਮੂਲ ਕਾਰਨ ਨਾ ਸਿਰਫ਼ AI ਦੀ ਖਪਤ ਵਿਧੀ ਦੀ ਸਮੱਸਿਆ ਹੈ, ਸਗੋਂ ਲੋਕਾਂ ਦੇ ਆਲਸ ਨਾਲ ਵੀ ਨੇੜਿਓਂ ਜੁੜਿਆ ਹੋਇਆ ਹੈ।

ਹੇਠਾਂ ਦੋ ਆਮ "ਸੋਚਣ ਵਾਲੇ ਆਲਸ" ਹਨ।

ਆਲਸ ਇੱਕ: ਹੈਂਡਸ-ਆਫ ਬੌਸ ਕਿਸਮ

ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਵੀ ਇਹ ਮਾਨਸਿਕਤਾ ਹੈ:

• "ਇਹ ਪੁਰਾਣਾ ਪ੍ਰੋਜੈਕਟ ਬਹੁਤ ਗੜਬੜ ਵਾਲਾ ਹੈ, ਮੈਂ ਤਰਕ ਨੂੰ ਦੇਖਣ ਦੀ ਖੇਚਲ ਨਹੀਂ ਕਰਦਾ, ਮੈਂ ਇਸਨੂੰ ਸਿੱਧਾ AI ਨੂੰ ਦੇ ਦਿੰਦਾ ਹਾਂ।"

• "ਕਰਸਰ ਨੇ ਏਜੰਟ ਮੋਡ ਜਾਰੀ ਕੀਤਾ ਹੈ, ਇਹ ਬਹੁਤ ਵਧੀਆ ਹੈ, ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਬੱਗ ਠੀਕ ਕਰਨ ਦਿਓ।"

ਇਸ ਲਈ, ਤੁਸੀਂ ਪੂਰੇ src ਫੋਲਡਰ ਨੂੰ ਏਜੰਟ ਨੂੰ ਦੇ ਦਿੰਦੇ ਹੋ, ਅਤੇ ਇੱਕ ਅਸਪਸ਼ਟ ਹਦਾਇਤ ਜਾਰੀ ਕਰਦੇ ਹੋ: "ਮੇਰੇ ਉਪਭੋਗਤਾ ਮੋਡੀਊਲ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਮੇਰੀ ਮਦਦ ਕਰੋ।" ਏਜੰਟ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ:

• ਇਸਨੇ 50 ਫਾਈਲਾਂ ਪੜ੍ਹੀਆਂ (500,000 ਦੀ ਖਪਤ)।

• ਇਸਨੇ ਪਾਇਆ ਕਿ utils ਦਾ ਹਵਾਲਾ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਟੂਲ ਕਲਾਸਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਗਿਆ (200,000 ਦੀ ਖਪਤ)।

• ਇਸਨੇ ਸੋਧਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਇੱਕ ਗਲਤੀ ਆਈ, ਅਤੇ ਗਲਤੀ ਲੌਗ ਪੜ੍ਹਿਆ (100,000 ਦੀ ਖਪਤ)।

• ਇਸਨੇ ਠੀਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਅਤੇ ਇੱਕ ਹੋਰ ਗਲਤੀ ਆਈ...

ਇਹ ਪਾਗਲਪਨ ਨਾਲ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ ਅਤੇ ਗਲਤੀ ਕਰ ਰਿਹਾ ਹੈ, ਅਤੇ ਪਾਗਲਪਨ ਨਾਲ ਟੋਕਨਾਂ ਦੀ ਖਪਤ ਕਰ ਰਿਹਾ ਹੈ। ਅਤੇ ਤੁਸੀਂ? ਤੁਸੀਂ ਆਪਣੇ ਫ਼ੋਨ 'ਤੇ ਸਕ੍ਰੌਲ ਕਰ ਰਹੇ ਹੋ, ਇਹ ਸੋਚਦੇ ਹੋਏ ਕਿ ਤੁਸੀਂ ਕਿੰਨੇ ਕੁਸ਼ਲ ਹੋ। ਸੱਚਾਈ ਇਹ ਹੈ: ਤੁਸੀਂ ਪੈਸੇ ਨਾਲ "ਝੂਠੀ ਕੁਸ਼ਲਤਾ" ਲਈ ਵਪਾਰ ਕਰ ਰਹੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਕੋਡ ਦਾ ਇੱਕ ਢੇਰ ਤਿਆਰ ਕੀਤਾ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਬਣਾਈ ਨਹੀਂ ਰੱਖ ਸਕਦੇ ਹੋ।

ਵਧੇਰੇ ਪੇਸ਼ੇਵਰ ਤੌਰ 'ਤੇ, ਇੱਥੇ ਦੋ ਪਰਤਾਂ ਦਾ ਨੁਕਸਾਨ ਹੈ:

• ਲਾਗਤ ਪਰਤ: ਇਨਪੁਟ ਟੋਕਨ ਵੱਡੇ ਹੋ ਜਾਂਦੇ ਹਨ, ਦੁਹਰਾਓ ਦੀ ਗਿਣਤੀ ਵੱਧ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਖਰਚੇ ਲਗਾਤਾਰ ਜੁੜਦੇ ਜਾਂਦੇ ਹਨ

• ਇੰਜੀਨੀਅਰਿੰਗ ਪਰਤ: ਤੁਸੀਂ ਸੰਦਰਭ ਅਤੇ ਫੈਸਲੇ ਲੈਣ ਦਾ ਅਧਿਕਾਰ ਗੁਆ ਦਿੰਦੇ ਹੋ, ਅਤੇ ਅੰਤ ਵਿੱਚ ਤੁਹਾਡੇ ਕੋਲ ਸਿਰਫ਼ ਇੱਕ ਬੇਕਾਬੂ ਸਿਸਟਮ ਬਚਦਾ ਹੈ ਜੋ "ਚੱਲ ਸਕਦਾ ਹੈ"।

ਆਲਸ ਦੋ: ਹਰ ਚੀਜ਼ ਨੂੰ ਇਕੱਠੇ ਸੁੱਟਣਾ

ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਬੱਗ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ AI ਨੂੰ ਕਿਵੇਂ ਦਿੰਦੇ ਹੋ? ਕੀ ਤੁਸੀਂ ਸਿੱਧਾ ਪੂਰੇ ਗਲਤੀ ਕੰਸੋਲ ਨੂੰ ਕਾਪੀ ਕਰਨ ਲਈ Ctrl+A ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਜਾਂ AI ਨੂੰ ਆਪਣੇ ਆਪ ਲੱਭਣ ਲਈ ਸਿੱਧਾ @Codebase ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ?

ਇਸਨੂੰ "ਹਰ ਚੀਜ਼ ਨੂੰ ਇਕੱਠੇ ਸੁੱਟਣਾ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਸਮੱਸਿਆ ਦੇ ਮੂਲ ਨੂੰ ਲੱਭਣ ਦੀ ਖੇਚਲ ਨਹੀਂ ਕਰਦੇ, ਅਤੇ ਤੁਸੀਂ ਮੁੱਖ ਕੋਡ ਸਨਿੱਪਟਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਖੇਚਲ ਨਹੀਂ ਕਰਦੇ। ਤੁਸੀਂ 99% ਬੇਕਾਰ ਜਾਣਕਾਰੀ (ਸ਼ੋਰ) ਅਤੇ 1% ਵੈਧ ਜਾਣਕਾਰੀ (ਸਿਗਨਲ) ਨੂੰ AI ਵਿੱਚ ਸੁੱਟ ਦਿੰਦੇ ਹੋ।

AI ਇੱਕ ਐਂਪਲੀਫਾਇਰ ਵਰਗਾ ਹੈ।

• ਤੁਸੀਂ ਉਸਨੂੰ ਸਪੱਸ਼ਟ ਤਰਕ (ਸਿਗਨਲ) ਦਿੰਦੇ ਹੋ, ਅਤੇ ਇਹ ਤੁਹਾਡੀ ਬੁੱਧੀ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ, ਘੱਟ ਟੋਕਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਅਤੇ ਇਸਦਾ ਇੱਕ ਚੰਗਾ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ।

• ਤੁਸੀਂ ਉਸਨੂੰ ਉਲਝਣ ਅਤੇ ਅਸਪਸ਼ਟਤਾ ਦਿੰਦੇ ਹੋ, ਅਤੇ ਇਹ ਤੁਹਾਡੀ ਉਲਝਣ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ, ਟੋਕਨ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦੇ ਹਨ, ਅਤੇ ਕੂੜਾ ਪੈਦਾ ਹੁੰਦਾ ਹੈ।

3. ਹੱਲ: 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 ਆਰਕੀਟੈਕਟ ਬਣੋ। ਇਹ ਇਸ ਯੁੱਗ ਵਿੱਚ ਸਾਡੀ ਸਭ ਤੋਂ ਵੱਡੀ ਨਾ ਬਦਲੀ ਜਾਣ ਵਾਲੀ ਯੋਗਤਾ ਵੀ ਹੈ।