AI ਨਿਸ਼ਾਨੇ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ, ਕੋਡ ਲਿਖ ਸਕਦਾ ਹੈ ਅਤੇ ਫੀਡਬੈਕ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰ ਸਕਦਾ ਹੈ—ਇਸ ਨਾਲ PMs ਅਤੇ ਇੰਜੀਨੀਅਰਾਂ ਦੀਆਂ ਭੂਮਿਕਾਵਾਂ, ਵਰਕਫਲੋਜ਼ ਅਤੇ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਬਦਲ ਰਹੀਆਂ ਹਨ।

ਕਾਫ਼ੀ ਸਮੇਂ ਲਈ, ਪ੍ਰੋਡਕਟ ਮੈਨੇਜਮੈਂਟ ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਦੇ درمیان ਵੰਡ ਕਾਫ਼ੀ ਸਾਫ਼ ਸੀ: PMs ਡਿਸਕਵਰੀ ਅਤੇ ਫੈਸਲੇ (ਕੀ ਬਣਾਉਣਾ ਹੈ ਅਤੇ ਕਿਉਂ) ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਸਨ, ਜਦੋਂ ਕਿ ਇੰਜੀਨੀਅਰਸ ਨਿਰਮਾਣ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਸਨ (ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ, ਸਮਾਂ ਕਿੰਨਾ ਲੱਗੇਗਾ, ਅਤੇ ਕਿਹੜੇ ਟਰੇਡਆਫ਼ ਕਬੂਲਯੋਗ ਹਨ)।
AI ਉਪਕਰਨ ਉਸ ਵੰਡ ਨੂੰ ਖਤਮ ਨਹੀਂ ਕਰਦੇ — ਪਰ ਉਹ ਉਸ ਹэндਆਫ਼ ਨੂੰ ਕਮਜ਼ੋਰ ਕਰਦੇ ਹਨ ਜੋ ਉਸਨੂੰ ਸਥਿਰ ਰੱਖਦਾ ਸੀ।
ਜ਼ਿਆਦਾਤਰ ਟੀਮਾਂ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਸਹਿਯੋਗ ਦਾ ਇਕਾਈ ਮੰਨਦੀਆਂ ਸਨ: ਇੱਕ PRD, ਯੂਜ਼ਰ ਸਟੋਰੀਜ਼, ਡਿਜ਼ਾਈਨ ਫਾਈਲ, ਟੈਸਟ ਪਲਾਨ। PMs ਇਨਪੁੱਟ ਤਿਆਰ ਜਾਂ ਸੰਭਾਲਦੇ ਹਨ, ਇੰਜੀਨੀਅਰਿੰਗ ਇਨ੍ਹਾਂ ਨੂੰ ਕਾਰਜਕਾਰੀ ਸਾਫਟਵੇਅਰ ਵਿੱਚ ਬਦਲ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਫੀਡਬੈਕ ਲੂਪਾਂ ਕੁਝ ਬਣਨ ਤੋਂ ਬਾਅਦ ਹੁੰਦੇ ਹਨ।
ਇਹ ਮਾਡਲ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਸਾਰੀਆਂ ਹਦਾਂ ਬਣਾਉਂਦਾ ਸੀ: ਜੇ ਤੁਸੀਂ ਦਸਤਾਵੇਜ਼ ਦੇ ਲੇਖਕ ਨਹੀਂ ਸੀ, ਤਾਂ ਤੁਸੀਂ ਅਮੂਮਨ ਤੌਰ 'ਤੇ ਸਮੀਖਿਆਕਾਰ ਹੁੰਦੇ।
AI-ਮਦਦ ਨਾਲ ਡ੍ਰਾਫਟ ਕਰਨ, ਸਾਰਾਂਸ਼ ਬਣਾਉਣ ਅਤੇ ਜਨਰੇਟ ਕਰਨ ਨਾਲ, ਟੀਮਾਂ ਅਕਸਰ ਇੱਕ ਸਾਂਝੇ “ਮਾਡਲ” ਤੇ ਕੰਮ ਕਰਨ ਲੱਗਦੀਆਂ ਹਨ: ਇੱਕ ਜੀਵੰਤ ਸੰਦਰਭ ਜੋ ਪੁੱਛਿਆ, ਰੀਫੈਕਟਰ ਕੀਤਾ ਅਤੇ ਵੱਖ-ਵੱਖ ਫਾਰਮੇਟਾਂ ਵਿੱਚ ਤਰਜਮਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
ਉਹੀ ਮੂਲ ਇਰਾਦਾ ਜਲਦੀ-ਨਾਲ ਇਹ ਬਣ ਸਕਦਾ ਹੈ:
ਜਦੋਂ ਤਰਜਮਾ ਸਸਤਾ ਹੋ ਜਾਂਦਾ ਹੈ, ਸੀਮਾ ਹਿਲਦੀ ਹੈ। PMs ਅਗਾਂਹ Implementation ਦੀ ਜਾਂਚ ਪਹਿਲਾਂ ਕਰ ਸਕਦੇ ਹਨ (“ਜੇ ਅਸੀਂ X ਵੱਲ ਬਦਲਾਈ ਕਰੀਏ ਤਾਂ ਕੀ ਲੱਗੇਗਾ?”), ਅਤੇ ਇੰਜੀਨੀਅਰ ਜਲਦੀ-прੋਡਕਟ ਇਰਾਦੇ 'ਤੇ ਫੈਸਲੇ ਲੈ ਸਕਦੇ ਹਨ (“ਜੇ ਅਸੀਂ Y ਲਈ optimize ਕਰੀਏ, ਤਾਂ ਲਕਸ਼ ਤਬ ਵੀ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ?”)।
AI ਤੁਹਾਡੇ ਪੁਰਾਣੇ ਲੇਨ ਤੋਂ ਬਾਹਰ ਕੰਮ ਕਰਨ ਦੀ ਘੜੀ ਘਟਾਉਂਦਾ ਹੈ। ਇਹ ਮਦਦਗਾਰ ਹੈ, ਪਰ ਇਹ ਉਮੀਦਾਂ ਵੀ ਬਦਲ ਦਿੰਦਾ ਹੈ: PMs ਤੋਂ ਅਮੀਤਤਾ ਦੀ ਉਮੀਦ ਹੋ ਸਕਦੀ ਹੈ, ਅਤੇ ਇੰਜੀਨੀਅਰਸ ਤੋਂ ਸਕੋਪ ਵਿੱਚ ਬੇਹਤਰ ਹਿੱਸਾ ਲੈਣ ਦੀ।
ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਜੋ ਧੁੰਦਲਾ ਹੁੰਦਾ ਹੈ ਉਹ ਹੈ ਪ੍ਰਾਇਕਟਿਕਲ ਕੰਮ: ਸਪੈੱਕਸ, ਛੋਟੇ ਕੋਡ ਬਦਲਾਅ, ਟੈਸਟਿੰਗ, ਅਤੇ ਡੇਟਾ ਸਵਾਲ—ਉਹ ਖੇਤਰ ਜਿੱਥੇ ਤੇਜ਼ੀ ਮਤਲਬੀ ਹੁੰਦੀ ਹੈ ਅਤੇ AI ਇਰਾਦੇ ਨੂੰ ਮਿੰਟਾਂ ਵਿੱਚ ਆਰਟੀਫੈਕਟਸ ਵਿੱਚ ਤਰਜਮਾ ਕਰ ਸਕਦਾ ਹੈ।
AI ਟੂਲ ਜ਼ਿਆਦਾਤਰ “ਪਹਿਲਾ ਡਰਾਫਟ” ਲਿਖਣ ਵਾਲੇ ਵਾਂਗ ਕੰਮ ਕਰਦੇ ਹਨ। ਇਸ ਨਾਲ ਲੋੜਾਂ ਦਾ ਕੰਮ ਖਾਲੀ ਸਫ਼ੇ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਬਜਾਏ ਇੱਕ ਡਰਾਫਟ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ—ਅਕਸਰ ਇਤਨਾ ਵਧੀਆ ਕਿ ਟੀਮ ਇਸ ਨੂੰ ਸਮੀਖਿਆ, ਤੰਗ ਅਤੇ ਰੇਖਾਬੱਧ ਕਰ ਸਕਦੀ ਹੈ।
ਆਮ PM ਨਿਕਾਸ ਤੇਜ਼ ਤੇ ਸੰਗਠਿਤ ਬਣ ਜਾਂਦੇ ਹਨ:
ਜਿੱਤ ਇਹ ਨਹੀਂ ਹੈ ਕਿ AI “ਉਤਪਾਦ ਨੂੰ ਜਾਣਦਾ” ਹੈ। ਜਿੱਤ ਇਹ ਹੈ ਕਿ ਇਹ ਢਾਂਚਾ ਲਗਾਤਾਰ ਲਗਾਉਂਦਾ ਹੈ, ਸ਼ਬਦਾਵਲੀ ਇਕਸਾਰ ਰੱਖਦਾ ਹੈ, ਅਤੇ ਵਿਕਲਪ ਤੁਰੰਤ ਤਿਆਰ ਕਰਦਾ ਹੈ—ਇਸ ਲਈ PMs ਅਤੇ ਇੰਜੀਨੀਅਰਸ ਜ਼ਿਆਦਾ ਸਮਾਂ ਮਨੋਰਥ ਅਤੇ ਪਾਬੰਦੀਆਂ 'ਤੇ ਬਹਿਸ ਕਰਨ ਵਿੱਚ ਲਗਾਉਂਦੇ ਹਨ, ਦਸਤਾਵੇਜ਼ ਫਾਰਮੈਟਿੰਗ 'ਤੇ ਨਹੀਂ।
AI ਅੰਦੇਸ਼ ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ। ਜੇ ਪ੍ਰਾਂਪਟ ਕਹਿੰਦਾ ਹੈ “ਓਨਬੋਰਡਿੰਗ ਸੁਧਾਰੋ,” ਤੁਹਾਨੂੰ ਵਿਅਾਪਕ ਯੂਜ਼ਰ ਸਟੋਰੀਜ਼ ਅਤੇ ਧੁੰਦਲੇ ਸਵੀਕਾਰਤਾ ਮਾਪਦੰਡ ਮਿਲਣਗੇ। ਫਿਰ ਟੀਮ ਇੰਪਲੀమెਂਟੇਸ਼ਨ 'ਤੇ ਬਹਿਸ ਕਰਦੀ ਹੈ ਬਿਨਾਂ ਇਹ ਤੈਅ ਕੀਤੇ ਕਿ “ਵਧੀਆ” ਦੀ ਪਰਿਭਾਸ਼ਾ ਕੀ ਹੈ।
ਇੱਕ ਸਧਾਰਨ ਸਧਾਰਾ ਹੱਲ: ਪ੍ਰਾਂਪਟ 'ਚ ਸੰਦਰਭ + ਫੈਸਲਾ + ਪਾਬੰਦੀਆਂ ਸ਼ਾਮਿਲ ਕਰੋ। ਲਕਸ਼ਤ ਉਪਭੋਗਤਾ, ਮੌਜੂਦਾ ਵਰਤੋਂ, ਸਫਲਤਾ ਮੈਟ੍ਰਿਕ, ਪਲੇਟਫਾਰਮ ਸੀਮਾਵਾਂ, ਅਤੇ ਜੋ ਬਦਲਣਾ ਨਹੀਂ ਚਾਹੀਦਾ ਉਹ ਸ਼ਾਮਿਲ ਕਰੋ।
AI ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਸਤਾਵ ਸਮਝੋ, ਨਿਰਦੇਸ਼ ਨਹੀਂ।
ਇਸ ਨਾਲ ਗਤੀ ਬਰਕਰਾਰ ਰਹਿੰਦੀ ਹੈ ਬਗੈਰ ਜ਼ਿੰਮੇਵਾਰੀ ਗੁਆਉਂਦੇ—ਅਤੇ ਬਾਅਦ ਵਿੱਚ “ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਸੀ” ਵਾਲੀਆਂ ਹੈਰਾਨੀਆਂ ਘੱਟ ਹੁੰਦੀਆਂ ਹਨ।
AI ਮੈਦਾਨੀ ਡਿਸਕਵਰੀ ਕੰਮ ਨੂੰ ਘੰਟਿਆਂ ਵਿੱਚ ਸঙ্কੁਚਿਤ ਕਰ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਗੰਦਲੇ ਇਨਪੁੱਟ—ਸਪੋਰਟ ਟਿਕਟਾਂ, ਕਾਲ ਨੋਟਸ, ਐਪ ਸਮੀਖਿਆਵਾਂ, ਸਰਵੇ ਕਮੈਂਟ, ਕਮਿਊਨਿਟੀ ਥ੍ਰੇਡ—ਨੂੰ ਸਟਰੱਕਚਰਡ ਥੀਮਾਂ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਹੱਥੋਂ ਹੱਥ ਸਭ ਕੁੱਝ ਪੜ੍ਹਨ ਦੀ ਬਜਾਏ, ਪ੍ਰੋਡਕਟ ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਇੱਕੋ ਹੀ ਸਾਰਾਂਸ਼ ਤੋਂ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਨ: ਮੁੜ ਆਉਣ ਵਾਲੇ ਦਰਦ, ਉਹਨਾਂ ਸੰਦਰਭਾਂ ਜਿੱਥੇ ਉਹ ਪ੍ਰਗਟ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਖੋਜਣ ਲਾਇਕ ਮੌਕਿਆਂ ਦੀ ਇੱਕ ਛੋਟੀ ਸੂਚੀ।
ਅਧੁਨਿਕ AI ਟੂਲ ਇੱਕੋ ਜਿਹੇ ਸ਼ਿਕਾਇਤਾਂ ਨੂੰ ਕਲੱਸਟਰ ਕਰਨ ("ਮੋਬਾਈਲ 'ਤੇ ਚੈਕਆਉਟ ਫੇਲ ਹੋ ਰਿਹਾ hai"), ਉਪਭੋਗਤਾ ਦਾ "ਜੋਬ" ਨਿਕਾਲਣ, ਅਤੇ ਸਾਂਝੇ ਟ੍ਰਿਗਰਾਂ (ਡਿਵਾਈਸ ਟਾਈਪ, ਯੋਜਨਾ ਟੀਅਰ, ਵਰਕਫਲੋ ਕਦਮ) ਨੂੰ ਉਭਾਰੇ ਵਿਚ ਚੰਗੇ ਹਨ। ਕੀਮਤ ਸਿਰਫ ਗਤੀ ਨਹੀਂ—ਇਹ ਸਾਂਝਾ ਸੰਦਰਭ ਵੀ ਹੈ। ਇੰਜੀਨੀਅਰ ਟੈਕਨੀਕਲ ਸੀਮਾਵਾਂ ਨਾਲ ਜੁੜੇ ਰੁਝਾਨ ਵੇਖ ਸਕਦੇ ਹਨ (ਲੈਟੈਂਸੀ ਸਪਾਈਕ, ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਏਜ ਕੇਸ) ਜਦੋਂ ਕਿ PMs ਉਨ੍ਹਾਂ ਨੂੰ ਉਪਭੋਗਤਾ ਨਤੀਜਿਆਂ ਨਾਲ ਜੋੜ ਸਕਦੇ ਹਨ।
ਡਿਸਕਵਰੀ ਨੂੰ ਤੇਜ਼ ਰੱਖਣ ਲਈ ਅਤੇ ਇਸਨੂੰ AI-ਚਲਿਤ ਅਨੁਮਾਨਤੋਂ ਬਚਾਉਣ ਲਈ, ਇੱਕ ਸਧਾਰਨ ਲੂਪ ਵਰਤੋ:
AI ਸੌਖੇ ਮਿਲਣ ਵਾਲੇ ਅਤੇ ਸਭ ਤੋਂ ਭਾਵੁਕ ਚੀਜ਼ਾਂ 'ਤੇ ਓਵਰਫਿਟ ਕਰ ਸਕਦਾ ਹੈ: ਪਾਵਰ ਯੂਜ਼ਰ, ਗੁੱਸੇਲੇ ਟਿਕਟ, ਜਾਂ ਸਭ ਤੋਂ ਵਧੀਆ ਲਿਖਿਆ ਗਿਆ ਚੈਨਲ। ਇਹ ਬਹੁਤ ਸਮਝਦਾਰ ਕਹਾਣੀਆਂ ਵੀ ਬਣਾਉਂਦਾ ਹੈ, ਜੋ ਵਿਰੋਧਾਂ ਨੂੰ ਹਟਾ ਸਕਦੀਆਂ ਹਨ ਜੋ ਪ੍ਰੋਡਕਟ ਫ਼ੈਸਲਿਆਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ।
ਗਾਰਡਰੇਲ ਮਦਦ ਕਰਦੇ ਹਨ: ਸੇਗਮੈਂਟਾਂ 'ਚ ਸਰਪ੍ਰਾਈਜ਼ ਸਮਪਲਿੰਗ, ਯੂਜ਼ਰ ਬੇਸ ਸਾਈਜ਼ ਅਨੁਸਾਰ ਵਜ਼ਨ ਦਿੰਨਾ, “ਆਵ੍ਰਿਤੀ” ਨੂੰ “ਪ੍ਰਭਾਵ” ਤੋਂ ਵੱਖ ਕਰਨਾ, ਅਤੇ ਅਵਲੋਕਨ ਅਤੇ ਵਿਆਖਿਆ ਦੇ ਵਿਚਕਾਰ ਸਪਸ਼ਟ ਫਰਕ ਰੱਖਣਾ।
AI ਸਾਰਾਂਸ਼ ਅਤੇ ਸੁਝਾਅ ਦੇ ਸਕਦਾ ਹੈ। ਫੈਸਲੇ ਮਨੁੱਖੀ ਹੁਨਰ ਮੰਗਦੇ ਹਨ।
ਟਰੇਡਆਫ਼ ਚੁਣਨਾ, ਰਣਨੀਤੀ ਸੈਟ ਕਰਨਾ, ਅਤੇ ਕੀ ਨਾ ਬਣਾਉਣਾ ਇਹ ਸਭ ਰਣਨੀਤੀ, ਸਮੇਂ, ਤਕਨੀਕੀ ਲਾਗਤ, ਅਤੇ ਦੂਜੇ ਅਸਰਾਂ ਦੀ ਸਮਝ ਮੰਗਦੇ ਹਨ। ਮਕਸਦ ਤੇਜ਼ ਡਿਸਕਵਰੀ ਹੈ, ਪ੍ਰੋਡਕਟ ਸੋਚ ਨੂੰ ਠੇਕਾ ਦੇਣਾ ਨਹੀਂ।
AI ਇਹ ਬਦਲ ਰਿਹਾ ਹੈ ਕਿ ਟੀਮ ਕਿਸ ਤਰ੍ਹਾਂ ਉਤਪਾਦ ਨੂੰ ਬਣਨ ਤੋਂ ਪਹਿਲਾਂ ਦੇਖਦੀ ਹੈ। ਡਿਜ਼ਾਈਨ ਸਥਿਰ ਮੌਕਸ ਦੇਣ ਦੀ ਬਜਾਏ, PMs, ਡਿਜ਼ਾਈਨਰ ਅਤੇ ਇੰਜੀਨੀਅਰ ਇਕ ਪ੍ਰੋਟੋਟਾਈਪ 'ਤੇ ਮਿਲ ਕੇ ਕੰਮ ਕਰਦੇ ਹਨ ਜੋ ਦਿਨ-ਬ-ਦਿਨ ਵਿਕਸਤ ਹੁੰਦਾ ਹੈ—ਅਕਸਰ AI ਨਾਲ ਜਨਰੇਟ ਅਤੇ ਸੋਧਿਆ ਹੋਇਆ।
AI-ਸਹਾਇਤ ਡਿਜ਼ਾਈਨ ਟੂਲਾਂ ਅਤੇ LLMs ਨਾਲ, ਟੀਮ ਝਟ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ:
ਪਹਿਲੇ ਪ੍ਰੋਟੋਟਾਈਪ "ਇਹ ਕਿੱਹਦਾ ਹੈ" ਤੋਂ ਵੱਧ ਹੁੰਦੇ ਹਨ। ਉਹ ਇਹ ਵੀ ਦਰਸਾਉਂਦੇ ਹਨ ਕਿ "ਇਹ ਕੀ ਕਹਿੰਦਾ ਹੈ" ਅਤੇ "ਇਹ ਕਿਵੇਂ ਵਰਤੋਂ ਕਰਦਾ ਹੈ" ਹਰ ਸਟੇਟ ਲਈ।
ਇੰਜੀਨੀਅਰ AI ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੇਜ਼ੀ ਨਾਲ ਇੰਟਰੈਕਸ਼ਨ ਵਿਕਲਪ ਖੋਜ ਸਕਦੇ ਹਨ—ਫਿਰ ਗਰੁੱਪ ਨੂੰ ਭੇਟ ਕਰਦੇ ਹਨ ਪਹਿਲਾਂ ਕਿ ਭਾਰੀ ਡਿਜ਼ਾਈਨ ਕੰਮ ਸ਼ੁਰੂ ਹੋਵੇ। ਉਦਾਹਰਣ ਵਜੋਂ, ਇੱਕ ਇੰਜੀਨੀਅਰ ਫਿਲਟਰੀਂਗ, ਬਲਕ ਕਾਰਜ, ਜਾਂ ਪ੍ਰੋਗਰੈਸਿਵ ਡਿਸਕਲੋਜ਼ਰ ਲਈ ਵਿਕਲਪ ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਪ੍ਰਦਰਸ਼ਨ, ਪਹੁੰਚਯੋਗਤਾ, ਅਤੇ ਕੰਪੋਨੈਂਟ ਲਾਇਬ੍ਰੇਰੀ ਸੀਮਾਵਾਂ ਖਿਲਾਫ਼ ਚੈੱਕ ਕਰਦਾ ਹੈ।
ਇਸ ਨਾਲ ਫੀਡਬੈਕ ਲੂਪ ਛੋਟਾ ਹੋ ਜਾਂਦਾ ਹੈ: ਸੰਭਾਵਨਾ ਅਤੇ ਇੰਪਲੀమెਂਟੇਸ਼ਨ ਵੇਰਵੇ UX ਦੇ ਹਾਲੇ ਵੀ ਲਚਕੀਲਾਪੂਰਵਕ ਹੋਣ 'ਤੇ ਹੀ ਉਪਰ ਆਉਂਦੇ ਹਨ, ਨਾਕਿ ਇੱਕ ਦੇਰ ਨਾਲ ਹੋਏ ਹੈਂਡਆਫ਼ਟ ਤੋਂ ਬਾਅਦ।
PMs AI ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰੋਟੋਟਾਈਪ ਦੀ ਸਰੋਪਾਈ ਅਤੇ ਏਜ ਕੇਸ ਪ੍ਰੈਸ਼ਰ-ਟੈਸਟ ਕਰ ਸਕਦੇ ਹਨ: “ਜਦੋਂ ਨਤੀਜੇ ਨਹੀਂ ਮਿਲਦੇ ਤਾਂ ਯੂਜ਼ਰ ਕੀ ਵੇਖਦਾ ਹੈ?”, “ਇਸ ਐਰਰ ਨੂੰ ਵਰਤੋਂਕਾਰ ਨੂੰ ਬੇਇਜਜ਼ ਨਹੀਂ ਕਰਦੇ ਹੋਏ ਕਿਵੇਂ ਸਮਝਾਇਆ ਜਾਵੇ?”, “ਕਿਹੜੇ ਕਦਮ ਪਹਿਲੀ ਵਾਰੀ ਯੂਜ਼ਰ ਨੂੰ ਭੁਲਾਵਟ ਕਰ ਸਕਦੇ ਹਨ?”
ਉਹ ਪ੍ਰਾਰੂਪ FAQ, ਟੂਲਟਿਪ, ਅਤੇ A/B ਟੈਸਟਾਂ ਲਈ ਵਿਕਲਪਕ ਸੁਨੇਹੇ ਭੀ ਜਨਰੇਟ ਕਰ ਸਕਦੇ ਹਨ—ਇਸ ਲਈ ਪ੍ਰੋਡਕਟ ਖੋਜ ਵਿੱਚ ਭਾਸ਼ਾ ਵੀ ਸ਼ਾਮਿਲ ਹੁੰਦੀ ਹੈ, ਸਿਰਫ਼ ਫੀਚਰ ਨਹੀਂ।
ਹੈਂਡਆਫ਼ਟ "ਫਾਈਨਲ ਸਕ੍ਰੀਨਾਂ" ਤੋਂ ਸਾਂਝੇ ਪ੍ਰੋਟੋਟਾਈਪ + ਸਪਸ਼ਟ ਫੈਸਲਿਆਂ ਤੱਕ ਬਦਲਦਾ ਹੈ: ਕੀ ਸ਼ਾਮਿਲ ਹੈ, ਕੀ ਮੁਅੱਹਮ ਹੈ, ਅਤੇ ਕੀ ਮਾਪਯੋਗ ਹੈ।
ਪ੍ਰੋਟੋਟਾਈਪ ਇੱਕ ਜੀਵੰਤ ਆਰਟੀਫੈਕਟ ਬਣ ਜਾਂਦਾ ਹੈ ਜਿਸਨੂੰ ਪੂਰੀ ਟੀਮ ਅਪਡੇਟ ਕਰਦੀ ਹੈ ਜਿਵੇਂ ਹੀ ਸੀਮਾਵਾਂ, ਸਿੱਖਿਆ ਅਤੇ ਲੋੜਾਂ ਬਦਲਦੀਆਂ ਹਨ—ਇਸ ਨਾਲ ਹੈਰਾਨੀਆਂ ਘੱਟ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ UX ਲਗਾਤਾਰ, ਕ੍ਰਾਸ-ਫੰਕਸ਼ਨਲ ਜਿੰਮੇਵਾਰੀ ਬਣ ਜਾਂਦੀ ਹੈ।
AI ਕੋਡ ਜਨਰੇਸ਼ਨ ਉਤਪਾਦ ਇਰਾਦੇ ਅਤੇ ਕਾਰਜਕਾਰੀ ਸਾਫਟਵੇਅਰ ਦੀ ਦੂਰੀ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਜਦੋਂ ਇੱਕ PM ਇੱਕ ਸਹਾਇਕ ਤੋਂ ਛੋਟੀ UI, ਨਮੂਨਾ API ਬੇਨਤੀ, ਜਾਂ ਨਿਯੂਨਤਮ ਸਕ੍ਰਿਪਟ ਮੰਗ ਸਕਦਾ ਹੈ, ਗੱਲਬਾਤ ਧਾਰਮਿਕ ਲੋੜਾਂ ਤੋਂ ਸਿੱਧੇ ਬਿਹੈਵਿਅਰ ਵੱਲ ਬਦਲ ਜਾਂਦੀ ਹੈ।
ਇਹ ਉਥੇ ਵੀ ਹੈ ਜਿੱਥੇ “ਵਾਈਬ-ਕੋਡਿੰਗ” ਪਲੇਟਫਾਰਮ ਸਹਿਯੋਗ ਦੀ ਗਤੀ ਬਦਲ ਦਿੰਦੇ ਹਨ: ਜਿਵੇਂ Koder.ai ਵਰਗੇ ਟੂਲ ਟੀਮਾਂ ਨੂੰ ਚੈਟ ਤੋਂ ਸਿੱਧੇ ਵੈੱਬ, ਬੈਕਐਂਡ, ਅਤੇ ਮੋਬਾਈਲ ਐਪ ਟੁਕੜੇ ਬਣਾਉਣ ਦਿੰਦੇ ਹਨ, ਤਾਂ ਇੱਕ PM ਇੱਕ ਫਲੋ ਪ੍ਰਸਤਾਵ ਕਰ ਸਕਦਾ ਹੈ, ਇੱਕ ਇੰਜੀਨੀਅਰ ਉਸਨੂੰ ਮਜ਼ਬੂਤ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਦੋਹਾਂ ਇਕੋ ਆਰਟੀਫੈਕਟ 'ਤੇ ਦੁਹਰਾਅ ਕਰ ਸਕਦੇ ਹਨ—ਬਰਕਰਾਰ ਰਿਲੀਜ਼ ਸਾਈਕਲ ਦੀ ਉਡੀਕ ਕੀਤੇ ਬਿਨਾਂ।
ਜ਼ਿਆਦਾਤਰ AI ਟੂਲ ਉਹ ਕੰਮ ਚਮਕਦੇ ਹਨ ਜੋ ਵਰਨਣ ਕਰਨਾ ਆਸਾਨ ਹੈ ਪਰ ਪੂਰੇ ਇੰਜੀਨੀਅਰ ਸਾਈਕਲ ਨੂੰ ਖ਼ਰਚ ਕਰਨ ਦਾ ਜੁਸਟਿਫਿਕੇਸ਼ਨ ਮੁਸ਼ਕਿਲ ਹੈ:
ਇਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤਿਆ ਗਿਆ, AI ਕੋਡ ਇੱਕ ਤੇਜ਼ ਸਕੈਚ ਹੁੰਦਾ ਹੈ—ਕੁਝ ਜੋ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਲਈ ਹੈ, ਨਾ ਕਿ ਅੰਧੇ ਤੌਰ 'ਤੇ ਸ਼ਿਪ ਕਰਨ ਲਈ।
ਜੋ ਕੋਡ “ਚੱਲਦਾ” ਹੈ, ਉਹ ਆਪਣੇ ਆਪ ਵਿੱਚ ਪੁਰਾ मतलब ਨਹੀਂ ਰੱਖਦਾ ਕਿ ਉਹ ਉਤਪਾਦ ਲਈ ਠੀਕ ਹੈ।
ਸੁਰੱਖਿਆ ਅਤੇ ਗੋਪਨੀਯਤਾ ਦੀਆਂ ਲੋੜਾਂ (ਸੀਕ੍ਰੇਟ ਹੈਂਡਲਿੰਗ, PII, ਪਰਮਿਸ਼ਨ ਚੈਕ), ਆਰਕੀਟੈਕਚਰਲ ਪ੍ਰਥਾਵਾਂ (ਸੇਵਾ ਸੀਮਾਵਾਂ, ਡੇਟਾ ਮਾਡਲ), ਅਤੇ ਨਿਰੰਤਰਤਾ (ਪਾਠਯੋਗਤਾ, ਮਾਨਿਤਰਿੰਗ, ਐਰਰ ਹੈਂਡਲਿੰਗ) ਅਜੇ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹਨ। AI-ਜਨਰੇਟ ਕੀਤਾ ਕੋਡ ਅਕਸਰ ਉਹ ਸੰਦਰਭੀ ਸੀਮਾਵਾਂ ਗੁੰਮ ਕਰ ਦਿੰਦਾ ਹੈ ਜੋ ਇਹ ਨਹੀਂ ਦੇਖ ਸਕਦਾ—ਜਿਵੇਂ ਅੰਦਰੂਨੀ ਲਾਇਬ੍ਰੇਰੀਜ਼, ਅਨੁਕੂਲਤਾ ਨਿਯਮ, ਜਾਂ ਸਕੇਲਿੰਗ ਉਮੀਦਾ।
ਚੰਗੀ ਟੀਮ ਨਿਯਮ: ਇੰਜੀਨੀਅਰਿੰਗ ਉਤਪਾਦਨ ਕੋਡ ਦੀ ਮਾਲਕੀ ਰੱਖਦੀ ਹੈ, ਭਾਵੇਂ ਪਹਿਲਾ ਡਰਾਫਟ ਕਿਸ ਨੇ ਵੀ ਬਣਾਇਆ ਹੋਵੇ।
PM-ਦਰਿਆਫ਼ਤ ਸਨਿੱਪੇਟਸ ਡਿਜ਼ਾਈਨ ਆਰਟੀਫੈਕਟ ਜਾਂ ਢਾਂਚਾਵਾਂ ਵਾਂਗ ਵਰਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ—ਇਰਾਦੇ ਲਈ ਉਪਯੋਗੀ, ਪਰ ਉਹਨਾਂ ਨੂੰ ਉਹਨਾਂ ਹੀ ਮਿਆਰਾਂ ਨਾਲ ਰੋਕਿਆ ਜਾਂਦਾ ਹੈ: ਕੋਡ ਰਿਵਿਊ, ਟੈਸਟ, ਜਿੱਥੇ ਜ਼ਰੂਰੀ ਹੋਵੇ ਥ੍ਰੈਟ ਮਾਡਲਿੰਗ।
ਜੇ ਤੁਸੀਂ ਇੱਕ AI ਬਿਲਡ ਪਲੇਟਫਾਰਮ ਵਰਤਦੇ ਹੋ, ਸਿਧੀ ਸਿਧੀ ਪ੍ਰਿੰਸੀਪਲ ਲਾਗੂ ਹੁੰਦੀ ਹੈ: ਜੇਕਰ Koder.ai ਇੱਕ ਕੰਮਕਾਜ React UI ਅਤੇ Go ਬੈਕਐਂਡ ਤੇਜ਼ੀ ਨਾਲ (PostgreSQL ਪਿੱਛੇ) ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ ਵੀ, ਟੀਮਾਂ ਨੂੰ ਸਾਫ਼ ਮਰਜ ਅਤੇ ਰਿਲੀਜ਼ ਮਲਕੀਅਤ ਦੀ ਲੋੜ ਹੈ। Snapshots/rollback ਅਤੇ ਸੋਅਰਸ-ਕੋਡ ਐਕਸਪੋਰਟ ਵਰਗੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਮਦਦਗਾਰ ਹਨ, ਪਰ ਉਹ ਇੰਜੀਨੀਅਰਿੰਗ ਜ਼ਿੰਮੇਵਾਰੀ ਦੀ ਜਗ੍ਹਾ ਨਹੀਂ ਲੈ ਸਕਦੀਆਂ।
AI ਉਪਕਰਨ “ਅਸੀਂ ਕੀ ਸੋਚਿਆ ਸੀ” ਅਤੇ “ਅਸੀਂ ਕੀ ਸ਼ਿਪ ਕੀਤਾ” ਦਰਮਿਆਨ ਲੂਪ ਨੂੰ ਕਸ ਕੇ ਬੰਨ੍ਹ ਰਹੇ ਹਨ। ਜਿੱਥੇ ਸਵੀਕਾਰਤਾ ਮਾਪਦੰਡ ਪਹਿਲਾਂ PMs ਵੱਲੋਂ ਲਿਖੇ ਜਾਂਦੇ ਸਨ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇੰਜੀਨੀਅਰਿੰਗ ਜਾਂ QA ਵੱਲੋਂ ਸਮਝੇ ਜਾਂਦੇ ਸਨ, ਹੁਣ LLMs ਉਹਨਾਂ ਮਾਪਦੰਡਾਂ ਨੂੰ ਮਿੰਟਾਂ ਵਿੱਚ ਇਕ-ਦਮ ਟੈਸਟ ਕੇਸਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਸਕਦੇ ਹਨ—ਯੂਨਿਟ ਟੈਸਟ, API ਟੈਸਟ, ਅਤੇ end-to-end ਫਲੋਜ਼।
ਜਦੋਂ ਮਾਪਦੰਡ ਸਾਫ਼ ਹੁੰਦੇ ਹਨ, AI ਅਜਿਹੇ ਟੈਸਟ ਸਨਾਰੀਓਜ਼ ਡਰਾਫਟ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਅਸਲੀ ਉਪਭੋਗਤਾ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ, ਵਿਚਕਾਰ ਉਹ ਏਜ ਕੇਸ ਭੀ ਜੋ ਮਨੁੱਖ ਅਕਸਰ ਭੁੱਲ ਜਾਂਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ, “ਉਪਭੋਗਤਾ ਆਪਣੀ ਈਮੇਲ ਬਦਲ ਸਕਦੇ ਹਨ ਅਤੇ ਉਸਨੂੰ ਮੁੜ-ਸੰਪਰਕ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ” ਵਰਗਾ ਮਾਪਦੰਡ ਗਲਤ ਈਮੇਲ, ਮਿਆਦ-ਪੂਰਾ ਵੈਰੀਫਿਕੇਸ਼ਨ ਲਿੰਕ, ਅਤੇ ਵੈਰੀਫਿਕੇਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਲੌਗਇਨ ਕਰਨ ਦੇ ਪ੍ਰਯਾਸਾਂ ਲਈ ਟੈਸਟ ਵਧਾ ਸਕਦਾ ਹੈ।
ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਵਰਕਫਲੋ ਉਭਰ ਰਿਹਾ ਹੈ:
ਇਸ ਨਾਲ ਇੱਕ ਸਾਂਝਾ ਆਰਟੀਫੈਕਟ ਬਣਦਾ ਹੈ: ਸਵੀਕਾਰਤਾ ਮਾਪਦੰਡ ਹੁਣ ਹینڈਆਫ਼ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਰਹਿੰਦੇ—ਉਹ ਆਟੋਮੇਟਿਕ ਸੱਬੂਟ ਦੇ ਬੀਜ ਬਣ ਜਾਂਦੇ ਹਨ।
ਆਟੋ-ਜਨਰੇਟ किए ਟੈਸਟ ਮੰਨਣਯੋਗ ਦਿੱਸ ਸਕਦੇ ਹਨ ਪਰ ਜਿਹੜੇ ਮਹੱਤਵਪੂਰਨ ਚੀਜ਼ਾਂ ਨਹੀਂ ਕਵਰ ਕਰਦੇ। ਆਮ ਨਾਕਾਮੀ ਖੇਤਰਾਂ ਵਿਚ ਹੈਪੀ ਪਾਥ ਹੀ ਟੈਸਟ ਹੋਣਾ, ਗਲਤ ਚੀਜ਼ 'ਤੇ assertion (ਜਿਵੇਂ UI ਟੈਕਸਟ ਜਗ੍ਹਾ ਸਟੇਟ ਚੇन्ज) ਜਾਂ ਅਜਿਹੀਆਂ ਧਾਰਣਾਵਾਂ ਜੋ ਅਸਲੀ ਸਿਸਟਮ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੀਆਂ।
ਸਭ ਤੋਂ ਵੱਡਾ ਖਤਰਾ ਹੈ ਰਿਗ੍ਰੈਸ਼ਨ ਅੰਧਤਾ: ਟੀਮ ਇੱਕ ਫੀਚਰ ਨੂੰ ਇਹ ਸੋਚ ਕੇ ਮਰਜ਼ ਕਰ ਦਿੰਦੀ ਹੈ ਕਿ ਉਹ ਕਵਰ ਹੈ ਕਿਉਂਕਿ “ਟੈਸਟ ਮੌਜੂਦ ਹਨ,” ਭਾਵੇਂ ਉਹ ਸਭ ਤੋਂ ਸੰਭਾਵਤ ਫੇਲਿਆਵਾਂ ਤੋਂ ਸੁਰੱਖਿਅਤ ਨਾ ਕਰਨ।
AI-ਜਨਰੇਟ ਕੀਤੇ ਟੈਸਟਾਂ ਨੂੰ ਡ੍ਰਾਫਟ ਮੰਨੋ, ਪ੍ਰੂਫ਼ ਨਹੀਂ।
ਇਸ ਛੋਟੀ ਚੈੱਕਲਿਸਟ ਦੀ ਵਰਤੋਂ ਕਰੋ ਤਾਂ ਜੋ ਮਾਪਦੰਡ ਆਟੋਮੇਟ ਕਰਨ ਲਈ ਆਸਾਨ ਹੋਣ ਅਤੇ ਘੁੰਮਨ-ਫਿਰਨ ਘੱਟ ਹੋਵੇ:
ਜਦੋਂ ਲੋੜਾਂ ਟੈਸਟੇਬਲ ਹੁੰਦੀਆਂ ਹਨ, AI ਤੇਜ਼ੀ ਨਾਲ ਕਾਰਜ ਲਈ ਮਦਦ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਉਹ ਨਹੀਂ ਹੁੰਦੀਆਂ, ਇਹ ਗਲਤਫਹਮੀਆਂ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ।
AI ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਗੱਲ-ਬਾਤੀ ਬਣਾਉਂਦਾ ਹੈ: “ਨਵੀਂ ਓਨਬੋਰਡਿੰਗ ਨੇ ਐਕਟਿਵੇਸ਼ਨ ਵਧਾਈ?” ਇੱਕ ਪ੍ਰਾਂਪਟ ਬਣਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਮਿੰਟਾਂ ਵਿੱਚ SQL, ਇੱਕ ਚਾਰਟ, ਅਤੇ ਲਿਖਤੀ ਪ੍ਰਯੋਗ ਰਿਪੋਰਟ ਪ੍ਰਾਪਤ ਕਰ ਲੈਂਦੇ ਹੋ।
ਉਹ ਗਤੀ ਵਰਕਫਲੋ ਨੂੰ ਬਦਲ ਦੇਂਦੀ ਹੈ—PMs ਲਾਈਨਾਂ ਵਿੱਚ ਉਡੀਕ ਕੀਤੇ ਬਿਨਾਂ ਸਿਧਾਂਤ ਜਾਂਚ ਸਕਦੇ ਹਨ, ਅਤੇ ਇੰਜੀਨੀਅਰ ਇੰਸਟ੍ਰੂਮੈਂਟੇਸ਼ਨ ਦੀ ਗੁਣਵੱਤਾ 'ਤੇ ਧਿਆਨ ਦੇ ਸਕਦੇ ਹਨ ਨਾਂ ਕਿ ਐਡ-ਹਾਕ ਨਿਕਾਸ ਉੱਤੇ।
ਆਧੁਨਿਕ ਟੂਲ SQL ਡਰਾਫਟ ਕਰ ਸਕਦੇ ਹਨ, ਇੱਕ ਫਨਲ ਪਰਿਭਾਸ਼ਾ ਸੁਝਾ ਸਕਦੇ ਹਨ, ਡੈਸ਼ਬੋਰਡ ਬਣਾਉਣ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ A/B ਟੈਸਟ ਨੂੰ ਸੰਖੇਪ ਕਰ ਸਕਦੇ ਹਨ (ਉਪਲਿਫਟ, ਭਰੋਸਾ, ਸੈਗਮੈਂਟ ਵਿਭਾਜਨ)। PMs ਲਈ ਇਹ ਖੋਜ ਅਤੇ ਪੋਸਟ-ਲਾਂਚ ਮਾਨੀਟਰਿੰਗ ਦੌਰਾਨ ਤੇਜ਼ ਇਟਰੇਸ਼ਨ ਦਾ ਮਤਲਬ ਹੈ। ਇੰਜੀਨੀਅਰ ਲਈ, ਇਹ ਘੱਟ ਇੱਕ-ਬਾਰੀ ਬੇਨਤੀਆਂ ਅਤੇ ਜ਼ਿਆਦਾ ਡੇਟਾ ਕੈਪਚਰ ਸੁਧਾਰ 'ਤੇ ਕੰਮ ਕਰਨ ਦਾ ਸਮਾਂ ਦਿੰਦਾ ਹੈ।
ਮੁੱਦਾ ਇਹ ਹੈ: AI ਖੁਸ਼ੀ-ਖ਼ੁਸ਼ੀ ਇੱਕ ਪਰਿਭਾਸ਼ਾ ਦੇਵੇਗਾ ਜਦੋਂ ਕੰਪਨੀ ਕੋਲ ਇੱਕ ਹੀ ਪਰਿਭਾਸ਼ਾ ਹੋਣੀ ਚਾਹੀਦੀ। ਸੈਲਫ਼-ਸੇਰ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਟੀਮ ਨੇ ਸਥਿਰ ਕੀਤਾ ਹੋਵੇ:
ਜਦੋਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਸਥਿਰ ਹੁੰਦੀਆਂ ਹਨ, PM-ਚਲਿਤ ਵਿਸ਼ਲੇਸ਼ਣ ਜੋੜੀਦਾਰ ਹੁੰਦੀ ਹੈ—ਇੰਜੀਨੀਅਰ ਨੰਬਰਾਂ 'ਤੇ ਭਰੋਸਾ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਕਾਰਜਕਾਰੀ ਬਣਾਉਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ।
ਦੋ ਮੁੱਦੇ ਆਮ ਹਨ:
ਇੱਕ ਸਾਂਝੀ ਮੈਟ੍ਰਿਕ ਗਲੋਸਰੀ ਬਣਾਓ (ਇੱਕ ਸਰੋਤ-ਅਫ-ਸੱਚ) ਅਤੇ ਮੁੱਖ ਵਿਸ਼ਲੇਸ਼ਣਾਂ ਲਈ ਛੋਟੀ ਸਮੀਖਿਆ ਦੀ ਲੋੜ ਰੱਖੋ: ਮੁੱਖ ਰਿਲੀਜ਼, ਪ੍ਰਯੋਗ ਨਤੀਜੇ, ਅਤੇ ਬੋਰਡ-ਇਸਤਰੇ ਮਾਪਦੰਡ।
15-ਮਿੰਟ "ਐਨਾਲਿਟਿਕਸ PR" (PM ਡਰਾਫਟ; ਵਿਸ਼ਲੇਸ਼ਕ/ਇੰਜੀਨੀਅਰ ਸਮੀਖਿਆ) ਪਰਿਭਾਸ਼ਾ ਗਲਤੀਆਂ ਨੂੰ ਜਲਦੀ ਫੜ ਲੈਂਦੀ ਹੈ ਅਤੇ ਫੈਸਲਿਆਂ ਤੋਂ ਬਾਅਦ ਨੰਬਰਾਂ 'ਤੇ ਗੱਲਬਾਤ ਕਰਨ ਦੀ ਬਜਾਏ ਸਾਂਝਾ ਸੰਦਰਭ ਬਣਾਉਂਦੀ ਹੈ।
AI ਬੈਕਲੌਗ ਪ੍ਰਬੰਧਨ ਦੀ ਜਗ੍ਹਾ ਨਹੀਂ ਲੈਂਦਾ—ਪਰ ਇਹ ਉਸਦੀ ਬਣਤਰ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਗਰੂਮਿੰਗ ਨੂੰ ਅਧਿਕਰਤ ਭਾਗ-ਲਿਖਤ ਟਿਕਟਾਂ ਨੂੰ ਡਿਕੋਡ ਕਰਨ ਦੀ ਬਜਾਏ ਇਰਾਦੇ ਨੂੰ ਜਾਣ-ਪਛਾਣ ਵਾਲਾ ਬਣਾ ਦਿੰਦਾ ਹੈ।
ਜਦੋਂ ਟੀਮ AI ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਵਰਤਦੀ ਹੈ, ਬੈਕਲੌਗ ਇੱਕ ਸਾਫ਼ ਨਕਸ਼ਾ ਬਣ ਜਾਂਦਾ ਹੈ—not ਸਿਰਫ਼ ਇਕ ਸੂਚੀ।
ਰੀਫਾਈਨਮੈਂਟ ਵਿੱਚ, AI ਗੰਦਲੇ ਇਨਪੁੱਟ—ਸੇਲਜ਼ ਕਾਲਾਂ ਦੇ ਨੋਟਸ, ਸਪੋਰਟ ਥ੍ਰੇਡ, ਜਾਂ ਮੀਟਿੰਗ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ—ਨੂੰ ਕConsistent ਫਾਰਮੈਟ ਵਿੱਚ ਤੁਰੰਤ ਟਿਕਟਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੈ:
ਮੁੱਖ ਬਦਲਾਅ: PMs ਘੱਟ ਡਰਾਫਟਿੰਗ 'ਤੇ ਸਮਾਂ ਬਿਤਾਉਂਦੇ ਹਨ ਅਤੇ ਜ਼ਿਆਦਾ ਨਿਯਤ ਇਰਾਦਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹਨ। ਇੰਜੀਨੀਅਰ ਅਣਗੋਲੇ ਅਨੁਮਾਨਾਂ ਦੀ ਬਜਾਏ ਪਹਿਲਾਂ ਹੀ ਧਾਰਣਾਵਾਂ ਨੂੰ ਚੁਣੌਤੀ ਦਿੰਦੇ ਹਨ।
AI-ਸਹਾਇਤ ਸਮੀਖਿਆਉਂ ਉਨ੍ਹਾਂ ਖਤਰਾ ਸਿਗਨਲਾਂ ਨੂੰ ਰੰਗ ਦਿੰਦੇ ਹਨ ਜੋ ਟਿਕਟ ਨੂੰ “ਕੰਮ ਵਿੱਚ ਬੱਕ” ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਸਾਹਮਣੇ ਆ ਸਕਦੇ ਹਨ: ਅਸਪਸ਼ਟ ਗੈਰ-ਫੰਕਸ਼ਨਲ ਲੋੜਾਂ, ਛੁਪਿਆ ਹੋਇਆ ਮਾਈਗਰੇਸ਼ਨ ਕੰਮ, ਸੁਰੱਖਿਆ/ਗੋਪਨੀਯਤਾ ਸੰਬੰਧੀ ਮੁੱਦੇ, ਅਤੇ ਇੰਟਿਗਰੇਸ਼ਨ ਦੀ ਜਟਿਲਤਾ।
ਇਸ ਨਾਲ ਇੰਜੀਨੀਅਰਿੰਗ ਅਕਸਰ ਗਰੂਮਿੰਗ ਦੌਰਾਨ ਹੀ ਅਣਜਾਣੀਆਂ ਨੂੰ ਉਭਾਰਦੀ ਹੈ—ਅਕਸਰ mid-sprint ਦੀ ਬਜਾਏ—ਤਾਂ ਜੋ ਅਨੁਮਾਨ ਜੋਖਮ ਬਾਰੇ ਗੱਲਬਾਤ ਬਣ ਜਾਣ।
ਪ੍ਰਯੋਗਿਕ ਰੂਪ ਇਹ ਹੈ ਕਿ AI ਹਰ ਉਮੀਦਸ਼ੁਦਾ ਆਈਟਮ ਨਾਲ ਇੱਕ “ਰਿਸਕ ਚੈੱਕਲਿਸਟ” ਤਿਆਰ ਕਰੇ: ਕੀ ਚੀਜ਼ 2× ਅਧਿਕ ਮੁਸ਼ਕਿਲ ਕਰ ਸਕਦੀ ਹੈ, ਕੀਏਲੇ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਕਿਸ ਲਈ spike ਦੀ ਲੋੜ ਹੈ, ਕੀ ਡਿਜ਼ਾਈਨ ਜਾਂ ਡੇਟਾ ਨਾਲ ਪੁਸ਼ਟੀ ਚਾਹੀਦੀ ਹੈ।
ਆਟੋ-ਤਰਜੀਹ ਆਕਰਸ਼ਕ ਹੈ: ਪ੍ਰਭਾਵ ਮੈਟਰਿਕਸ ਦਿਓ ਅਤੇ ਮਾਡਲ ਨੂੰ ਬੈਕਲੌਗ ਸੋਰਟ ਕਰਨ ਦਿਓ। ਖ਼ਤਰਾ ਇਹ ਹੈ ਕਿ ਇਹ ਸਭ ਤੋਂ ਆਸਾਨ ਮਾਪਦੰਡਾਂ ਲਈ optimize ਕਰਦਾ ਹੈ, ਨਾ ਕਿ ਜੋ ਰਣਨੀਤਿਕ ਤੌਰ 'ਤੇ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ—ਜਿਵੇਂ ਵੱਖਰਾ ਕਰਨ ਵਾਲਾ ਕੰਮ, ਲੰਬੇ ਸਮੇਂ ਦਾ ਪਲੇਟਫਾਰਮ ਕੰਮ, ਜਾਂ ਬ੍ਰਾਂਡ ਵਿਸ਼ਵਾਸ।
ਇਕ ਸਰਲ ਨਿਯਮ ਵਰਤੋ: AI ਸੁਝਾਅ ਦਿਵੇ; ਮਨੁੱਖ ਫੈਸਲਾ ਕਰਦੇ ਅਤੇ ਕਾਰਨ ਦਰਜ ਕਰਦੇ। ਜੇ ਇੱਕ ਆਈਟਮ ਉੱਪਰ ਜਾਂ ਹੇਠਾਂ ਗਿਆ, ਤਿਕਟ ਵਿੱਚ ਰਣਨੀਤੀ ਕਾਰਨ (ਸਟ੍ਰੈਟਜੀ ਸਬੰਧ, ਜੋਖਮ, ਗ੍ਰਾਹਕ ਵਚਨ) ਸਿੱਧਾ ਲਿਖੋ ਤਾਂ ਟੀਮ ਸਿਰਫ਼ ਰੈਂਕ ਆਧਾਰ 'ਤੇ ਨਹੀਂ ਨਿਰਣਾ ਲੈਂਦੀ।
ਜਦੋਂ PMs ਅਤੇ ਇੰਜੀਨੀਅਰ ਇੱਕੋ ਹੀ AI ਟੂਲ ਵਰਤਦੇ ਹਨ, ਉਹ ਨਵੇਂ ਨੁਕਸਾਨੀ ਮੋਡ ਵੀ ਸਾਂਝੇ ਕਰਦੇ ਹਨ। ਸੁਸ਼ਾਸਨ ਟੀਮਾਂ ਨੂੰ ਆਹਸਾਸ ਕਰਾਉਂਦਾ ਹੈ ਕਿ ਕੌਣ ਫੈਸਲਾ ਕਰਦਾ, ਕੌਣ ਚੈੱਕ ਕਰਦਾ, ਅਤੇ ਗਲਤੀ ਹੋਣ 'ਤੇ ਕੀ ਹੁੰਦਾ ਹੈ—ਇਹ ਟੀਮ ਨੂੰ ਧੀਮਾ ਕਰਨ ਲਈ ਨਹੀਂ, ਪਰ ਸਪਸ਼ਟਤਾ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
AI-ਸਹਾਇਤ ਕੰਮ ਉਹ ਤਰੀਕੇ ਨੁਕਸਾਨ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਵਿਖਾਈ ਨਹੀਂ ਦਿੰਦੀਆਂ ਜਦ ਤਕ ਉਨ੍ਹਾਂ ਦੀ ਕੀਮਤ ਮਹਿੰਗੀ ਨਾ ਹੋ ਜਾਏ:
ਵਰਕਫਲੋ ਦਰਜੇ 'ਤੇ ਮਲਕੀਅਤ ਸਪੱਸ਼ਟ ਕਰੋ, ਨਾਂ ਕਿ ਸਿਰਫ਼ ਨੌਕਰੀ ਦੇ ਸਿਰਲੇਖ ਨਾਲ:
ਨਿਯਮ ਛੋਟੇ ਅਤੇ ਲਾਗੂਯੋਗ ਰੱਖੋ:
ਜੇ ਤੁਸੀਂ Koder.ai ਵਰਗਾ ਪਲੇਟਫਾਰਮ ਅਪਣਾਉਂਦੇ ਹੋ, ਇਸਨੂੰ ਆਪਣੇ SDLC ਦਾ ਹਿੱਸਾ ਸਮਝੋ: ਚੇਟ ਤੋਂ ਕੀ ਜਨਰੇਟ ਹੋ ਸਕਦਾ, ਨਿਰਯਾਤ ਨਾਲ ਬਾਅਦ ਵਿੱਚ ਕੋਡ ਰਿਵਿਊ ਕਦੋਂ ਜਰੂਰੀ ਹੈ, ਅਤੇ ਜਦ ਤਕ iterations ਤੇਜ਼ ਹੁੰਦੀਆਂ ਹਨ snapshots/rollback ਕਿਵੇਂ ਵਰਤੇ ਜਾਣ।
AI ਗਲਤੀਆਂ ਨੂੰ ਕਿਸੇ ਹੋਰ ਉਤਪਾਦਕ ਜੋਖਮ ਵਾਂਗੋ ਹੀ ਸਲਝਾਓ:
AI ਸਿਰਫ਼ ਮੌਜੂਦਾ ਕੰਮ ਨੂੰ ਤੇਜ਼ ਨਹੀਂ ਕਰਦਾ—ਇਹ ਨਵੇਂ "ਦਰਮਿਆਨੀ" ਕੰਮ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ PM ਜਾਂ ਇੰਜੀਨੀਅਰ ਦੇ ਦਾਇਰੇ ਵਿੱਚ ਨਹੀਂ ਆਉਂਦੇ। ਜਿਹੜੀਆਂ ਟੀਮਾਂ ਇਹ ਕੰਮ ਪਹਿਲਾਂ ਹੀ ਸਵੀਕਾਰ ਕਰ ਲੈਂਦੀਆਂ ਹਨ ਉਹ ਗਲਤੀ ਅਤੇ ਦੁਹਰਾਅ ਤੋਂ ਬਚ ਜਾਂਦੀਆਂ ਹਨ।
ਕੁਝ ਨਿਗੜੇ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਆ ਰਹੀਆਂ ਹਨ:
ਜਦੋਂ ਇਹ ਕੰਮ “ਹਰ ਕਿਸੇ ਦਾ ਕੰਮ” ਬਣ ਜਾਂਦੇ ਹਨ, ਅਕਸਰ ਉਹ ਕਿਸੇ ਦੇ ਕੰਮ ਨਹੀਂ ਰਹਿੰਦੇ। ਇੱਕ ਮਾਲਕ ਨਿਯੁਕਤ ਕਰੋ, ਅਪਡੇਟ ਕੈਡੈਂਸ ਨਿਰਧਾਰਤ ਕਰੋ, ਅਤੇ ਤੈਆਰ ਕਰੋ ਕਿ ਇਹ ਕਿੱਥੇ ਰਹਿਣਗੇ (ਵਿਕੀ, ਰੇਪੋ, ਜਾਂ ਦੋਹਾਂ)।
ਇਹ ਵੱਡੀਆਂ ਸੰਸਥਾਵਾਂ ਵਿੱਚ ਫ਼ੋਰਮਲ ਭੂਮਿਕਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਾਂ ਛੋਟੀਆਂ ਵਿਚ ਮੌਜੂਦਾ ਮੈਂਬਰਾਂ ਦੀਆਂ ਹੈਟਾਂ।
PMs ਟੈਕਨੀਕੀ ਸਾਖ਼ਤੀ ਤੋਂ ਫਾਇਦਾ ਲੈ ਸਕਦੇ ਹਨ: ਉੱਚ-ਸਤਰ ਤੇ ਡਿਫਜ਼ ਪੜ੍ਹਨਾ, APIs ਨੂੰ سمجھਣਾ, ਅਤੇ ਮੌਲੈਕੂਲਾ ਸ਼ਾਮਿਲ ਕਰਨ ਦੀ ਸਮਝ ਰੱਖਣਾ।
ਇੰਜੀਨੀਅਰ ਪ੍ਰੋਡਕਟ ਸੋਚ ਤੋਂ ਲਾਭਾਨਵਿਤ ਹੁੰਦੇ ਹਨ: ਸਪਸ਼ਟ ਸਮੱਸਿਆ ਫਰੇਮਿੰਗ, ਉਪਭੋਗਤਾ ਪ੍ਰਭਾਵ, ਅਤੇ ਪ੍ਰਯੋਗ ਡਿਜ਼ਾਈਨ—ਸਿਰਫ਼ ਇੰਪਲੀਮੇੰਟੇਸ਼ਨ ਵੇਰਵਿਆਂ ਤੱਕ ਸੀਮਿਤ ਨਹੀਂ।
ਜੋੜੀ ਸੈਸ਼ਨ ਚਲਾਓ (PM + ਇੰਜੀਨੀਅਰ) ਤਾਂ ਜੋ ਪ੍ਰਾਂਪਟ, ਸਪੈੱਕ, ਅਤੇ ਸਵੀਕਾਰਤਾ ਮਾਪਦੰਡ ਇਕੱਠੇ ਬਣਾਏ ਜਾਣ, ਫਿਰ AI ਆਉਟਪੁੱਟ ਨੂੰ ਅਸਲ ਉਦਾਹਰਣਾਂ ਨਾਲ ਤੁਲਨਾ ਕਰੋ। ਜੋ ਚੰਗਾ ਕਾਮ ਕਰ ਗਿਆ ਉਸਨੂੰ ਇੱਕ ਸਾਂਝੇ ਪਲੇਬੁੱਕ (ਟੈਮਪਲੇਟ, ਕਰੋ/ਨਾ ਕਰੋ, ਸਮੀਖਿਆ ਚੈੱਕਲਿਸਟ) ਵਿੱਚ ਕੈਪਚਰ ਕਰੋ ਤਾਂ ਕਿ ਸਿੱਖਿਆ ਟੀਮ ਵਿੱਚ ਕੁਟਿਆ ਹੋ ਜਾਵੇ।
ਥੋੜੀ ਢਾਂਚਾ ਬਹੁਤ ਕੰਮ ਕਰਦਾ ਹੈ। ਮਕਸਦ ਹਰ ਜਗ੍ਹਾ AI ਲਾਉਣਾ ਨਹੀਂ, ਬਲਕਿ ਇੱਕ ਨਿਯੰਤਰਿਤ ਪਾਇਲਟ ਚਲਾਉਣਾ ਜਿੱਥੇ ਭੂਮਿਕਾਵਾਂ ਸਪਸ਼ਟ ਰਹਿੰਦੀਆਂ ਹਨ ਅਤੇ ਟੀਮ ਇਹ ਸਿੱਖਦੀ ਹੈ ਕਿ ਕੀ ਵਾਸਤਵ ਵਿੱਚ ਨਤੀਜੇ ਸੁਧਾਰਦਾ ਹੈ।
ਇੱਕ ਅਸਲੀ ਸਕੋਪ ਵਾਲਾ ਫੀਚਰ ਚੁਣੋ (ਨਾ ਕੋਈ ਛੋਟਾ ਕਾਪੀ ਬਦਲਾਅ, ਨਾ ਕੋਈ ਕਈ-ਕਵਾਰਟਰ ਪਲੇਟਫਾਰਮ ਰਿਵਰਾਈਟ). ਸ਼ੁਰੂ/ਅੰਤ ਬਿੰਦੂ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ: ਪਹਿਲੇ ਵਿਚਾਰ ਡਰਾਫਟ ਤੋਂ ਪ੍ਰੋਡਕਸ਼ਨ ਰਿਲੀਜ਼ ਤੱਕ।
ਪਾਇਲਟ ਲਈ ਇੱਕ-ਸਫ਼ਾ ਭੂਮਿਕਾ ਨਕਸ਼ਾ ਲਿਖੋ: ਕੌਣ ਸਮੱਸਿਆ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ (PM), ਤਕਨੀਕੀ ਰੁਖ ਕੌਣ ਲੈਂਦਾ (engineering), UX ਫੈਸਲੇ ਕੌਣ ਲੈਂਦਾ (design), ਅਤੇ ਕਿਣੀ ਗੁਣਾ (QA) ਕੌਣ ਨਿਰਧਾਰਤ ਕਰਦਾ। ਦਰਸਾਓ ਕਿ ਕੌਣ ਸੁਝਾਅ ਦੇ ਸਕਦਾ ਹੈ ਅਤੇ ਕੌਣ ਫੈਸਲਾ ਕਰਦਾ।
ਸਿਰਫ 2–3 AI ਵਰਤੋਂ-ਮਾਮਲੇ ਚੁਣੋ, ਉਦਾਹਰਨ ਲਈ:
ਇਨਪੁੱਟਸ ਨੂੰ ਇੱਕਸਾਰ ਕਰੋ: ਪ੍ਰਾਂਪਟਾਂ ਲਈ ਇੱਕ ਸਾਂਝਾ ਟੈਮਪਲੇਟ ਅਤੇ AI ਆਉਟਪੁੱਟ ਲਈ ਇੱਕ ਸਾਂਝਾ "ਡਨ" ਪਰਿਭਾਸ਼ਾ (ਕੀ ਚੀਜ਼ ਪੁਸ਼ਟੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਕੀ ਭਰੋਸੇਯੋਗ ਹੈ) ਰੱਖੋ।
2–4 ਸਪ੍ਰਿੰਟ ਲਈ ਚਲਾਓ, ਫਿਰ ਵਧਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਰੁਕ ਕੇ ਸਮੀਖਿਆ ਕਰੋ।
ਜੇ ਤੁਹਾਡੀ ਟੀਮ ਡਰਾਫਟਿੰਗ ਤੋਂ ਅੱਗੇ ਜਾ ਕੇ ਤੇਜ਼ ਇੰਪਲੀਮੇੰਟੇਸ਼ਨ ਦੇ ਪ੍ਰਯੋਗ ਕਰਨਾ ਚਾਹੁੰਦੀ ਹੈ, ਤਾ ਪਾਇਲਟ ਨੂੰ ਇਕ ਨਿਯੰਤਰਿਤ ਬਿਲਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਰੋ (ਉਦਾਹਰਨ ਲਈ, Koder.ai ਦੀ planning mode ਨਾਲ snapshots/rollback)। ਮਕਸਦ ਇੰਜੀਨੀਅਰਿੰਗ ਨੂੰ ਬਾਇਪਾਸ ਕਰਨਾ ਨਹੀਂ—ਇਹ ਦੁਹਰਾਈ ਸਸਤੀ ਬਣਾਉਣਾ ਹੈ ਜਦਕਿ ਸਮੀਖਿਆ ਦਰਵਾਜੇ ਬਰਕਰਾਰ ਰਹਿੰਦੇ ਹਨ।
ਇੱਕ ਬੇਸਲਾਈਨ ਟਰੈਕ ਕਰੋ (ਪਿਛਲੇ ਸਮਾਨ ਫੀਚਰ) ਅਤੇ ਤੁਲਨਾ ਕਰੋ:
ਇੱਕ ਸਾਂਝਾ ਪ੍ਰਾਂਪਟ ਰਿਪੋ (ਵਰਜਨਡ, ਚੰਗੇ/ਖਰਾਬ ਆਉਟਪੁੱਟ ਦੇ ਉਦਾਹਰਣਾਂ ਨਾਲ) ਰੱਖੋ। ਹਫਤਾਵਾਰ 20 ਮਿੰਟ ਸਮੀਖਿਆ ਰੱਖੋ ਜਿੱਥੇ ਟੀਮ AI-ਜਨਰੇਟ ਆਰਟੀਫੈਕਟਾਂ ਨੂੰ ਨਮੂਨੇ ਵਜੋਂ ਵੇਖ ਕੇ ਲੇਬਲ ਕਰੇ: ਸਹੀ, ਭ੍ਰਮਿਤ, ਘਾਟ-ਸੰਦਰਭ, ਜਾਂ ਮਿਹਨਤ ਯੋਗ ਨਹੀਂ।
ਆਖਰੀ ਉਦਦੇਸ਼ ਸਿਧਾਂਤ: ਸਾਂਝੇ ਆਰਟੀਫੈਕਟ, ਸਪਸ਼ਟ ਜ਼ਿੰਮੇਵਾਰੀ, ਦਿੱਖਧਾਰੀ ਫੈਸਲੇ।