ਸਾਫਟਵੇਅਰ ਟੀਮਾਂ ਲਈ ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ: ਵਰਕਿੰਗ ਮਾਡਲ ਅਤੇ ਸੀਮਾਵਾਂ

ਲਾਭ:

• ਇਹ ਦੱਸਣ ਦੀ ਯੋਗਤਾ ਕਿ ਇੱਕ ਕੋਡਿੰਗ ਸਹਾਇਕ ਇੱਕ ਭਾਸ਼ਾ ਮਾਡਲ ਦੇ ਰੂਪ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਟੋਕਨ, ਸੰਦਰਭ ਵਿੰਡੋ, ਭੁਲੇਖੇ ਦੀਆਂ ਧਾਰਨਾਵਾਂ
• ਸਾਫਟਵੇਅਰ ਕੰਮਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਜਿੱਥੇ AI ਮਾਨਸਿਕ ਨਕਸ਼ੇ ਨਾਲ ਮਜ਼ਬੂਤ ਅਤੇ ਕਮਜ਼ੋਰ ਹੈ
• ਉਹਨਾਂ ਦੇ ਆਪਣੇ ਕੰਮਾਂ ਲਈ ਪ੍ਰਸਤਾਵ-ਉਤਪਾਦ-ਤਸਦੀਕ ਦੇ ਬੁਨਿਆਦੀ ਕਾਰਜ ਚੱਕਰ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

ਇੱਕ ਸੌਫਟਵੇਅਰ ਡਿਵੈਲਪਰ ਦਾ ਦਿਨ ਘੱਟ ਹੀ "ਸਕ੍ਰੈਚ ਤੋਂ ਕੋਡ ਲਿਖਣ" ਵਿੱਚ ਖਰਚ ਹੁੰਦਾ ਹੈ। ਅਸਲੀ ਸਮਾਂ; ਕਿਸੇ ਹੋਰ ਦੁਆਰਾ ਲਿਖੇ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨਾ, ਇੱਕ ਬੱਗ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ, ਲੌਗ ਨੂੰ ਸਕੈਨ ਕਰਨਾ (ਚੱਲਦੇ ਸਮੇਂ ਐਪਲੀਕੇਸ਼ਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਗਈ ਲੌਗ ਲਾਈਨਾਂ), ਟੈਸਟ ਲਿਖਣਾ, ਇੱਕ PR ਲਿਖਣਾ (ਪੁੱਲ ਬੇਨਤੀ - ਇੱਕ ਅਭੇਦ ਬੇਨਤੀ ਜਿੱਥੇ ਟੀਮ ਸਮੀਖਿਆ ਲਈ ਇੱਕ ਕੋਡ ਤਬਦੀਲੀ ਪੇਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ) ਦੀ ਵਿਆਖਿਆ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ। ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI) ਇੱਕ ਸਪੀਡ ਗੁਣਕ ਹੈ ਜੋ ਲਗਭਗ ਇਹਨਾਂ ਸਾਰੀਆਂ ਅਣਦੇਖੀ ਨੌਕਰੀਆਂ ਨੂੰ ਛੂਹ ਸਕਦਾ ਹੈ। ਪਰ ਇਸਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਵਰਤਣ ਲਈ ਪਹਿਲੀ ਸ਼ਰਤ ਇਹ ਹੈ ਕਿ ਇਹ ਸਹੀ ਢੰਗ ਨਾਲ ਸਮਝਣਾ ਕਿ ਇਹ ਕੀ ਹੈ ਅਤੇ ਕੀ ਨਹੀਂ ਹੈ।

ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਅਸੀਂ ਪਹਿਲਾਂ ਸਾਦੀ ਭਾਸ਼ਾ ਵਿੱਚ ਇੱਕ ਕੋਡਿੰਗ ਸਹਾਇਕ ਦੀ ਅੰਤਰੀਵ ਤਕਨਾਲੋਜੀ ਦੀ ਵਿਆਖਿਆ ਕਰਦੇ ਹਾਂ; ਫਿਰ ਅਸੀਂ ਮਾਡਲ ਦੀਆਂ ਸ਼ਕਤੀਆਂ ਅਤੇ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਮਾਨਸਿਕ ਨਕਸ਼ਾ ਬਣਾਉਂਦੇ ਹਾਂ; ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਬੁਨਿਆਦੀ ਕੰਮਕਾਜੀ ਅਨੁਸ਼ਾਸਨ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ ਜਿਸਦੀ ਵਰਤੋਂ ਅਸੀਂ ਪੂਰੇ ਮੋਡੀਊਲ ਵਿੱਚ ਕਰਾਂਗੇ: ਪ੍ਰਸਤਾਵ, ਉਤਪਾਦਨ, ਪੁਸ਼ਟੀ ਕਰੋ। ਇਹ ਤਿੰਨੇ ਪੜਾਅ ਅਗਲੀਆਂ ਗਿਆਰਾਂ ਇਕਾਈਆਂ ਦੀ ਰੀੜ੍ਹ ਦੀ ਹੱਡੀ ਹਨ।

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

ਇੱਕ ਕੋਡਿੰਗ ਸਹਾਇਕ ਅਸਲ ਵਿੱਚ ਕੀ ਕਰਦਾ ਹੈ?

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

ਇੱਥੇ ਤਿੰਨ ਸ਼ਬਦ ਮਹੱਤਵਪੂਰਨ ਹਨ। ਟੋਕਨ ਸਭ ਤੋਂ ਛੋਟੀ ਇਕਾਈ ਹੈ ਜੋ ਮਾਡਲ ਟੈਕਸਟ ਨੂੰ ਵੰਡ ਕੇ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ; ਇਹ ਮੋਟੇ ਤੌਰ 'ਤੇ ਕੁਝ ਅੱਖਰ ਜਾਂ ਕਿਸੇ ਸ਼ਬਦ ਦਾ ਹਿੱਸਾ ਹੈ। ਸੰਦਰਭ ਵਿੰਡੋ ਟੋਕਨਾਂ ਦੀ ਮਾਤਰਾ ਹੈ ਜੋ ਮਾਡਲ ਇੱਕ ਵਾਰ ਵਿੱਚ "ਵੇਖ" ਸਕਦਾ ਹੈ; ਤੁਹਾਡਾ ਕੋਡ, ਗਲਤੀ ਸੁਨੇਹਾ, ਅਤੇ ਹਦਾਇਤ ਇਸ ਵਿੰਡੋ ਵਿੱਚ ਫਿੱਟ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਇੱਕ ਪ੍ਰੋਂਪਟ ਉਹ ਸਾਰੀਆਂ ਹਦਾਇਤਾਂ ਅਤੇ ਸੰਦਰਭ ਹੁੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਦਿੰਦੇ ਹੋ। ਤੁਹਾਡੇ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੀ ਆਉਟਪੁੱਟ ਦੀ ਗੁਣਵੱਤਾ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਇਹਨਾਂ ਦੋਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ: ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਜਿੰਨਾ ਵਧੀਆ ਸੰਦਰਭ ਅਤੇ ਸਪੱਸ਼ਟ ਨਿਰਦੇਸ਼ ਦਿੰਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਉੱਨਾ ਹੀ ਵਧੀਆ ਨਤੀਜਾ ਮਿਲੇਗਾ। ਖਰਾਬ ਇਨਪੁਟ ਖਰਾਬ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਇਹ ਇੱਕ ਸਮਾਰਟ ਮਾਡਲ ਹੋਵੇ — ਸਾਫਟਵੇਅਰ ਦਾ ਕਲਾਸਿਕ "ਗਾਰਬੇਜ ਇਨ, ਗਾਰਬੇਜ ਆਊਟ" ਨਿਯਮ AI 'ਤੇ ਵੀ ਲਾਗੂ ਹੁੰਦਾ ਹੈ।

ਤਾਕਤ ਅਤੇ ਕਮਜ਼ੋਰੀਆਂ ਦਾ ਨਕਸ਼ਾ

AI ਨੂੰ ਸਹੀ ਨੌਕਰੀਆਂ ਵੱਲ ਸੇਧਿਤ ਕਰਨ ਲਈ, ਇਹ ਜਾਣਨਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਇਹ ਕਿੱਥੇ ਚਮਕਦਾ ਹੈ ਅਤੇ ਕਿੱਥੇ ਠੋਕਰ ਖਾਂਦਾ ਹੈ। ਇਸ ਨਕਸ਼ੇ ਨੂੰ ਯਾਦ ਰੱਖਣਾ ਤੁਹਾਨੂੰ ਹਰ ਅਗਲੇ ਮਿਸ਼ਨ ਨਾਲ ਹੈਰਾਨ ਕਰ ਦੇਵੇਗਾ, "ਕੀ ਮੈਨੂੰ ਇਸ ਨੌਕਰੀ ਨੂੰ AI ਨੂੰ ਆਊਟਸੋਰਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ ਇਹ ਖੁਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?" ਇਹ ਤੁਹਾਨੂੰ ਸਕਿੰਟਾਂ ਵਿੱਚ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦੇਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ.

ਇਸ ਦੀਆਂ ਖੂਬੀਆਂ ਹਨ: ਬਾਇਲਰਪਲੇਟ ਕੋਡ ਬਣਾਉਣਾ, ਇੱਕ ਭਾਸ਼ਾ ਤੋਂ ਦੂਜੀ ਭਾਸ਼ਾ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨਾ, ਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ (ਰੇਜੈਕਸ) ਲਿਖਣਾ, ਇੱਕ ਫੰਕਸ਼ਨ ਦਾ ਵਰਣਨ ਕਰਨਾ, ਇੱਕ ਟੈਸਟ ਸਕੈਲੇਟਨ ਬਣਾਉਣਾ, ਇੱਕ ਗਲਤੀ ਸੰਦੇਸ਼ ਦੀ ਵਿਆਖਿਆ ਕਰਨਾ, ਦਸਤਾਵੇਜ਼ਾਂ ਦਾ ਖਰੜਾ ਤਿਆਰ ਕਰਨਾ, ਵੇਰੀਏਬਲ/ਫੰਕਸ਼ਨ ਨਾਮਾਂ ਦਾ ਸੁਝਾਅ ਦੇਣਾ, ਅਤੇ ਮਾਮੂਲੀ ਰੀਫੈਕਟਰਿੰਗਜ਼ (ਕੋਡ ਦੀ ਬਣਤਰ ਵਿੱਚ ਸੁਧਾਰ ਕੀਤੇ ਬਿਨਾਂ ਇਸਦੇ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲਣਾ)।

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

ਮਿਸ਼ਨ ਦੀ ਕਿਸਮ

ਏਆਈ ਦੀ ਭੂਮਿਕਾ

ਆਦਮੀ ਦੀ ਭੂਮਿਕਾ

ਬਾਇਲਰਪਲੇਟ/ਪਿੰਜਰ ਪੈਦਾ ਕਰੋ

ਡਰਾਫਟ ਤਿਆਰ ਕਰਦਾ ਹੈ

ਅਨੁਕੂਲਤਾ, ਸਮੀਖਿਆਵਾਂ

ਕੋਡ ਦਾ ਵੇਰਵਾ

ਇੱਕ ਤੇਜ਼ ਸਾਰ ਦਿੰਦਾ ਹੈ

ਕੋਡ ਦੇ ਨਾਜ਼ੁਕ ਹਿੱਸੇ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ

ਲਿਖਣ ਦੇ ਟੈਸਟ

ਕੇਸ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ

ਕਵਰੇਜ ਅਤੇ ਸ਼ੁੱਧਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ

ਸੁਰੱਖਿਆ-ਨਾਜ਼ੁਕ ਤਰਕ

ਮਦਦਗਾਰ ਵਿਚਾਰ

ਫੈਸਲਾ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮਨੁੱਖਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।

API/ਲਾਇਬ੍ਰੇਰੀ ਵਰਤੋਂ

ਨਮੂਨਾ ਤਿਆਰ ਕਰਦਾ ਹੈ

ਮੌਜੂਦਗੀ ਅਤੇ ਸੰਸਕਰਣ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ

ਆਰਕੀਟੈਕਚਰਲ ਫੈਸਲਾ

ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਵਿਕਲਪ

ਸੰਦਰਭ ਨੂੰ ਜਾਣ ਕੇ ਚੁਣਦਾ ਹੈ ਅਤੇ ਬਚਾਅ ਕਰਦਾ ਹੈ

ਕਦਮ ਦਰ ਕਦਮ: ਬੁਨਿਆਦੀ ਕਾਰਜ ਚੱਕਰ

1. ਕੰਮ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੋ. ਜੇ ਤੁਸੀਂ ਇੱਕ ਵਾਕ ਵਿੱਚ ਉਹ ਨਹੀਂ ਲਿਖ ਸਕਦੇ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ, ਨਾ ਹੀ ਮਾਡਲ. ਜਿੰਨੀ ਪਹਿਲਾਂ ਦੀ ਅਨਿਸ਼ਚਿਤਤਾ ਇੰਪੁੱਟ ਵਿੱਚ ਆਉਂਦੀ ਹੈ, ਇਹ ਆਉਟਪੁੱਟ ਵਿੱਚ ਉੱਨੀ ਹੀ ਵੱਧ ਜਾਂਦੀ ਹੈ।
2. ਪ੍ਰਸੰਗ ਦਿਓ. ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਸੰਬੰਧਿਤ ਕੋਡ, ਪੂਰਾ ਗਲਤੀ ਸੁਨੇਹਾ, ਭਾਸ਼ਾ/ਫ੍ਰੇਮਵਰਕ ਸੰਸਕਰਣ ਅਤੇ ਰੁਕਾਵਟਾਂ ਸ਼ਾਮਲ ਕਰੋ। "ਇਸ ਨੂੰ ਠੀਕ ਕਰੋ" ਨਾ ਕਹੋ, "Python 3.11, FastAPI 0.110; ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ 500 ਗਲਤੀ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਬੇਨਤੀ ਬਾਡੀ ਖਾਲੀ ਹੁੰਦੀ ਹੈ ਤਾਂ ਇਹ ਫਟਦਾ ਹੈ"।
3. ਲਾਗੂ ਕਰਨ ਦੀ ਭੂਮਿਕਾ ਅਤੇ ਫਾਰਮੈਟ। ਇੱਕ ਫਰੇਮਵਰਕ ਜਿਵੇਂ ਕਿ "ਤੁਸੀਂ ਇੱਕ ਸੀਨੀਅਰ ਗੋ ਡਿਵੈਲਪਰ ਹੋ; ਸਿਰਫ਼ ਕੋਡ ਦਿਓ ਅਤੇ ਇੱਕ ਦੋ-ਵਾਕ ਦਾ ਤਰਕ" ਆਉਟਪੁੱਟ ਨੂੰ ਫੋਕਸ ਕਰਦਾ ਹੈ।
4. ਛੋਟੇ ਲਈ ਪੁੱਛੋ. ਇਸ ਨੂੰ ਇੱਕ ਵਿਸ਼ਾਲ ਬੇਨਤੀ ਦੀ ਬਜਾਏ ਕਦਮਾਂ ਵਿੱਚ ਵੰਡੋ; ਹਰੇਕ ਕਦਮ ਦੀ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪੁਸ਼ਟੀ ਕਰੋ। ਵੱਡੀਆਂ ਤਬਦੀਲੀਆਂ ਖ਼ਤਰਨਾਕ ਹੁੰਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਉਹਨਾਂ ਦੀ ਤਸਦੀਕ ਕਰਨਾ ਔਖਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਗਲਤੀਆਂ ਨੂੰ ਲੁਕਾਉਣ ਦੀ ਸੰਭਾਵਨਾ ਹੁੰਦੀ ਹੈ।
5. ਪੁਸ਼ਟੀ ਕਰੋ। ਇਸਨੂੰ ਚਲਾਓ, ਇਸ ਦੀ ਜਾਂਚ ਕਰੋ, ਇਸਨੂੰ ਦ੍ਰਿਸ਼ਟੀ ਨਾਲ ਪੜ੍ਹੋ। ਗੈਰ-ਪ੍ਰਮਾਣਿਤ AI ਕੋਡ ਇੱਕ "ਸਕੈਚ" ਹੈ, "ਹੱਲ" ਨਹੀਂ। ਇਹ ਚੱਕਰ ਦਾ ਸਭ ਤੋਂ ਗੈਰ-ਵਿਚਾਰਯੋਗ ਕਦਮ ਹੈ।

ਤਿੰਨ ਮਿੰਨੀ ਕੇਸ

ਕੇਸ 1 — ਸਮੇਂ ਦੀ ਬਚਤ ਅਸਲ ਪਰ ਮਾਮੂਲੀ ਹੈ। ਜਦੋਂ ਇੱਕ ਟੀਮ ਨੇ AI ਨਾਲ ਨਵੇਂ CRUD (Create-Read-Update-Delete) ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਪਿੰਜਰ ਬਣਾਇਆ, ਤਾਂ ਪਹਿਲੇ ਡਰਾਫਟ ਦਾ ਸਮਾਂ ਲਗਭਗ 40 ਮਿੰਟਾਂ ਤੋਂ ਘਟ ਕੇ 8 ਮਿੰਟ ਹੋ ਗਿਆ। ਹਾਲਾਂਕਿ, ਸਮੀਖਿਆ ਅਤੇ ਟੈਸਟਿੰਗ ਦੇ ਨਾਲ, ਕੁੱਲ ਸਮਾਂ 25 ਮਿੰਟ ਸੀ; ਇਸ ਲਈ ਅਸਲ ਲਾਭ 40 ਤੋਂ 25 ਤੱਕ ਹੈ, ਲਗਭਗ 38%। ਇਹ ਦਰ, "ਅਸੀਂ 10 ਗੁਣਾ ਤੇਜ਼ ਕੀਤੀ ਹੈ" ਦੀ ਉਮੀਦ ਦੀ ਬਜਾਏ ਮਾਪੀ ਗਈ, ਇੱਕ ਟਿਕਾਊ ਲਾਭ ਹੈ।

ਕੇਸ 2 - ਭਰਮ ਮਹਿੰਗਾ ਹੈ। ਇੱਕ ਡਿਵੈਲਪਰ ਨੇ ਬਿਨਾਂ ਪ੍ਰਮਾਣਿਕਤਾ ਦੇ AI-suggested requests.get_json() ਕਾਲ ਦੀ ਵਰਤੋਂ ਕੀਤੀ; ਅਜਿਹਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਸੀ (ਸਹੀ ਜਵਾਬ. json())। ਕੋਡ ਕੰਪਾਇਲ ਨਾ ਹੋਣ 'ਤੇ 20 ਮਿੰਟ ਗੁੰਮ ਹੋ ਗਏ। ਇੱਕ ਸਧਾਰਨ "ਕੀ ਇਹ ਵਿਧੀ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਹੈ?" ਪੁਸ਼ਟੀਕਰਨ ਨੁਕਸਾਨ ਨੂੰ ਰੀਸੈਟ ਕਰੇਗਾ।

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

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਨਮੂਨੇ

ਇੱਕ ਆਮ-ਉਦੇਸ਼, ਸ਼ਕਤੀਸ਼ਾਲੀ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਂਪਟ:

ਭੂਮਿਕਾ: ਤੁਸੀਂ ਇੱਕ ਤਜਰਬੇਕਾਰ {{language}} ਡਿਵੈਲਪਰ ਹੋ। ਟਾਸਕ: {{what_want}}ਪ੍ਰਸੰਗ:- ਫਰੇਮਵਰਕ/ਵਰਜ਼ਨ: {{framework_and_version}}- ਪਾਬੰਦੀਆਂ: {{ਪ੍ਰਦਰਸ਼ਨ, ਸ਼ੈਲੀ, ਨਿਰਭਰਤਾ ਨਿਯਮ}} ਨਿਯਮ:- ਗੈਰ-ਮੌਜੂਦ ਲਾਇਬ੍ਰੇਰੀ/ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ; ਜੇਕਰ ਤੁਸੀਂ ਯਕੀਨੀ ਨਹੀਂ ਹੋ, ਤਾਂ ਇਸਨੂੰ "ਪੁਸ਼ਟੀ ਕਰੋ" ਵਜੋਂ ਮਾਰਕ ਕਰੋ। - ਪਹਿਲਾਂ, ਇੱਕ ਛੋਟੀ ਯੋਜਨਾ, ਫਿਰ ਕੋਡ, ਫਿਰ ਜਾਇਜ਼ਤਾ ਦੇ 2 ਵਾਕ ਦਿਓ। - ਟੈਸਟ ਕਰਨ ਯੋਗ, ਕਾਰਜਸ਼ੀਲ ਕੋਡ ਤਿਆਰ ਕਰੋ।

ਅਨਿਸ਼ਚਿਤਤਾ ਨੂੰ ਵਾਪਸ ਮਾਡਲ ਵਿੱਚ ਫਿਲਟਰ ਕਰਨ ਲਈ:

ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਨੂੰ ਹੱਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਘੱਟ ਤੋਂ ਘੱਟ 3 ਪੁਆਇੰਟਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਤੁਹਾਨੂੰ ਸਵਾਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਗੁੰਮ ਜਾਂ ਅਸਪਸ਼ਟ ਹਨ। ਮੇਰੇ ਜਵਾਬ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕੋਡ ਨਾ ਲਿਖੋ। Task: {{task}}

ਆਉਟਪੁੱਟ ਦੀ ਸਵੈ-ਜਾਂਚ ਕਰਨ ਲਈ:

ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਤਿਆਰ ਕੀਤਾ ਹੈ। ਹੁਣ ਆਪਣੀ ਭੂਮਿਕਾ ਬਦਲੋ ਅਤੇ ਇਸ ਕੋਡ ਦੀ ਆਲੋਚਨਾ ਕਰੋ:- 3 ਕੇਸਾਂ (ਐਜ ਕੇਸਾਂ) ਦੀ ਸੂਚੀ ਬਣਾਓ ਜੋ ਸ਼ਾਇਦ ਕੰਮ ਨਾ ਕਰਨ।- ਕੀ ਇੱਥੇ ਕੋਈ API/ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਤੁਸੀਂ ਬਣਾ ਸਕਦੇ ਹੋ? ਮਾਰਕ.- ਠੀਕ ਕੀਤਾ ਸੰਸਕਰਣ ਦਿਓ।ਕੋਡ:{{code}}

ਕਿਸੇ ਫੈਸਲੇ ਨੂੰ ਵਿਕਲਪਾਂ ਵਿੱਚ ਵੰਡਣ ਲਈ:

{{problem}} ਲਈ 2-3 ਹੱਲ ਪਹੁੰਚ ਦਾ ਸੁਝਾਅ ਦਿਓ। ਹਰੇਕ ਲਈ: ਛੋਟਾ ਵੇਰਵਾ, ਪਲੱਸ/ਘਟਾਓ, ਕਦੋਂ ਚੁਣਨਾ ਹੈ। ਸਾਰਣੀ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿਓ। ਮੇਰੇ ਲਈ ਨਾ ਚੁਣੋ; ਸਿਰਫ਼ ਵਿਕਲਪ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੋ।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਇਸ ਕੋਡ ਵਿੱਚ ਬੱਗ ਨੂੰ ਠੀਕ ਕਰੋ।" (ਕਿਹੜੀ ਗਲਤੀ? ਕਿਹੜੀ ਭਾਸ਼ਾ? ਅਨੁਮਾਨਿਤ ਵਿਵਹਾਰ ਕੀ ਹੈ?)

ਮਜ਼ਬੂਤ: "Python 3.11 / FastAPI 0.110। ਹੇਠਾਂ ਦਿੱਤਾ ਅੰਤਮ ਬਿੰਦੂ KeyError ਨਾਲ 500 ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਦੋਂ ਬੇਨਤੀ ਬਾਡੀ ਖਾਲੀ ਆਉਂਦੀ ਹੈ; ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਇਹ 400 ਅਤੇ ਖਾਲੀ ਬਾਡੀ 'ਤੇ ਅਰਥਪੂਰਨ ਸੁਨੇਹਾ ਵਾਪਸ ਕਰੇ। ਪਹਿਲਾਂ ਕਾਰਨ ਦੱਸੋ, ਫਿਰ ਸਹੀ ਫੰਕਸ਼ਨ ਦਿਓ, ਫਿਰ ਇਸ ਦ੍ਰਿਸ਼ ਲਈ ਇੱਕ ਟੈਸਟ ਲਿਖੋ। [ਕੋਡ]"

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

ਆਮ ਗਲਤੀਆਂ

• ਤਸਦੀਕ ਕੀਤੇ ਬਿਨਾਂ ਭਰੋਸਾ ਕਰਨਾ। ਸਭ ਤੋਂ ਆਮ ਅਤੇ ਸਭ ਤੋਂ ਮਹਿੰਗੀ ਗਲਤੀ. ਕੋਡ ਨੂੰ ਕੰਪਾਇਲ ਅਤੇ ਟੈਸਟ ਕੀਤੇ ਜਾਣ ਤੱਕ "ਹੱਲ" ਨਾ ਕਹੋ।
• ਬਿਨਾਂ ਪ੍ਰਸੰਗ ਦੇ ਸਵਾਲ ਪੁੱਛਣਾ। ਸੰਸਕਰਣ, ਗਲਤੀ ਟੈਕਸਟ ਅਤੇ ਪਾਬੰਦੀਆਂ ਤੋਂ ਬਿਨਾਂ ਜਵਾਬ ਆਮ ਅਤੇ ਅਕਸਰ ਗਲਤ ਹੁੰਦਾ ਹੈ।
• ਇੱਕ ਵੱਡੀ ਬੇਨਤੀ। ਇੱਕ ਵਾਰ ਵਿੱਚ 300-ਲਾਈਨ ਉਤਪਾਦਨ ਦੀ ਬੇਨਤੀ ਕਰਨ ਅਤੇ ਸਮੀਖਿਆ ਕਰਨ ਦੇ ਯੋਗ ਨਾ ਹੋਣਾ ਗਲਤੀਆਂ ਨੂੰ ਅਦਿੱਖ ਬਣਾਉਂਦਾ ਹੈ।
• ਸਬੂਤ ਵਜੋਂ ਮਾਡਲ ਦੇ ਆਤਮ-ਵਿਸ਼ਵਾਸ ਨੂੰ ਗਲਤ ਸਮਝਣਾ. AI ਭਰੋਸੇ ਨਾਲ ਕੁਝ ਗਲਤ ਕਹਿ ਸਕਦਾ ਹੈ; ਟੋਨ ਸ਼ੁੱਧਤਾ ਦਾ ਸੂਚਕ ਨਹੀਂ ਹੈ।
• ਕੰਪਨੀ ਦੇ ਗੁਪਤ ਨੂੰ ਬੇਤਰਤੀਬ ਨਾਲ ਚਿਪਕਾਉਣਾ. ਪ੍ਰਾਈਵੇਟ ਕੁੰਜੀਆਂ, ਗਾਹਕ ਡੇਟਾ ਜਾਂ ਨਿੱਜੀ ਸਰੋਤ ਕੋਡ ਨੂੰ ਗੈਰ-ਪ੍ਰਵਾਨਿਤ ਸਾਧਨਾਂ ਵਿੱਚ ਦਾਖਲ ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਅਸੀਂ ਯੂਨਿਟ 10 ਵਿੱਚ ਇਸ ਵਿਸ਼ੇ ਬਾਰੇ ਵਿਚਾਰ ਕਰਾਂਗੇ)।

ਨੁਕਤਾ: ਹਰ AI ਆਉਟਪੁੱਟ ਨੂੰ "ਇਹ ਇੱਕ ਡਰਾਫਟ ਹੈ" ਵਜੋਂ ਮੰਨੋ। ਇਹ ਇਕੱਲੀ ਮਾਨਸਿਕ ਆਦਤ ਜ਼ਿਆਦਾਤਰ ਜੋਖਮਾਂ ਨੂੰ ਬੁਝਾ ਦਿੰਦੀ ਹੈ ਜੋ ਤੁਸੀਂ ਪੂਰੇ ਮੋਡਿਊਲ ਵਿੱਚ ਦੇਖੋਗੇ।

ਸੰਖੇਪ ਵਿੱਚ

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

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਤਿੰਨ ਸੌਫਟਵੇਅਰ ਕਾਰਜਾਂ ਨੂੰ ਲਿਖੋ ਜੋ ਤੁਸੀਂ ਪਿਛਲੇ ਹਫ਼ਤੇ ਵਿੱਚ ਕੀਤੇ ਸਨ (ਜਿਵੇਂ ਕਿ ਇੱਕ ਬੱਗ ਫਿਕਸ, ਇੱਕ ਟੈਸਟ, ਇੱਕ README ਅੱਪਡੇਟ)। ਹਰੇਕ ਲਈ “ਤਾਕਤਾਂ ਅਤੇ ਕਮਜ਼ੋਰੀਆਂ ਦੇ ਨਕਸ਼ੇ” ਨੂੰ ਦੇਖੋ ਅਤੇ ਇੱਕ ਵਾਕ ਵਿੱਚ ਵਰਣਨ ਕਰੋ ਕਿ ਤੁਹਾਡੀ ਅਤੇ AI ਦੀ ਭੂਮਿਕਾ ਕੀ ਹੋਵੇਗੀ ਜੇਕਰ ਤੁਸੀਂ AI ਅਜਿਹਾ ਕਰਦੇ ਹੋ। ਫਿਰ ਉਪਰੋਕਤ "ਸਟਾਰਟ ਪ੍ਰੋਂਪਟ" ਟੈਂਪਲੇਟ ਦੇ ਨਾਲ ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਕੰਮ AI ਨੂੰ ਦਿਓ ਅਤੇ ਆਉਟਪੁੱਟ ਨੂੰ ਚਲਾਓ ਅਤੇ ਤਸਦੀਕ ਕਰੋ; ਨੋਟ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਿੰਨੇ ਮਿੰਟ ਬਚਾਏ ਅਤੇ ਕਿੰਨੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨਾ ਪਿਆ।

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ LLM ਪੈਟਰਨ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਕੋਡ ਨੂੰ "ਸਮਝਦਾ" ਨਹੀਂ।
• [ ] ਮੈਂ ਇੱਕ ਵਾਕ ਵਿੱਚ ਟੋਕਨ, ਪ੍ਰਸੰਗ ਵਿੰਡੋ ਅਤੇ ਪ੍ਰੋਂਪਟ ਦੀਆਂ ਧਾਰਨਾਵਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦਾ ਹਾਂ।
• [ ] ਮੈਂ ਉਹਨਾਂ ਕੰਮਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਵਿੱਚ ਫਰਕ ਕਰ ਸਕਦਾ ਹਾਂ ਜਿੱਥੇ AI ਮਜ਼ਬੂਤ ​​ਅਤੇ ਕਮਜ਼ੋਰ ਹੈ।
• [ ] ਮੈਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਭਰਮ ਕੀ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇੱਕੋ ਇੱਕ ਐਂਟੀਡੋਟ ਪੁਸ਼ਟੀਕਰਨ ਹੈ।
• [ ] ਮੈਂ ਆਪਣੇ ਖੁਦ ਦੇ ਕੰਮ ਲਈ "ਪ੍ਰਸਤਾਵ, ਉਤਪਾਦਨ, ਪ੍ਰਮਾਣਿਤ" ਚੱਕਰ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਹੈ।
• [ ] ਮੈਂ ਇੱਕ ਠੋਸ ਉਦਾਹਰਨ ਵਿੱਚ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਪ੍ਰੋਂਪਟ ਅਤੇ ਇੱਕ ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਅੰਤਰ ਦਿਖਾ ਸਕਦਾ ਹਾਂ।