17 ਜੂਨ 2025·8 ਮਿੰਟ
ਡਿਵੈਲਪਰਾਂ ਦੇ ਕੰਮ ਵਿੱਚ AI ਕਿੰਨਾਂ ਨੂੰ ਬਦਲਦਾ ਹੈ (ਅਤੇ ਕੀ ਨਹੀਂ)
ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਵੰਡ: ਉਹ ਕੰਮ ਜਿਹਨਾਂ ਨੂੰ AI ਬਦਲ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਇਹ ਮਨੁੱਖਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਹ ਕੰਮ ਜੋ ਅਜੇ ਵੀ ਟੀਮ ਦੀ ਪੂਰੀ ਮਾਲਕੀ ਮੰਗਦੇ ਹਨ।
ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਵੰਡ: ਉਹ ਕੰਮ ਜਿਹਨਾਂ ਨੂੰ AI ਬਦਲ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਇਹ ਮਨੁੱਖਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ, ਅਤੇ ਉਹ ਕੰਮ ਜੋ ਅਜੇ ਵੀ ਟੀਮ ਦੀ ਪੂਰੀ ਮਾਲਕੀ ਮੰਗਦੇ ਹਨ।
"AI ਡਿਵੈਲਪਰਾਂ ਲਈ ਕੀ ਕਰੇਗਾ" ਬਾਰੇ ਗੱਲਾਂ ਜਲਦੀ ਗੁੰਝਲਦਾਰ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਅਸੀਂ ਅਕਸਰ ਟੂਲਾਂ ਨੂੰ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਨਾਲ ਮਿਲਾ ਦਿੰਦੇ ਹਾਂ। ਇੱਕ ਟੂਲ ਕੋਡ ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ, ਇੱਕ ਟਿਕਟ ਦਾ ਸਾਰ ਲਿਖ ਸਕਦਾ ਹੈ, ਜਾਂ ਟੈਸਟ ਸੁਝਾ ਸਕਦਾ ਹੈ। ਇੱਕ ਜ਼ਿੰਮੇਵਾਰੀ ਉਹ ਹੁੰਦੀ ਹੈ ਜਿਸਦਾ ਟੀਮ ਜਵਾਬਦੇਹ ਹੋਵੇ ਜਦੋਂ ਸੁਝਾਅ ਗਲਤ ਹੋਵੇ।
ਇਹ ਲੇਖ ਇੱਕ ਸਧਾਰਣ ਫ੍ਰੇਮਵਰਕ—replace, augment, untouched—ਵਰਤਦਾ ਹੈ ਤਾਂ ਜੋ ਅਸਲ ਟੀਮਾਂ ਦੇ ਦਿਨ‑प्रतिदਿਨ ਕੰਮ ਨੂੰ ਦਰਸਾਇਆ ਜਾ ਸਕੇ: ਡੇਡਲਾਈਨ, ਲੈਗੇਸੀ ਕੋਡ, ਪ੍ਰੋਡਕਸ਼ਨ ਇਨਸੀਡੈਂਟ ਅਤੇ ਹਿੱਸੇਦਾਰ ਜੋ ਭਰੋਸੇਯੋਗ ਨਤੀਜੇ ਉਮੀਦ ਕਰਦੇ ਹਨ।
Replace ਦਾ ਮਤਲਬ ਹੈ ਕਿ AI ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ ਟਾਸਕ ਨੂੰ ਐਂਡ‑ਟੂ‑ਐਂਡ ਪੂਰਾ ਕਰ ਸਕਦਾ ਹੈ ਜੇ ਸਾਫ਼ ਗਾਰਡਰੇਲ ਹੋਣ, ਅਤੇ ਮਨੁੱਖੀ ਭੂਮਿਕਾ ਨਿਗਰਾਨੀ ਅਤੇ ਸਪਾਟ‑ਚੈਕ ਵਿੱਚ ਬਦਲ ਜਾਂਦੀ ਹੈ।
ਉਦਾਹਰਨ ਆਮ ਤੌਰ 'ਤੇ ਸੀਮਿਤ ਕੰਮ ਹੁੰਦੇ ਹਨ: ਬੋਇਲਰਪਲੇਟ ਜਨਰੇਸ਼ਨ, ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਡ ਦਾ ਅਨੁਵਾਦ, ਦੁਹਰਾਏ ਜਾਣ ਵਾਲੇ ਟੈਸਟ ਕੇਸ ਦਾ ਡਰਾਫਟ, ਜਾਂ ਪਹਿਲੀ ਪਾਸ ਦੀ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਤਿਆਰ ਕਰਨਾ।
Replace ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ "ਕੋਈ ਮਨੁੱਖੀ ਜਵਾਬਦੇਹੀ ਨਹੀਂ ਹੈ।" ਜੇ ਆਉਟਪੁੱਟ ਪ੍ਰੋਡਕਸ਼ਨ ਤੋੜ ਦੇਵੇ, ਡੇਟਾ ਲੀਕ ਹੋਵੇ, ਜਾਂ ਮਿਆਰਾਂ ਦੀ ਉਲੰਘਣਾ ਹੋਵੇ, ਤਾਂ ਟੀਮ ਫਿਰ ਵੀ ਜ਼ਿੰਮੇਵਾਰ ਰਹੇਗੀ।
Augment ਮਤਲਬ ਹੈ ਕਿ AI ਇੱਕ ਡਿਵੈਲਪਰ ਨੂੰ ਤੇਜ਼ ਜਾਂ ਹੋਰ ਵਿਸਥਾਰਕ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਬਿਨਾਂ ਮਨੁੱਖੀ ਫੈਸਲੇ ਦੇ ਇਹ ਕੰਮ ਨੂੰ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਮੁਕੰਮਲ ਨਹੀਂ ਕਰਦਾ।
ਪੇਸ਼ੇਵਰ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ ਇਹ ਆਮ ਮਾਮਲਾ ਹੈ: ਤੁਹਾਨੂੰ ਉਪਯੋਗੀ ਡਰਾਫਟ, ਵਿਕਲਪੀ ਰਸਤੇ, ਤੇਜ਼ ਵਿਆਖਿਆਵਾਂ, ਜਾਂ ਸੰਭਾਵਿਤ ਬਗਾਂ ਦੀ ਛਾਂਟ ਮਿਲੇਗੀ—ਪਰ ਡਿਵੈਲਪਰ ਹੀ ਤੈਅ ਕਰੇਗਾ ਕਿ ਕੀ ਸਹੀ, ਸੁਰੱਖਿਅਤ ਅਤੇ ਉਤਪਾਦ ਲਈ ਯੋਗ ਹੈ।
Untouched ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੋਰ ਜ਼ਿੰਮੇਵਾਰੀ ਮਨੁੱਖੀ ਰਹਿੰਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਪ੍ਰਸੰਗ, ਟਰੇਡ‑ਆਫ ਅਤੇ ਜ਼ਵਾਬਦੇਹੀ ਮੰਗਦੀ ਹੈ ਜੋ ਪ੍ਰੋਮਪਟਾਂ ਵਿੱਚ ਨਹੀਂ ਆ ਸਕਦੀ।
ਸੋਚੋ: ਲੋੜਾਂ 'ਤੇ ਗੱਲਬਾਤ, ਸਿਸਟਮ‑ਸਤਰੀਆਂ ਪਾਬੰਦੀਆਂ ਦੀ ਚੋਣ, ਇੰਸੀਡੈਂਟ ਸੰਭਾਲਣਾ, ਗੁਣਵੱਤਾ ਮਿਆਰ ਤੈਅ ਕਰਨਾ, ਅਤੇ ਉਹ ਫੈਸਲੇ ਜਿੱਥੇ ਕੋਈ ਇੱਕ "ਸਹੀ" ਉੱਤਰ ਨਹੀਂ ਹੁੰਦਾ।
ਟੂਲ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਦੇ ਹਨ। ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਹੌਲੀ‑ਹੌਲੀ ਬਦਲਦੀਆਂ ਹਨ।
ਇਸ ਲਈ "ਕੀ AI ਇਹ ਕੋਡ ਲਿਖ ਸਕਦਾ ਹੈ?" ਪੁੱਛਣ ਦੀ ਬਜਾਏ ਪੁੱਛੋ "ਨਤੀਜੇ ਦੀ ਮਾਲਕੀ ਕਿਸ ਦੀ ਹੈ?" ਇਹ ਫਰੇਮਿੰਗ ਉਮੀਦਾਂ ਨੂੰ ਅਸਲਾਈ, ਭਰੋਸੇਯੋਗਤਾ, ਅਤੇ ਜ਼ਵਾਬਦੇਹੀ ਵਿੱਚ ਬੰਨ੍ਹਕੇ ਰੱਖਦੀ ਹੈ—ਜੋ ਕਿ ਬੜੇ ਡੈਮੋਜ਼ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ।
ਜਦੋਂ ਲੋਕ ਪੁੱਛਦੇ ਹਨ ਕਿ AI ਡਿਵੈਲਪਮੈਂਟ 'ਚ "ਕੀ ਬਦਲੇਗਾ", ਉਹ ਅਕਸਰ ਟਾਸਕਾਂ ਦੀ ਗੱਲ ਕਰਦੇ ਹਨ: ਇਕ ਫੰਕਸ਼ਨ ਲਿਖੋ, ਟੈਸਟ ਜਨਰੇਟ ਕਰੋ, ਡੌਕ ਤਿਆਰ ਕਰੋ। ਟੀਮਾਂ ਹਾਲਾਂਕਿ ਟਾਸਕ ਨਹੀਂ ਭੇਜਦੀਆਂ—ਉਹ ਨਤੀਜੇ ਭੇਜਦੀਆਂ ਹਨ। ਇੱਥੇ ਹੀ ਡਿਵੈਲਪਰ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀਆਂ ਹਨ।
ਇੱਕ ਡਿਵੈਲਪਰ ਦੀ ਨੌਕਰੀ ਆਮ ਤੌਰ 'ਤੇ ਕੋਡਿੰਗ ਦੇ ਸਮੇਂ ਤੋਂ ਵੱਧ ਫੈਲੀ ਹੁੰਦੀ ਹੈ:
ਇਹ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਲਾਈਫਸਾਈਕਲ ਉੱਪਰ ਸਥਿਤ ਹਨ—"ਅਸੀਂ ਕੀ ਬਣਾਵਾਂ?" ਤੋਂ ਲੈ ਕੇ "ਕੀ ਇਹ ਸੁਰੱਖਿਅਤ ਹੈ?" ਅਤੇ "ਰਾਤ 3 ਵਜੇ ਫਟਕਾਰ ਹੋਣ 'ਤੇ ਕੀ ਹੁੰਦਾ ਹੈ?" ਤੱਕ।
ਹਰ ਜ਼ਿੰਮੇਵਾਰੀ ਅਸਲ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਛੋਟੇ ਫੈਸਲੇ ਹਨ: ਕਿਹੜੇ ਐਜ‑ਕੇਸ ਮੱਤਵਪੂਰਨ ਹਨ, ਕਿਹੜੇ ਮੈਟ੍ਰਿਕਸ ਸਿਹਤ ਦਿਖਾਉਂਦੇ ਹਨ, ਕਦੋਂ ਸਕੋਪ ਕੱਟਣਾ ਹੈ, ਕੀ ਫਿਕਸ ਸ਼ਿਪ ਕਰਨ ਲਈ ਸੁਰੱਖਿਅਤ ਹੈ, ਕਿਸ ਨੂੰ ਹਿੱਸੇਦਾਰਾਂ ਨੂੰ ਟਰੇਡ‑ਆਫ ਸਮਝਾਉਣਾ ਹੈ। AI ਇਹ ਕੰਮ ਦੇ ਟੁਕੜੇ (ਕੋਡ ਡ੍ਰਾਫਟ, ਟੈਸਟ ਸੁਝਾਅ, ਲੌਗ ਦਾ ਸਾਰ) ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਜ਼ਿੰਮੇਵਾਰੀ ਨਤੀਜੇ ਦੀ ਮਾਲਕੀ ਬਾਰੇ ਹੈ।
ਟੁੱਟਨਾਂ ਅਕਸਰ ਹੱਣਡਆਫ ਸੀਮਾਵਾਂ 'ਤੇ ਹੁੰਦੀਆਂ ਹਨ:
ਜਦੋਂ ਮਾਲਕੀ ਅਸਪਸ਼ਟ ਹੁੰਦੀ ਹੈ, ਕੰਮ ਗੈਪ ਵਿੱਚ ਚਲੀ ਜਾਂਦੀ ਹੈ।
ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਬਾਰੇ ਗੱਲ ਕਰਨ ਦਾ ਇੱਕ ਉਪਯੋਗੀ ਤਰੀਕਾ ਹੈ ਫੈਸਲਾ ਅਧਿਕਾਰ:
AI ਲਾਗੂ ਕਰਨ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ। ਫੈਸਲਾ ਅਧਿਕਾਰ—ਅਤੇ ਨਤੀਜਿਆਂ ਲਈ ਜ਼ਵਾਬਦੇਹੀ—ਫਿਰ ਵੀ ਕਿਸੇ ਮਨੁੱਖ ਦੇ ਨਾਮ ਨਾਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
AI ਕੋਡਿੰਗ ਸਹਾਇਕ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਵਾਕਈ ਮਦਦਗਾਰ ਹੁੰਦੇ ਹਨ ਜਿੱਥੇ ਕੰਮ ਭਵਿੱਖਬਾਣੀਯੋਗ, ਘੱਟ‑ਜੋਖਮ ਅਤੇ ਆਸਾਨੀ ਨਾਲ ਪਰਖਯੋਗ ਹੁੰਦਾ ਹੈ। ਉਨ੍ਹਾਂ ਨੂੰ ਤੇਜ਼ ਜੂਨੀਅਰ ਸਾਥੀ ਮੰਨੋ: ਪਹਿਲਾ ਪਾਸ ਤਿਆਰ ਕਰਨ ਵਿੱਚ ਵਧੀਆ, ਪਰ ਸਪਸ਼ਟ ਨਿਰਦੇਸ਼ ਅਤੇ ਧਿਆਨਪੂਰਵਕ ਜਾਂਚ ਲੋੜੀਂਦੀ ਹੁੰਦੀ ਹੈ।
ਅਮਲੀ ਤੌਰ 'ਤੇ, ਕੁਝ ਟੀਮਾਂ "vibe‑coding" ਪਲੇਟਫਾਰਮ ਵਰਤਦੀਆਂ ਹਨ (ਜਿਵੇਂ Koder.ai) ਤਾਂ ਜੋ ਇਹਨਾਂ ਬਦਲੇ ਜਾ ਸਕਣ ਵਾਲੇ ਹਿੱਸਿਆਂ ਨੂੰ ਤੇਜ਼ ਕੀਤਾ ਜਾ ਸਕੇ: ਸਕੈਫੋਲਡ ਤਿਆਰ ਕਰਨਾ, CRUD ਫਲੋ ਵਾਇਰ ਕਰਨਾ, ਅਤੇ ਚੈਟ ਤੋਂ UI ਅਤੇ ਬੈਕਐਂਡ ਕੋਡ ਦੇ ਪਹਿਲੇ ਡਰਾਫਟ ਬਣਾਉਣਾ। ਕੁੰਜੀ ਇੱਕੋ ਹੀ ਹੈ: ਗਾਰਡਰੇਲ, ਰਿਵਿਊ, ਅਤੇ ਸਾਫ਼ ਮਾਲਕੀ।
ਡਿਵੈਲਪਰਾਂ ਦਾ ਬਹੁਤ ਸਮਾਂ ਪ੍ਰਾਜੈਕਟ ਸਕੈਫੋਲਡਿੰਗ ਅਤੇ ਲੇਅਰਾਂ ਵਿਚਕਾਰ ਗਲੂ ਲਿਖਣ ਵਿੱਚ ਲੱਗਦਾ ਹੈ। AI ਅਕਸਰ ਬਣਾਉ ਸਕਦਾ ਹੈ:
ਇਥੇ ਗਾਰਡਰੇਲ ਸਥਿਰਤਾ ਹੈ: ਯਕੀਨੀ ਬਣਾਓ ਇਹ ਤੁਹਾਡੇ ਮੌਜੂਦਾ ਰੀਤੀ‑ਰਿਵਾਜ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ ਅਤੇ ਨਵੇਂ ਪੈਟਰਨ ਜਾਂ ਡਿਪੈਂਡੈਂਸੀ ਨਹੀਂ ਬਣਾਉਂਦੇ।
ਜਦੋਂ ਇੱਕ ਬਦਲੀ ਆਮ ਤੌਰ 'ਤੇ ਮਕੈਨਿਕਲ ਹੁੰਦੀ ਹੈ—ਕੋਡਬੇਸ 'ਚ ਇੱਕ ਸਿੰਬੋਲ ਦਾ ਨਾਮ ਬਦਲਣਾ, ਫਾਰਮੈਟਿੰਗ, ਜਾਂ ਸਿੱਧਾ‑ਸਾਦਾ API ਵਰਤੋਂ ਅਪਡੇਟ—AI ਵਿਅਸਤ ਕੰਮ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ।
ਫਿਰ ਵੀ, ਇਸਨੂੰ ਇੱਕ ਬਲਕ‑ਐਡਿਟ ਵਾਂਗ ਵਰਤੋ: ਪੂਰਾ ਟੈਸਟ ਸੂਟ ਚਲਾਓ, ਡਿਫਸ ਸਕੈਨ ਕਰੋ ਅਣਚਾਹੇ ਵਿਹਾਰ ਬਦਲਾਵਾਂ ਲਈ, ਅਤੇ ਇਸਨੂੰ ਮੰਗੇ ਹੋਏ ਰੀਫੈਕਟਰ ਤੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ "ਸੁਧਾਰ" ਕਰਨ ਨਾ ਦਿਓ।
AI ਕੋਡ ਅਤੇ ਕਮਿਟ ਨੋਟਾਂ ਦੇ ਆਧਾਰ 'ਤੇ README, inline टिप्पणीਆਂ ਅਤੇ ਚੇਂਜਲੌਗ ਇੰਟਰੀਜ਼ ਦਾ ਡਰਾਫਟ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਸਪੱਸਟਤਾ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਵਿਸ਼ਵਾਸਯੋਗ ਦਿਖਾਈ ਦੇਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਵੀ ਬਣਾਏ ਸਕਦਾ ਹੈ।
ਸर्वੋਤਮ ਅਭਿਆਸ: ਸੰਰਚਨਾ ਅਤੇ ਵਾਕ‑ਸ਼ੈਲੀ ਲਈ AI ਵਰਤੋਂ; ਫਿਰ ਹਰ ਦਾਅਵੇ ਨੂੰ ਜਾਂਚੋ—ਖ਼ਾਸ ਕਰਕੇ ਸੈਟਅਪ ਕਦਮ, ਕਨਫਿਗ ਡਿਫੌਲਟ, ਅਤੇ ਐਜ‑ਕੇਸ।
ਚੰਗੀ ਤਰੀਕੇ ਨਾਲ ਨਿਰਧਾਰਿਤ, "ਸ਼ੁੱਧ" ਫੰਕਸ਼ਨਾਂ ਲਈ, AI-ਜਨਰੇਟ ਕੀਤੇ ਯੂਨਿਟ ਟੈਸਟ ਸ਼ੁਰੂਆਤੀ ਕੋਵਰੇਜ ਦਿੰਦੇ ਹਨ ਅਤੇ ਤੁਹਾਨੂੰ ਐਜ‑ਕੇਸ ਯਾਦ ਦਿਵਾਉਂਦੇ ਹਨ। ਗਾਰਡਰੇਲ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਹੁਣ ਵੀ ਫੈਸਲਾ ਕਰੋ ਕਿ ਕੀ ਮੀਨੇ ਰੱਖਦੇ ਹਨ, ਉਹਾਸਰਸ਼ਨਾਂ ਜੋ ਅਸਲੀ ਲੋੜਾ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਜੋੜੋ, ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਟੈਸਟ ਸਹੀ ਕਾਰਨਾਂ ਲਈ ਫੇਲ ਹੋਣ।
ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਲੰਮੇ Slack ਥ੍ਰੇਡ, ਟਿਕਟ, ਜਾਂ ਇੰਸੀਡੈਂਟ ਲੌਗ ਹੁੰਦੇ ਹਨ, AI ਉਨ੍ਹਾਂ ਨੂੰ ਸੰਖੇਪ ਨੋਟਾਂ ਅਤੇ ਕਾਰਵਾਈ ਆਈਟਮਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ। ਇਸਨੂੰ ਸਥਿਰ ਰੱਖੋ: ਪੂਰਾ ਪ੍ਰਸੰਗ ਦੇਵੋ ਅਤੇ ਫਿਰ ਅਹੰਕਾਰਿਕ ਤੱਥ, ਟਾਈਮਸਟੈਂਪ, ਅਤੇ ਫੈਸਲੇ ਜਾਂਚੋ ਪਹਿਲਾਂ ਕਿ ਸਾਂਝਾ ਕਰੋ।
AI ਕੋਡਿੰਗ ਸਹਾਇਕ ਸਭ ਤੋਂ ਵਧੀਆ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਹੀ ਪਤਾ ਹੋ ਕਿ ਤੁਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਅੱਗੇ ਵਧਣਾ ਹੈ। ਉਹ "ਟਾਈਪਿੰਗ ਕੰਮ" ਘਟਾਉਂਦੇ ਹਨ ਅਤੇ ਮਦਦਗਾਰ ਸੰਦਰਭ ਉੱਠਾਂਦੇ ਹਨ, ਪਰ ਮਾਲਕੀ, ਤਸਦੀਕ, ਅਤੇ ਫੈਸਲੇ ਦੀ ਲੋੜ ਹਮੇਸ਼ਾ ਰਹਿੰਦੀ ਹੈ।
ਇੱਕ ਸਪੱਸ਼ਟ ਸਪੈੱਕ—ਇੰਪੁੱਟ, ਆਉਟਪੁੱਟ, ਐਜ‑ਕੇਸ, ਅਤੇ ਪਾਬੰਦੀਆਂ—ਦਿੱਤੀ ਹੋਵੇ ਤਾਂ AI ਇੱਕ ਵਾਜਬ ਸ਼ੁਰੂਆਤੀ ਇੰਪਲਿਮੈਂਟੇਸ਼ਨ ਦਾ ਡਰਾਫਟ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ: ਬੋਇਲਰਪਲੇਟ, ਡੇਟਾ ਮੈਪਿੰਗ, API ਹੈਂਡਲਰ, ਮਾਈਗ੍ਰੇਸ਼ਨ, ਜਾਂ ਸਿੱਧਾ‑ਸਾਦਾ ਰੀਫੈਕਟਰ। ਜਿੱਤ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਕੁਝ ਚੱਲਦਾ‑ਫਿਰਦਾ ਪ੍ਰਾਪਤ ਕਰ ਲੈਂਦੇ ਹੋ।
ਫ਼ੇਕਟ ਇਹ ਹੈ ਕਿ ਪਹਿਲਾ‑ਪਾਸ ਅਕਸਰ ਸੁਕੰਧੀ ਲੋੜਾਂ (ਏਰਰ ਸੈਮੈਂਟਿਕਸ, ਪ੍ਰਦਰਸ਼ਨ ਮਰਿਆਦਾ, ਪਿੱਛਲੇ ਸੰਪਰਕ ਨਾਲ ਸੰਗਤ) ਨੂੰ ਮਿਸ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਇੰਟਰਨ ਦੀ ਡਰਾਫਟ ਵਾਂਗ ਸਮਝੋ: ਉਪਯੋਗੀ, ਪਰ ਅਧਿਕਾਰਕ ਨਹੀਂ।
ਜਦੋਂ ਤੁਸੀਂ ਰੁੱਦਾ ਚੁਣ ਰਹੇ ਹੋ (ਜਿਵੇਂ cache vs batching, optimistic vs pessimistic locking), AI ਵਿਕਲਪ ਦਸ ਸਕਦਾ ਹੈ ਅਤੇ ਟਰੇਡ‑ਆਫ ਲਿਖ ਸਕਦਾ ਹੈ। ਇਹ ਸੋਚ‑ਵਿਚਾਰ ਲਈ ਕੀਮਤੀ ਹੈ, ਪਰ ਟਰੇਡ‑ਆਫ ਨੂੰ ਤੁਹਾਡੇ ਸਿਸਟਮ ਦੀਆਂ ਹਕੀਕਤਾਂ—ਟ੍ਰੈਫਿਕ ਆਕਾਰ, ਡੇਟਾ ਸਾਂਤ੍ਰਿਤੀ ਲੋੜਾਂ, ਓਪਰੇਸ਼ਨਲ ਪਾਬੰਦੀਆਂ, ਅਤੇ ਟੀਮ ਰੀਤੀ—ਦੇਖ ਕੇ ਪਰਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
AI ਗੈਰ‑ਪਰਿਚਿਤ ਕੋਡ ਦੀ ਵੀਖਿਆ ਕਰਨ ਵਿੱਚ ਮਜ਼ਬੂਤ ਹੈ, ਰੁਝਾਨਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਅਤੇ "ਇਹ ਕੀ ਕਰ ਰਿਹਾ ਹੈ?" ਨੂੰ ਸਧਾਰਨ ਭਾਸ਼ਾ ਵਿੱਚ ਬਿਆਨ ਕਰਦਾ ਹੈ। ਖੋਜ ਟੂਲਾਂ ਨਾਲ ਜੋੜਕੇ, ਇਹ "X ਕਿੱਥੇ ਵਰਤੀ ਜਾ ਰਹੀ ਹੈ?" ਦਾ ਜਵਾਬ ਅਤੇ ਸੰਭਾਵਿਤ ਪ੍ਰਭਾਵ ਵਾਲੇ ਕਾਲ ਸਾਈਟਾਂ ਦੀ ਲਿਸਟ ਦੇ ਸਕਦਾ ਹੈ।
ਪ੍ਰਯੋਗਕਾਰੀ ਸੁਧਾਰ: ਸਪਸ਼ਟ ਐਰਰ ਸੁਨੇਹੇ, ਛੋਟੇ ਉਦਾਹਰਣ, ਅਤੇ ਤਿਆਰ‑ਕੀਤੇ ਟੁਕੜੇ। ਇਹ ਘਰਢਿਲ ਘਟਾਉਂਦੇ ਹਨ, ਪਰ ਇਹ ਧਿਆਨਪੂਰਕ ਰਿਵਿਊ, ਲੋਕਲ ਰਨ, ਅਤੇ ਨਿਸ਼ਚਿਤ ਟੈਸਟ ਨੂੰ ਬਦਲਦੇ ਨਹੀਂ—ਖ਼ਾਸ ਕਰਕੇ ਉਹ ਬਦਲਾਅ ਜੋ ਉਪਭੋਗੀਆਂ ਜਾਂ ਪ੍ਰੋਡਕਸ਼ਨ ਸਿਸਟਮਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ।
AI ਤੁਹਾਨੂੰ ਲੋੜਾਂ ਲਿਖਣ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਫੈਸਲਾ ਨਹੀਂ ਕਰ ਸਕਦਾ ਕਿ ਤੁਸੀਂ ਕੀ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਕਿਉਂ ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਉਤਪਾਦੀ ਸਮਝ ਪ੍ਰਸੰਗ ਵਿੱਚ ਨਿਗੜੀ ਹੁੰਦੀ ਹੈ: ਬਿਜ਼ਨੈਸ ਲਕੜੀ, ਉਪਭੋਗੀ ਦਰਦ, sangathanik ਰੋਕ, ਐਜ‑ਕੇਸ, ਅਤੇ ਗਲਤ ਹੋਣ ਦੀ ਲਾਗਤ। ਇਹ ਜਾਣਕਾਰੀਆਂ ਗੱਲਬਾਤਾਂ, ਇਤਿਹਾਸ, ਅਤੇ ਜ਼ਵਾਬਦੇਹੀ ਵਿੱਚ ਰਹਿੰਦੀਆਂ ਹਨ—ਜਿਨ੍ਹਾਂ ਨੂੰ ਮਾਡਲ ਸੰਖੇਪ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਮਾਲਕੀ ਨਹੀਂ ਲੈ ਸਕਦਾ।
ਆਰੰਭਿਕ ਬੇਨਤੀਆਂ ਅਕਸਰ ਇੰਝ ਹੁੰਦੀਆਂ ਹਨ: "Onboarding ਸੌਖਾ ਕਰੋ" ਜਾਂ "ਸਪੋਰਟ ਟਿਕਟ ਘਟਾਉ"। ਡਿਵੈਲਪਰ ਦਾ ਕੰਮ ਇਹਨੂੰ ਸਪੱਸ਼ਟ ਲੋੜਾਂ ਅਤੇ ਐਕਸੈਪਟੈਂਸ ਕਰਾਈਟੇਰੀਆ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ ਹੈ।
ਇਹ ਤਬਦੀਲੀ ਆਮ ਤੌਰ 'ਤੇ ਮਨੁੱਖੀ ਕੰਮ ਹੈ ਕਿਉਂਕਿ ਇਹ ਜਾਂਚ‑ਪੜਤਾਲ ਅਤੇ ਫੈਸਲਾ ਲੈਣ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ:
AI ਸੰਭਾਵਿਤ ਮੈਟ੍ਰਿਕਸ ਜਾਂ ਐਕਸੈਪਟੈਂਸ ਕਰਾਈਟੇਰੀਆ ਸੁਝਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਕਿਹੜੀਆਂ ਪਾਬੰਦੀਆਂ ਅਸਲ ਵਿੱਚ ਮੌਜੂਦ ਹਨ ਜਦ ਤੱਕ ਕਿਸੇ ਨੇ ਉਨ੍ਹਾਂ ਨੂੰ ਨਹੀਂ ਦਿੱਤਾ—ਅਤੇ ਇਹ ਤਾਂ ਨਹੀਂ ਦੱਸੇਗਾ ਜਦੋਂ ਕੋਈ ਬੇਨਤੀ ਆਪਸ ਵਿੱਚ ਵਿਰੋਧੀ ਹੋਵੇ।
ਲੋੜਾਂ ਦਾ ਕੰਮ ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ ਅਸੁਖਾਵਨ ਟਰੇਡ‑ਆਫ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ: ਸਮਾਂ ਵੱਲੋਂ ਗੁਣਵੱਤਾ, ਗਤੀ ਵਲੋਂ ਰੱਖ‑ਪੋਸ, ਨਵੇਂ ਫੀਚਰ ਵਲੋਂ ਸਥਿਰਤਾ। ਟੀਮ ਨੂੰ ਕਿਸੇ ਵਿਅਕਤੀ ਦੀ ਲੋੜ ਹੋਂਦੀ ਹੈ ਜੋ ਜੋਖਮ ਨੂੰ ਸਪਸ਼ਟ ਕਰੇ, ਵਿਕਲਪ ਪ੍ਰਸਤਾਵੇ, ਅਤੇ ਹਿੱਸੇਦਾਰਾਂ ਨੂੰ ਨਤੀਜਿਆਂ 'ਤੇ ਇਕਝਟ ਕਰੇ।
ਇੱਕ ਚੰਗਾ ਸਪੈੱਕ ਸਿਰਫ ਟੈਕਸਟ ਨਹੀਂ; ਇਹ ਇੱਕ ਫੈਸਲਾ ਰਿਕਾਰਡ ਹੈ। ਇਹ ਟੈਸਟ ਕਰਨਯੋਗ ਅਤੇ ਇੰਪਲਿਮੇਂਟ ਕਰਨਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਿਰਧਾਰਤ ਪਰਿਭਾਸ਼ਾਵਾਂ (ਇੰਪੁੱਟ, ਆਉਟਪੁੱਟ, ਐਜ‑ਕੇਸ, ਫੇਲਿਅਰ ਮੋਡ) ਨਾਲ। AI ਸੰਰਚਨਾ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਸਹੀਪਣ ਲਈ ਜ਼ਿੰਮੇਵਾਰੀ ਮਨੁੱਖੀ ਹੈ।
ਸਿਸਟਮ ਡਿਜ਼ਾਇਨ ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ "ਅਸੀਂ ਕੀ ਬਣਾਵਾਂ?" بدل ਕੇ "ਅਸੀਂ ਇਸਨੂੰ ਕਿਸ 'ਤੇ ਬਣਾਵਾਂ ਅਤੇ ਜਦੋਂ ਚੀਜ਼ਾਂ ਖਰਾਬ ਹੋਣ ਤਾਂ ਇਹ ਕਿਵੇਂ ਵਰਤੇਗਾ?" ਬਣ ਜਾਂਦਾ ਹੈ। AI ਤੁਹਾਨੂੰ ਵਿਕਲਪਾਂ ਦੀ ਖੋਜ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਨਤੀਜਿਆਂ ਦੀ ਮਾਲਕੀ ਨਹੀਂ ਲੈ ਸਕਦਾ।
ਮੋਨੋਲਿਥ, ਮਾਡਿਊਲਰ ਮੋਨੋਲਿਥ, ਮਾਇਕ੍ਰੋਸਰਵਿਸਿਜ, ਸਰਵਰਲੈਸ, ਜਾਂ ਮੈਨੇਜਡ ਪਲੇਟਫਾਰਮ ਵਿਚੋਂ ਚੋਣ ਇੱਕ ਪ੍ਰਸ਼ਨ ਨਹੀਂ ਹੈ ਜਿਸਦਾ ਇੱਕ ਸਹੀ ਉੱਤਰ ਹੋਵੇ। ਇਹ ਫਿੱਟ ਦਾ ਸੁਆਲ ਹੈ: ਉਮੀਦ ਕੀ ਸਕੇਲ ਹੈ, ਬਜਟ, ਟਾਈਮ‑ਟੂ‑ਮਾਰਕੀਟ, ਅਤੇ ਟੀਮ ਦੀਆਂ ਹੁਨਰਾਂ।
ਐਸਿਸਟੈਂਟ ਪੈਟਰਨ ਸੰਖੇਪ ਅਤੇ ਰੈਫ਼ਰੈਂਸ ਆਰਕੀਟੈਕਚਰ ਸੁਝਾ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਤੁਹਾਡੀ ਟੀਮ ਹਫ਼ਤੇ ਦੌਰਾਨ ਆਨ‑ਕੌਲ ਕਿਵੇਂ ਰੋਟੇਟ ਕਰਦੀ ਹੈ, ਭਰਤੀ ਸਲੋ ਕਿਵੇਂ ਹੈ, ਜਾਂ ਡੇਟਾਬੇਸ ਵੇਂਡਰ ਦਾ ਠੇਕਾ ਅਗਲੇ ਤਿਮਾਹੀ ਵਿੱਚ ਨਵੀਨੀਕਰਨ ਹੋ ਰਿਹਾ ਹੈ। ਇਹ ਵਿਵਰਣ ਅਕਸਰ ਫੈਸਲੇ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ।
ਚੰਗੀ ਆਰਕੀਟੈਕਚਰ ਮੁੱਖ ਤੌਰ 'ਤੇ ਟਰੇਡ‑ਆਫ ਹਨ: ਸਾਦਗੀ ਬਨਾਮ ਲਚਕੀਲਾਪਨ, ਪ੍ਰਦਰਸ਼ਨ ਬਨਾਮ ਲਾਗਤ, ਅੱਜ ਦੀ ਗਤੀ ਬਨਾਮ ਭਵਿੱਖੀ ਰੱਖ‑ਪੋਸ। AI ਤੁਰੰਤ ਪ੍ਰੋਸ/ਕਾਨਸ ਲਿਸਟ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਦਸਤਾਵੇਜ਼ੀ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੈ।
ਪਰ ਇਹ ਪ੍ਰਾਇਓਰਿਟੀ ਨਹੀਂ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਜਦੋਂ ਟਰੇਡ‑ਆਫ ਨੁਕਸਾਨ ਪਹੁੰਚਾਉਂਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, “ਅਸੀਂ ਥੋੜ੍ਹੀ ਧੀਮੀ ਰਿਸਪਾਂਸ ਮਨਜ਼ੂਰ ਕਰਦੇ ਹਾਂ ਤਾਂ ਕਿ ਸਿਸਟਮ ਸਿੰਪਲ ਰਹੇ” ਇੱਕ ਬਿਜ਼ਨੈਸ ਚੋਣ ਹੈ, ਸਿਰਫ਼ ਤਕਨੀਕੀ ਨਹੀਂ।
ਸੇਵਾ ਦੀਆਂ ਸੀਮਾਵਾਂ, ਕੌਣ ਕਿਹੜਾ ਡੇਟਾ ਰੱਖਦਾ ਹੈ, ਅਤੇ ਅੰਸ਼ਿਕ ਠਹਿਰਾਉਂਦਿਆਂ ਕੀ ਹੁੰਦਾ ਹੈ ਇਹ ਗਹਿਰਾ ਉਤਪਾਦ ਅਤੇ ਓਪਰੇਸ਼ਨਲ ਪ੍ਰਸੰਗ ਮੰਗਦਾ ਹੈ। AI ਫੇਲਿਅਰ ਮੋਡ ਬਰੇਨਸਟਾਰਮ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ (“ਜੇ ਭੁਗਤਾਨ ਪ੍ਰਦਾਤਾ ਡਾਉਨ ਹੋ ਜਾਵੇ ਤਾਂ?”), ਪਰ ਗਾਹਕ ਸੰਦੇਸ਼, ਰੋਲਬੈਕ ਯੋਜਨਾ, ਅਤੇ ਉਮੀਦਵਾਰ ਵਰਤਾਰਾ ਨਿਰਧਾਰਿਤ ਕਰਨ ਲਈ ਮਨੁੱਖੀ ਫੈਸਲੇ ਲੋੜੀਂਦੇ ਹਨ।
API ਡਿਜ਼ਾਇਨ ਇਕ ਠੇਕਾ ਬਣਾਉਣ ਵਰਗਾ ਹੈ। AI ਉਦਾਹਰਣ ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਅਸਮੰਜਸ ਪਤਾ ਲਗਾ ਸਕਦਾ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਫੈਸਲਾ ਕਰਨਾ ਹੈ ਕਿ ਵਰਜ਼ਨਿੰਗ, ਬੈਕਵਰਡ‑ਕੰਪੈਟਬਿਲਟੀ, ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਲਈ ਤੁਸੀਂ ਕੀ ਸਹਿਯੋਗ ਦਿਓਗੇ।
ਸਭ ਤੋਂ ਵੱਡਾ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲਾ ਕਦੇ‑ਕਦੇ “ਨਾ” ਕਹਿਣਾ ਜਾਂ ਕਿਸੇ ਫੀਚਰ ਨੂੰ ਮਿਟਾਣਾ ਹੁੰਦਾ ਹੈ। AI ਉਪਯੋਗਤਾ ਜਾਂ ਰਾਜਨੀਤਿਕ ਜੋਖਮ ਨੂੰ ਮਾਪ ਨਹੀਂ ਸਕਦਾ। ਟੀਮਾਂ ਇਹ ਮਾਪ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਇਨ੍ਹਾਂ ਫੈਸਲਿਆਂ ਦੀ ਮਾਲਕੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।
ਡੀਬੱਗਿੰਗ ਓਥੇ ਹੈ ਜਿੱਥੇ AI ਅਕਸਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਲੱਗਦਾ ਹੈ—ਅਤੇ ਓਥੇ ਜਿੱਥੇ ਇਹ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਸਮਾਂ ਬਰਬਾਦ ਕਰ ਸਕਦਾ ਹੈ। ਇੱਕ ਸਹਾਇਕ ਲੌਗ ਸਕੈਨ ਕਰ ਸਕਦਾ ਹੈ, ਸ਼ੱਕੀ ਕੋਡ ਪਾਥ ਦਿਖਾ ਸਕਦਾ ਹੈ, ਜਾਂ ਇਕ ਐਸਾ ਫਿਕਸ ਸੁਝਾ ਸਕਦਾ ਹੈ ਜੋ "ਠੀਕ ਲੱਗਦਾ"। ਪਰ ਰੁਟ‑ਕਾਰਨ ਵਿਸ਼ਲੇਸ਼ਣ ਸਿਰਫ ਵਿਆਖਿਆਵਾਂ ਬਣਾਉਣਾ ਨਹੀਂ; ਇਹ ਇਕ ਵਿਆਖਿਆ ਨੂੰ ਸਾਬਤ ਕਰਨਾ ਹੁੰਦਾ ਹੈ।
AI ਆਉਟਪੁੱਟ ਨੂੰ ਹਿਪੋਥੇਸਿਸ ਸਮਝੋ, ਨ ਕਿ ਨਤੀਜੇ। ਬਹੁਤ ਸਾਰੇ ਬੱਗਾਂ ਦੇ ਕਈ ਸੰਭਾਵਿਤ ਕਾਰਨ ਹੋ ਸਕਦੇ ਹਨ, ਅਤੇ AI ਖ਼ਾਸ ਕਰਕੇ ਉਸ ਸੁੰਦਰ ਕਹਾਣੀ ਨੂੰ ਚੁਣਨ ਲਗਦਾ ਹੈ ਜੋ ਉਸ ਕੋਡ ਨੂ ਪੇਸਟ ਕੀਤੇ ਟੁਕੜੇ ਨੂੰ ਮਿਲਦੀ ਹੈ, ਨ ਕਿ ਚਲ ਰਹੇ ਸਿਸਟਮ ਦੀ ਅਸਲ ਹਕੀਕਤ।
ਪ੍ਰਾਯੋਗਿਕ ਵਰਕਫਲੋ ਇਹ ਹੈ:
ਭਰੋਸੇਯੋਗ ਦੁਹਰਾਵਾ ਇੱਕ ਡੀਬੱਗਿੰਗ ਸੁਪਰਪਾਵਰ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇਕ ਰਹੱਸ ਨੂੰ ਇੱਕ ਟੈਸਟ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। AI ਤੁਹਾਨੂੰ ਮਿਨੀਮਲ ਰੀਪ੍ਰੋ ਲਿਖਣ, ਡਾਇਗਨੋਸਟਿਕ ਸਕ੍ਰਿਪਟ ਤਿਆਰ ਕਰਨ, ਜਾਂ ਵਾਧੂ ਲੌਗਿੰਗ ਸੁਝਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਤੈਅ ਕਰਦੇ ਹੋ ਕਿ ਕਿਹੜੇ ਸਿਗਨਲ ਮਹੱਤਵਪੂਰਨ ਹਨ: ਰਿਕਵੈਸਟ ID, ਟਾਈਮਿੰਗ, ਐਨਵਾਇਰਨਮੈਂਟ ਅੰਤਰ, ਫੀਚਰ ਫਲੈਗ, ਡੇਟਾ ਸ਼ੇਪ ਜਾਂ ਕੰਕਰਨਸੀ।
ਜਦੋਂ ਉਪਭੋਗੀ ਲੱਛਣ ਦੱਸਦੇ ਹਨ ("ਐਪ ਫ੍ਰੀਜ਼ ਹੋ ਗਿਆ"), ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਸਿਸਟਮ ਵਿਹਾਰ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ ਪੈਂਦਾ ਹੈ: ਕੌਣ‑ਕੌਣ endpoint ਰੁਕਿਆ, ਕਿਹੜੇ ਟਾਈਮਆਉਟ ਫਾਇਰ ਹੋਏ, ਕਿਹੜੇ ਏਰਰ‑ਬਜਟ ਸੰਕੇਤ ਬਦਲੇ। ਇਹ ਪ੍ਰਸੰਗ ਮੰਗਦਾ ਹੈ: ਉਤਪਾਦ ਕਿਸ ਤਰ੍ਹਾਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ "ਸਧਾਰਨ" ਕੀ ਹੁੰਦਾ ਹੈ।
ਜੇ ਸੁਝਾਅ ਨੂੰ ਸਾਬਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਤਾਂ ਇਹ ਮੰਨੋ ਕਿ ਇਹ ਗਲਤ ਹੈ। ਉਨ੍ਹਾਂ ਵਿਆਖਿਆਵਾਂ ਨੂੰ ਪਸੰਦ ਕਰੋ ਜੋ ਕਿਸੇ ਟੈਸਟਯੋਗ ਭਵਿੱਖਬਾਣੀ ਕਰਦੀਆਂ ਹਨ (ਉਦਾਹਰਣ: "ਇਹ ਕੇਵਲ ਵੱਡੇ ਪੇਲੋਡਾਂ 'ਤੇ ਹੋਵੇਗਾ" ਜਾਂ "ਕੇਵਲ ਕੈਸ਼ ਗਰਮੀ ਤੋਂ ਬਾਅਦ").
ਕਾਰਣ ਲੱਭਣ ਮਗਰੋਂ ਵੀ, ਸਖ਼ਤ ਫੈਸਲਾ ਰਹਿੰਦਾ ਹੈ। AI ਟਰੇਡ‑ਆਫ ਦਿੱਸ ਸਕਦਾ ਹੈ, ਪਰ ਮਨੁੱਖ ਚੁਣਦੇ ਹਨ:
ਰੁਟ‑ਕਾਰਨ ਵਿਸ਼ਲੇਸ਼ਣ ਆਖ਼ਿਰਕਾਰ ਜ਼ਵਾਬਦੇਹੀ ਹੈ: ਵਿਆਖਿਆ, ਫਿਕਸ, ਅਤੇ ਇਸ ਗੱਲ ਦੀ ਕਾਨਫ਼ੀਡੈਂਸ ਦੀ ਮਾਲਕੀ ਕਿ ਇਹ ਮੁੜ ਨਹੀਂ ਆਵੇਗਾ।
ਕੋਡ ਸਮੀਖਿਆ ਸਿਰਫ਼ ਸਟਾਈਲ ਚੈੱਕਲਿਸਟ ਨਹੀਂ ਹੈ। ਇਹ ਉਹ ਸਮਾਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਟੀਮ ਫੈਸਲਾ ਕਰਦੀ ਹੈ ਕਿ ਉਹ ਕੀ ਮੇਂਟੇਨ ਕਰਣ ਲਈ ਤਿਆਰ ਹੈ, ਸਮਰਥਨ ਦੇਵੇਗੀ, ਅਤੇ ਜਿਸਦਾ ਜਵਾਬਦੇਹ ਹੋਵੇਗੀ। AI ਤੁਹਾਨੂੰ ਵੱਧ ਦੇਖਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਇਹ ਤੈਅ ਨਹੀਂ ਕਰ ਸਕਦਾ ਕਿ ਕੀ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਕੀ ਤੁਹਾਡੇ ਉਤਪਾਦ ਦੇ ਇਰਾਦੇ ਨਾਲ ਫਿੱਟ ਬੈਠਦਾ ਹੈ, ਜਾਂ ਟੀਮ ਕਿਹੜੇ ਟਰੇਡ‑ਆਫ ਸਵੀਕਾਰਦੀ ਹੈ।
AI ਕੋਡਿੰਗ ਸਹਾਇਕ ਇਕ ਥੱਕਣ ਰਹਿਤ ਦੂਜਾ ਜੋੜਨਾਂ ਵਾਲੀ ਅੱਖ ਵਾਂਗ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ। ਉਹ ਤੇਜ਼ੀ ਨਾਲ:
ਇਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤੋਂ ਕਰਨ ਉੱਤੇ, AI PR ਖੋਲ੍ਹਣ ਤੋਂ ਲੈ ਕੇ ਖ਼ਤਰੇ ਦੇ ਨੋਟ ਕਰਨ ਤੱਕ ਸਮਾਂ ਘਟਾਉਂਦਾ ਹੈ।
ਸਮੀਖਿਆ ਸਹੀ ਹੋਣ ਦੀ ਜਾਂਚ ਸਿਰਫ ਇਹ ਨਹੀਂ ਕਿ ਕੋਡ ਕੰਪਾਈਲ ਹੁੰਦਾ ਹੈ। ਮਨੁੱਖ ਬਦਲਾਅ ਨੂੰ ਅਸਲੀ ਉਪਭੋਗੀ ਵਰਤਾਰੇ, ਪ੍ਰੋਡਕਸ਼ਨ ਸੀਮਾਵਾਂ, ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਦੀ ਮੈਨਟੇਨਬਿਲਟੀ ਨਾਲ ਜੋੜਦੇ ਹਨ।
ਇੱਕ ਸਮੀਖਿਆਕਾਰ ਨੂੰ ਅਜੇ ਵੀ ਫੈਸਲਾ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ:
AI ਨੂੰ ਦੂਜੇ ਸਮੀਖਿਆਕਾਰ ਵਾਂਗੋ ਬਣਾਓ, ਆਖ਼ਰੀ ਮਨਜ਼ੂਰੀ ਨਹੀਂ। ਇਸਨੂੰ ਨਿਸ਼ਾਨਦਾਰ ਪਾਸ ਮੰਗੋ (ਸੁਰੱਖਿਆ ਚੇਕ, ਐਜ‑ਕੇਸ, ਬੈਕਵਰਡ‑ਕੰਪੈਟਬਿਲਟੀ), ਫਿਰ ਮਨੁੱਖੀ ਫੈਸਲਾ ਕਰੋ ਕਿ ਸਕੋਪ, ਪ੍ਰਾਇਟੀ, ਅਤੇ ਕੀ ਬਦਲੇਗਾ ਟੀਮ ਮਿਆਰ ਅਤੇ ਉਤਪਾਦ ਇਰਾਦੇ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
AI ਕੋਡਿੰਗ ਸਹਾਇਕ ਤੇਜ਼ੀ ਨਾਲ ਟੈਸਟ ਜਨਰੇਟ ਕਰ ਸਕਦੇ ਹਨ, ਪਰ ਉਹ ਗੁਣਵੱਤਾ ਦੀ ਮਾਲਕੀ ਨਹੀਂ ਲੈ ਸਕਦੇ। ਇੱਕ ਟੈਸਟ ਸੂਟ ਇਹ ਬੈਟ ਹੈ ਕਿ ਕੀ ਟੁੱਟ ਸਕਦਾ ਹੈ, ਕੀ ਕਦੇ ਵੀ ਨਹੀਂ ਟੁੱਟਣਾ ਚਾਹੀਦਾ, ਅਤੇ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਐਜ‑ਕੇਸ ਨੂੰ ਬਿਨਾਂ ਪਰਖੇ ਛੱਡਣ ਲਈ ਤਿਆਰ ਹੋ। ਇਹ ਬੇਟਸ ਉਤਪਾਦ ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਦੇ ਫੈਸਲੇ ਹਨ—ਹੁਣ ਵੀ ਮਨੁੱਖੀ।
ਸਹਾਇਕ ਯੂਨਿਟ ਟੈਸਟ ਸਕੈਫੋਲਡਿੰਗ, ਡਿਪੈਂਡੈਂਸੀ ਮੌਕਿੰਗ, ਅਤੇ ਇਮਪਲੀਮੈਂਟੇਸ਼ਨ ਦੇ "ਹੈਪੀ ਪਾਥ" ਦੇ ਕਵਰੇਜ ਵਿੱਚ ਚੰਗੇ ਹਨ। ਜੋ ਉਹ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਉਹ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਕਿ ਕਿਹੜੀ ਕੋਵਰੇਜ ਅਹਮ ਹੈ।
ਮਨੁੱਖ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ:
ਜ਼ਿਆਦਾਤਰ ਟੀਮਾਂ ਨੂੰ "ਹੋਰ ਟੈਸਟ" ਦੀ ਲੋੜ ਨਹੀਂ, ਬਲਕਿ ਲੇਅਰਡ ਰਣਨੀਤੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। AI ਇਨ੍ਹਾਂ ਨੂੰ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਚੋਣ ਅਤੇ ਸੀਮਾਵਾਂ ਮਨੁੱਖੀ‑ਅਗਵਾਈ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ:
AI-ਜਨਰੇਟ ਕੀਤੇ ਟੈਸਟ ਅਕਸਰ ਕੋਡ ਨੂੰ ਬਹੁਤ ਨੇੜੇ ਤੋਂ ਮਿਰਰ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਨਾਜ਼ੁਕ ਐਸਰਸ਼ਨ ਜਾਂ ਓਵਰ‑ਮੌਕਡ ਸੈਟਅਪ ਬਣਦੇ ਹਨ ਜੋ ਅਸਲ ਵਿਹਾਰ ਫੇਲ ਹੋਣ 'ਤੇ ਵੀ ਪਾਸ ਕਰ ਜਾਦੇ ਹਨ। ਡਿਵੈਲਪਰ ਇਸਨੂੰ ਰੋਕਣ ਲਈ:
ਚੰਗੀ ਰਣਨੀਤੀ ਤੁਹਾਡੇ ਸ਼ਿਪਿੰਗ ਢੰਗ ਨਾਲ ਮਿਲਦੀ ਹੋਵੇ। ਤੇਜ਼ ਰਿਲੀਜ਼ਜ਼ ਨੂੰ ਮਜਬੂਤ ਆਟੋਮੇਟਿਕ ਚੈਕ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਸਪਸ਼ਟ ਰੋਲਬੈਕ ਰਾਹ; ਹੌਲੀ ਰਿਲੀਜ਼ ਚੜ੍ਹਾਈ ਪਹਿਲਾਂ ਜ਼ਿਆਦਾ ਪ੍ਰੀ‑ਮਰਜ ਵੈਧਤਾ ਸਵੀਕਾਰ ਕਰ ਸਕਦੀ ਹੈ। ਗੁਣਵੱਤਾ ਕੀਮਤ ਟੂਲ ਦੀ ਨਹੀਂ—ਟੀਮ ਦੀ ਹੈ।
ਗੁਣਵੱਤਾ ਕੋਵਰੇਜ ਦਾ ਇੱਕ ਨੰਬਰ ਨਹੀਂ। ਟਰੈਕ ਕਰੋ ਕਿ ਕੀ ਟੈਸਟਿੰਗ ਨਤੀਜਿਆਂ ਨੂੰ ਸੁਧਾਰ ਰਹੀ ਹੈ: ਕਮ ਪ੍ਰੋਡਕਸ਼ਨ ਇਨਸੀਡੈਂਟ, ਤੇਜ਼ ਰਿਕਵਰੀ, ਅਤੇ ਜ਼ਿਆਦਾ ਸੁਰੱਖਿਅਤ ਬਦਲਾਅ (ਛੋਟੇ ਰੋਲਬੈਕ, ਤੇਜ਼ ਭਰੋਸੇਯੋਗ ਡਿਪਲੌਇ)। AI ਕੰਮ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਜ਼ਿੰਮੇਵਾਰੀ ਡਿਵੈਲਪਰਾਂ ਦੀ ਹੀ ਰਹੇਗੀ।
ਸੁਰੱਖਿਆ ਕੰਮ ਕੋਡ ਜਨਰੇਟ ਕਰਨ ਤੋਂ ਜ਼ਿਆਦਾ ਚੋਣਾਂ ਕਰਨ ਬਾਰੇ ਹੁੰਦਾ ਹੈ ਜੋ ਹਕੀਕਤ ਦੇ ਸੀਮਿਆਂ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦੇ ਹਨ। AI ਚੈੱਕਲਿਸਟ ਅਤੇ ਆਮ ਗਲਤੀਆਂ ਦੱਸ ਸਕਦਾ ਹੈ, ਪਰ ਜੋਖਮ ਫੈਸਲਿਆਂ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਟੀਮ ਦੀ ਹੀ ਰਹੇਗੀ।
ਥ੍ਰੈਟ ਮਾਡਲਿੰਗ ਕੋਈ ਜਨਰਿਕ ਵਰਕ ਨਹੀਂ—ਕੀ ਮਹੱਤਵਪੂਰਨ ਹੈ ਇਹ ਤੁਹਾਡੇ ਬਿਜ਼ਨੈਸ, ਉਪਭੋਗੀ, ਅਤੇ ਫੇਲਿਅਰ ਮੋਡ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਹਾਇਕ ਆਮ ਖਤਰੇ (injection, broken auth, insecure defaults) ਦੱਸ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਤੁਹਾਡੇ ਉਤਪਾਦ ਲਈ ਸਬ ਤੋਂ ਮਹਿੰਗਾ ਕੀ ਹੈ: ਅਕਾਊਂਟ ਟੇਕਓਵਰ, ਡੇਟਾ ਲੀਕ, ਜਾਂ ਸੇਵਾ ਵਿਘਟਨ।
AI ਮਾਲੂਮ ਆਂਟੀ‑ਪੈਟਰਨ ਪਛਾਣਨ ਵਿੱਚ ਚੰਗਾ ਹੈ, ਪਰ ਕਈ ਘਟਨਾਵਾਂ ਐਪ‑ਖ਼ਾਸ ਵੇਰਵਿਆਂ ਤੋਂ ਹੁੰਦੀਆਂ ਹਨ: ਇੱਕ ਪਰਮੀਸ਼ਨ ਐਜ‑ਕੇਸ, ਇਕ "ਅਸਥਾਈ" ਐਡਮਿਨ ਐਂਡਪਾਇੰਟ, ਜਾਂ ਕੋਈ ਵਰਕਫਲੋ ਜੋ ਅਣਜਾਣੇ ਵਿੱਚ ਮਨਜ਼ੂਰੀਆਂ ਨੂੰ ਬਾਈਪਾਸ ਕਰ ਦਿੰਦਾ ਹੈ। ਇਹ ਖ਼ਤਰਿਆਂ ਲਈ ਸਿਸਟਮ ਦੇ ਇਰਾਦੇ ਨੂੰ ਪੜ੍ਹਨਾ ਲੋੜੀਦਾ ਹੈ, ਸਿਰਫ਼ ਕੋਡ ਨਹੀਂ।
ਟੂਲ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾ ਸਕਦੇ ਹਨ ਕਿ ਕੀਜ਼ ਹਾਰਡਕੋੱਡ ਨਾ ਕਰੋ, ਪਰ ਪੂਰੀ ਨੀਤੀ ਦੀ ਮਾਲਕੀ ਨਹੀਂ ਲੈ ਸਕਦੇ:
AI ਪੁਰਾਣੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਫਲੈਗ ਹਾਈਲਾਈਟ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਟੀਮਾਂ ਨੂੰ ਅਜੇ ਵੀ ਪ੍ਰੈਕਟਿਸ ਲੋੜੀਦੀ ਹੈ: ਵਰਜ਼ਨ ਪਿਨ ਕਰਨਾ, ਪ੍ਰੋਵੇਨੰਸ ਜਾਂਚਨਾ, ਟ੍ਰਾਂਜ਼ਟਿਵ ਡਿਪੈਂਡੈਂਸੀ ਦੀ ਸਮੀਖਿਆ ਕਰਨੀ, ਅਤੇ ਫੈਸਲਾ ਕਰਨਾ ਕਿ ਜੋਖਮ ਛਡਿਆ ਜਾਵੇ ਜਾਂ ਪੂਨਰ ਨਿਵੇਸ਼ ਕੀਤਾ ਜਾਵੇ।
ਕਾਗਜ਼ੀ ਕੰਮ ਸਿਰਫ਼ "ਐਨਕ੍ਰਿਪਸ਼ਨ ਲਗਾਓ" ਨਹੀਂ ਹੁੰਦਾ। ਇਹ ਨਿYANਤਰਣ, ਦਸਤਾਵੇਜ਼ੀ, ਅਤੇ ਜ਼ਵਾਬਦੇਹੀ ਹੈ: ਐਕਸੈਸ ਲੌਗ, ਮਨਜ਼ੂਰੀ ਟ੍ਰੇਲ, ਇੰਸੀਡੈਂਟ ਪ੍ਰਕਿਰਿਆ, ਅਤੇ ਇਸਦੀ ਪ੍ਰਮਾਣਿਕਤਾ। AI ਟੈਮਪਲੇਟ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਮਨੁੱਖੀ ਪ੍ਰਮਾਣੀਕਰਨ ਅਤੇ ਸਾਈਨ‑ਆਫ਼ ਕਰਨਗੇ—ਕਿਉਂਕਿ ਆਡੀਟਰਾਂ (ਅਤੇ ਗਾਹਕ) ਆਖ਼ਰਕਾਰ ਉਨ੍ਹਾਂ 'ਤੇ ਭਰੋਸਾ ਕਰਦੇ ਹਨ।
AI ਦਿਨ‑ਪਰ‑ਦਿਨ ਓਪਰੇਸ਼ਨਜ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਮਾਲਕੀ ਨਹੀਂ ਲੈ ਸਕਦਾ। ਵਿਸ਼ਵਾਸਯੋਗਤਾ ਅਣਿਸ਼ਚਿਤਤਾ ਹੇਠਾਂ ਫੈਸਲਿਆਂ ਦੀ ਲੜੀ ਹੈ, ਅਤੇ ਗਲਤ ਫੈਸਲੇ ਦੀ ਲਾਗਤ ਆਮ ਤੌਰ 'ਤੇ ਧੀਰੇ ਫੈਸਲੇ ਤੋਂ ਵੱਧ ਹੁੰਦੀ ਹੈ।
AI ਦ੍ਰੋਹ‑ਚੱਕਰਿਕ ਦਸਤਾਵੇਜ਼—রਨਬੁਕਸ, ਚੈੱਕਲਿਸਟ, ਅਤੇ "ਜੇ X ਤਾਂ Y ਕੋਸ਼ਿਸ਼ ਕਰੋ" ਪਲੇਬੁੱਕ—ਤਿਆਰ ਕਰਨ ਅਤੇ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਇਹ ਲੌਗਾਂ ਦਾ ਸੰਖੇਪ, ਇੱਕੋ ਜਿਹੇ ਅਲਰਟਾਂ ਨੂੰ ਕਲੱਸਟਰ ਕਰਨਾ, ਅਤੇ ਪਹਿਲੀ‑ਪਾਸ ਹਿਪੋਥੇਸਿਸ ਦੱਸਣ ਵਿੱਚ ਵੀ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।
ਇਸਦਾ ਅਰਥ:
ਇਹ ਤੇਜ਼ੀ ਲਈ ਵਧੀਆ ਹਨ, ਪਰ ਇਹ ਖ਼ੁਦ ਕੰਮ ਨਹੀਂ ਹਨ।
ਇੰਸੀਡੈਂਟ ਆਮ ਤੌਰ 'ਤੇ ਸਕ੍ਰਿਪਟ ਦੇ ਅਨੁਕੂਲ ਨਹੀਂ ਹੁੰਦੇ। on‑call ਇੰਜੀਨੀਅਰ ਅਣਸਪਸ਼ਟ ਸਿਗਨਲ, ਅੰਸ਼ਿਕ ਫੇਲਿਆਂ, ਅਤੇ ਘੁੰਮਦੇ ਟਰੇਡ‑ਆਫ ਦੇ ਨਾਲ ਨਿਪਟਦੇ ਹਨ ਜਦੋਂ ਘੜੀ ਬਣਾ ਰਹੀ ਹੁੰਦੀ ਹੈ। AI ਸੰਭਾਵਿਤ ਕਾਰਨ ਦੱਸ ਸਕਦਾ ਹੈ,ਪਰ ਇਹ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਫੈਸਲਾ ਨਹੀਂ ਕਰ ਸਕਦਾ ਕਿ ਕਿਸ ਨੂੰ ਪੇਜ ਕਰੋ, ਕਿਸ ਫੀਚਰ ਨੂੰ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਨਿਰਸਾਰ ਕਰੋ, ਜਾਂ ਡੇਟਾ ਇਨਟੀਗ੍ਰਿਟੀ ਬਚਾਉਣ ਲਈ ਛੋਟਾ ਪ੍ਰਭਾਵ ਸਵੀਕਾਰ ਕਰਨਾ ਹੈ।
ਡਿਪਲੌਇਮੈਂਟ ਸੁਰੱਖਿਆ ਹੋਰ ਇੱਕ ਮਨੁੱਖੀ ਜ਼ਿੰਮੇਵਾਰੀ ਹੈ। ਟੂਲ ਰੋਲਬੈਕ, ਫੀਚਰ ਫਲੈਗ, ਜਾਂ ਸਟੇਜਡ ਰਿਲੀਜ਼ ਸਿਫਾਰਸ਼ ਕਰ ਸਕਦੇ ਹਨ, ਪਰ ਟੀਮ ਨੂੰ ਕਾਰੋਬਾਰੀ ਪ੍ਰਸੰਗ ਅਤੇ ਬਲਾਸਟ ਰੇਡੀਅਸ ਦੇ ਅਨੁਸਾਰ ਸਭ ਤੋਂ ਸੁਰੱਖਿਅਤ ਰਾਹ ਚੁਣਨਾ ਪੈਂਦਾ ਹੈ।
AI ਟਾਈਮਲਾਈਨ ਡਰਾਫਟ ਅਤੇ ਚੈਟ, ਟਿਕਟ, ਮਾਨੀਟਰਨਗ ਤੋਂ ਮੁੱਖ ਘਟਨਾਵਾਂ ਖਿੱਚ ਸਕਦਾ ਹੈ। ਮਨੁੱਖੀ ਕੁਝ ਅਹੰਕਾਰਿਕ ਹਿੱਸੇ ਕਰਦੇ ਹਨ: "ਚੰਗਾ" ਕੀ ਹੈ ਇਹ ਤੈਅ ਕਰਨਾ, ਫਿਕਸਾਂ ਨੂੰ ਤਰਜੀਹ ਦੇਣਾ, ਅਤੇ ਉਹ ਤਬਦੀਲੀਆਂ ਕਰਨਾ ਜੋ ਦੁਹਰਾਵਾਂ ਨੂੰ ਰੋਕਦੀਆਂ ਹਨ (ਸਿਰਫ਼ ਇੱਕੋ ਲੱਛਣ ਨੂੰ ਨਹੀਂ)।
ਜੇ ਤੁਸੀਂ AI ਨੂੰ ops ਕਾਗਜ਼ਾਤ ਅਤੇ ਪੈਟਰਨ‑ਖੋਜ ਲਈ ਕੋ‑ਪਾਇਲਟ ਮੰਨ ਕੇ ਵਰਤੋਂ—ਨ ਕਿ ਇੰਸੀਡੈਂਟ ਕਮਾਂਡਰ ਵਜੋਂ—ਤਾਂ ਤੁਹਾਨੂੰ ਤੇਜ਼ੀ ਮਿਲੇਗੀ ਬਿਨਾਂ ਜ਼ਵਾਬਦੇਹੀ ਛੱਡੇ।
AI ਸੰਕਲਪਾਂ ਨੂੰ ਸਪਸ਼ਟ ਅਤੇ ਮੰਗਤ ਤਰੀਕੇ ਨਾਲ ਸਮਝਾ ਸਕਦਾ ਹੈ: "CQRS ਕੀ ਹੈ?", "ਇਹ ਡੇਡਲਾਕ ਕਿਉਂ ਹੁੰਦਾ ਹੈ?", "ਇਸ PR ਦਾ ਸੰਖੇਪ ਦਿਓ"। ਇਹ ਟੀਮਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਪਰ ਕਾਰਜਸਥਲ 'ਤੇ ਸੰਚਾਰ ਸਿਰਫ ਜਾਣਕਾਰੀ ਬਟਵਾਰਾ ਨਹੀਂ—ਇਹ ਭਰੋਸਾ ਬਣਾਉਣਾ, ਸਾਂਝੇ ਰਿਵਾਜਾਂ ਦੀ ਸਥਾਪਨਾ, ਅਤੇ ਉਹ ਵਚਨਬੱਧਤਾਵਾਂ ਬਣਾਉਣਾ ਹੈ ਜਿਨ੍ਹਾਂ 'ਤੇ ਲੋਕ ਨਿਰਭਰ ਕਰ ਸਕਦੇ ਹਨ।
ਨਵੇਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਸਿਰਫ ਉੱਤਰਾਂ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ; ਉਹ ਪ੍ਰਸੰਗ ਅਤੇ ਰਿਸ਼ਤੇ ਲੋੜਦੇ ਹਨ। AI ਮੌਡੀਊਲਾਂ ਦਾ ਸੰਖੇਪ, ਪੜ੍ਹਨ ਦਾ ਰਸਤਾ, ਅਤੇ ਜਾਰਗਨ ਦਾ ਅਨੁਵਾਦ ਕਰ ਕੇ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਮਨੁੱਖਾਂ ਨੂੰ ਸਿਖਾਉਣਾ ਪੈਂਦਾ ਹੈ ਕਿ "ਇੱਥੇ ਕੀ ਮਹੱਤਵਪੂਰਨ ਹੈ": ਟੀਮ ਕਿਸ ਟਰੇਡ‑ਆਫ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੀ ਹੈ, ਇਸ ਕੋਡਬੇਸ ਵਿੱਚ "ਚੰਗਾ" ਕੀ ਹੈ, ਅਤੇ ਕਿਸ ਨਾਲ ਗੱਲ ਕਰਨੀ ਹੈ ਜਦੋਂ ਕੁਝ ਗਲਤ ਲਗੇ।
ਅਧਿਕਤਮ ਪ੍ਰਾਜੈਕਟ friction ਭੂਮਿਕਾਵਾਂ ਦਰਮਿਆਂਨ ਆਉਂਦਾ ਹੈ: ਪ੍ਰੋਡਕਟ, ਡਿਜ਼ਾਇਨ, QA, ਸੁਰੱਖਿਆ, ਸਪੋਰਟ। AI ਮੀਟਿੰਗ ਨੋਟ ਤਿਆਰ ਕਰਨ, ਐਕਸੈਪਟੈਂਸ ਕਰਾਈਟੇਰੀਆ ਸੁਝਾਉਣ, ਜਾਂ ਫੀਡਬੈਕ ਨੂੰ ਨਿਰਪੱਖ ਢੰਗ ਨਾਲ ਦੁਹਰਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਲੋਕਾਂ ਨੂੰ ਇਹ ਅਜੇ ਵੀ ਨਿਊਨੀਕਰਨ, ਪ੍ਰਾਇਰਿਟਾਈਜ਼, ਅਤੇ ਉਹ ਵੇਖਣਾ ਹੋਵੇਗਾ ਜਦੋਂ ਕੋਈ ਹਿੱਸੇਦਾਰ "ਹਾਂ" ਕਹਿ ਰਿਹਾ ਹੈ ਪਰ ਅਸਲ ਵਿੱਚ ਸਹਿਮਤ ਨਹੀਂ।
ਜਦੋਂ ਜ਼ਿੰਮੇਵਾਰੀ ਧੁੰਦਲੀ ਹੁੰਦੀ ਹੈ, ਟੀਮ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ। AI ਚੈਕਲਿਸਟ ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਜ਼ਿੰਮੇਵਾਰੀ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਮਨੁੱਖਾਂ ਨੂੰ ਤੈਅ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਕਿ "ਡੋਨ" ਦਾ ਕੀ ਮਤਲਬ ਹੈ (ਟੈਸਟ? ਡੌਕ? ਰੋਲਆਉਟ ਯੋਜਨਾ? ਮਾਨੀਟਰਨਗ?), ਅਤੇ ਮਰਜ ਮਗਰੋਂ ਕੌਣ ਕੀ ਸੰਭਾਲੇਗਾ—ਖ਼ਾਸ ਕਰਕੇ ਜਦੋਂ AI-ਜਨਰੇਟ ਕੋਡ ਗੁੰਝਲਦਾਰ ਹੋਵੇ।
ਇਹ ਟੂਲਾਂ ਦੁਆਰਾ ਕੀਤੇ ਕੰਮ (tasks) ਅਤੇ ਟੀਮ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ (responsibilities) ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ।
ਕਿਉਂਕਿ ਟੀਮਾਂ "ਟਾਸਕ" ਨਹੀਂ ਭੇਜਦੀਆਂ—ਉਹ ਨਤੀਜੇ ਭੇਜਦੀਆਂ ਹਨ।
ਭਾਵੇਂ ਇੱਕ ਸਹਾਇਕ ਕੋਡ ਜਾਂ ਟੈਸਟ ਦਾ ਡ੍ਰਾਫਟ ਤਿਆਰ ਕਰੇ, ਤੁਹਾਡੀ ਟੀਮ ਫਿਰ ਵੀ ਜ਼ਿੰਮੇਵਾਰ ਰਹੇਗੀ:
“Replace” ਦਾ ਮਤਲਬ ਹੈ ਸੀਮਿਤ, ਤਸਦੀਕਯੋਗ ਅਤੇ ਘੱਟ ਜੋਖਮ ਵਾਲਾ ਕੰਮ ਜਿਸ ਵਿੱਚ ਗਲਤੀਆਂ ਅਸਾਨੀ ਨਾਲ ਪਤਾ ਲੱਗ ਜਾਂਦੀਆਂ ਹਨ।
ਚੰਗੇ ਉਮੀਦਵਾਰ ਹਨ:
ਉਨ੍ਹਾਂ ਗਾਰਡਰੇਲਾਂ ਨੂੰ ਵਰਤੋਂ ਜੋ ਗਲਤੀਆਂ ਨੂੰ ਸਪੌਟ ਅਤੇ ਸਸਤੀ ਬਣਾਉਂਦੀਆਂ ਹਨ:
ਕਿਉਂਕਿ "augment" ਕੰਮ ਵਿੱਚ ਅਕਸਰ ਲੁਕਵੇਂ ਪਾਬੰਦੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਮਾਡਲ ਸਹੀ ਤਰ੍ਹਾਂ ਅਨੁਮਾਨ ਨਹੀਂ ਲਗਾ ਸਕਦਾ:
AI ਆਊਟਪੁੱਟ ਨੂੰ ਇੱਕ ਡ੍ਰਾਫਟ ਸਮਝੋ ਜੋ ਤੁਹਾਨੂੰ ਆਪਣੇ ਸਿਸਟਮ ਦੇ ਅਨੁਕੂਲ ਬਨਾਉਣਾ ਪੈਦਾ ਹੈ, ਨਾ ਕਿ ਅਖੀਰਲਾ ਹੱਲ।
ਇਸਨੂੰ ਹੁਨਰਾਂਕ ਸਿਫਾਰਸ਼ਾਂ ਵਜੋਂ ਵਰਤੋਂ ਕਰੋ, ਨ ਕਿ ਨਤੀਜੇ ਵਜੋਂ।
ਵਰਕਫਲੋ:
ਜੇ ਕਿਸੇ ਸੁਝਾਅ ਦੀ ਪੜਤਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ, ਤਾਂ ਮੰਨੋ ਕਿ ਉਹ ਗਲਤ ਹੈ ਜਦ ਤੱਕ ਸਾਬਤ ਨਾ ਹੋਵੇ।
AI ਤੁਹਾਨੂੰ ਜ਼ਿਆਦਾ ਚੀਜ਼ਾਂ ਨੋਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਮਨੁੱਖ ਅੰਤਿਮ ਤੌਰ 'ਤੇ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸ਼ਿਪ ਹੋਵੇ।
ਉਪਯੋਗੀ ਪੁੱਛਣੇ:
ਫਿਰ ਮਨੁੱਖੀ ਪਾਸ ਕਰੋ: ਇਰਾਦਾ, ਰੱਖ‑ਪੋਸ, ਅਤੇ ਰਿਲੀਜ਼ ਰਿਸਕ (ਕੀ ਰਿਲੀਜ਼‑ਬਲਾਕਿੰਗ ਹੈ ਅਤੇ ਕੀ ਫਾਲੋਅਪ) ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ।
AI ਬਹੁਤ ਸਾਰੇ ਟੈਸਟ ਸ਼ੁਰੂਆਤੀ ਤੌਰ 'ਤੇ ਲਿਖ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਫੈਸਲਾ ਨਹੀਂ ਕਰ ਸਕਦਾ ਕਿ ਕਿੰਨੀ ਕੋਵਰੇਜ ਅਹਮ ਹੈ।
ਮਨੁੱਖ ਜ਼ਿੰਮੇਵਾਰ ਹਨ:
AI ਨੂੰ ਸਕੈਫੋਲਡ ਅਤੇ ਐਜ‑ਕੇਸ ਸੋਚਣ ਲਈ ਵਰਤੋ—ਪਰ ਕਵਾਲਿਟੀ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਮਨੁੱਖੀ ਹੋਵੇ।
ਕਿਉਂਕਿ ਇਹ ਫੈਸਲੇ ਬਿਜਨੈਸ ਸੰਦਰਭ ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਦੀ ਜ਼ਵਾਬਦੇਹੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।
AI ਕਰ ਸਕਦਾ ਹੈ:
ਮਨੁੱਖ ਫੈਸਲੇ ਕਰਨਗੇ:
ਕਦੇ ਵੀ ਪ੍ਰੋੰਪਟਾਂ ਵਿੱਚ ਸੀਕਰੇਟ ਜਾਂ ਸੰਵੇਦਨਸ਼ੀਲ ਗਾਹਕ/ਇੰਸੀਡੈਂਟ ਡੇਟਾ ਪੇਸਟ ਨਾ ਕਰੋ।
ਵਿਆਹਕ ਨਿਯਮ: