30 ਸਤੰ 2025·8 ਮਿੰਟ
Vibe Coding ਦਾ ਭਵਿੱਖ: ਵੱਡਾ ਸੰਦਰਭ, ਸਮਾਰਟ AI ਟੂਲ
ਦੇਖੋ ਕਿ ਜਿਵੇਂ AI ਮਾਡਲ ਸੁਧਰਦੇ, ਸੰਦਰਭ ਵਧਦੇ ਅਤੇ ਟੂਲ ਮਾਹੌਲੀ ਹੁੰਦੇ ਜਾਂਦੇ ਹਨ, vibe coding ਕਿਵੇਂ ਵਿਕਸਤ ਹੋ ਸਕਦਾ ਹੈ—ਤੇ ਟੀਮਾਂ ਨੂੰ ਕਿਸ ਕਾਬਲੀਅਤ, ਜੋਖਮ ਅਤੇ ਵਰਕਫਲੋ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।
ਦੇਖੋ ਕਿ ਜਿਵੇਂ AI ਮਾਡਲ ਸੁਧਰਦੇ, ਸੰਦਰਭ ਵਧਦੇ ਅਤੇ ਟੂਲ ਮਾਹੌਲੀ ਹੁੰਦੇ ਜਾਂਦੇ ਹਨ, vibe coding ਕਿਵੇਂ ਵਿਕਸਤ ਹੋ ਸਕਦਾ ਹੈ—ਤੇ ਟੀਮਾਂ ਨੂੰ ਕਿਸ ਕਾਬਲੀਅਤ, ਜੋਖਮ ਅਤੇ ਵਰਕਫਲੋ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।
“Vibe coding” ਇੱਕ ਐਸਾ ਤਰੀਕਾ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਪਹਿਲਾਂ ਇਰਾਦਾ ਰੱਖਦੇ ਹੋ—ਕਿ ਪ੍ਰੋਗਰਾਮ ਕਿਸ ਤਰ੍ਹਾਂ ਵਰਤੋਂਕਾਰ ਲਈ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ—ਅਤੇ AI ਤੁਹਾਡੀ ਮਦਦ ਕਰਦਾ ਹੈ ਉਹ ਇਰਾਦਾ ਕੰਮ ਕਰਨ ਵਾਲੇ ਕੋਡ ਵਿੱਚ ਬਦਲਨ ਲਈ। ਹਰ ਲਾਈਨ ਖੁਦ ਨਾ ਲਿਖਦੇ ਹੋ; ਤੁਸੀਂ ਦਿਸ਼ਾ ਦਿੰਦੇ ਹੋ: ਵਰਣਨ ਕਰਦੇ ਹੋ, ਪਾਬੰਦੀਆਂ ਅਤੇ ਉਦਾਹਰਨ ਦਿੰਦੇ ਹੋ, ਫਿਰ ਟੂਲ ਦੀ ਬਣਾਈ ਹੋਈ ਚੀਜ਼ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋ, ਸੋਧ ਕਰਦੇ ਹੋ, ਅਤੇ ਦੁਹਰਾਉਂਦੇ ਹੋ।
ਮੁੱਖ ਖਿਆਲ ਇਹ ਹੈ ਕਿ ਕੰਮ ਦੀ ਇਕਾਈ "ਕੋਡ ਟਾਈਪ ਕਰੋ" ਤੋਂ ਬਦਲ ਕੇ "ਦਿਸ਼ਾ ਦਿਓ ਅਤੇ ਵੈਰੀਫਾਈ ਕਰੋ" ਹੋ ਜਾਂਦੀ ਹੈ। ਨਤੀਜੇ ਲਈ ਤੁਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਰਹਿੰਦੇ ਹੋ, ਪਰ ਹੁਣ ਤੁਸੀਂ ਵੱਧ ਸਮਾਂ ਮੰਗ-ਮਰਦ, ਟਰੇਡ‑ਆਫ਼ ਚੁਣਨ ਅਤੇ ਨਤੀਜੇ ਜਾਂਚਣ ਵਿੱਚ ਵਿਤਾਉਂਦੇ ਹੋ।
Vibe coding ਦਾ ਮਤਲਬ ਹੈ:
ਇਹ ਕੇਵਲ autocomplete ਨਹੀਂ ਹੈ। Autocomplete ਨਜ਼ਦੀਕੀ ਸੰਦਰਭ ਤੇ ਅਗਲੇ ਕੁਝ ਟੋਕਨ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ; vibe coding ਦਾ ਮਕਸਦ ਤੁਹਾਡੇ ਦੱਸੇ ਇਰਾਦੇ ਦੇ ਆਧਾਰ 'ਤੇ ਵੱਡੇ ਹਿੱਸੇ ਬਣਾਉਣਾ ਜਾਂ ਤਬਦੀਲ ਕਰਨਾ ਹੈ।
ਇਹ templates ਨਹੀਂ ਹਨ। Templates ਜਾਣੀ-ਪਛਾਣ ਪੈਟਰਨ ਨੂੰ ਲਾਉਂਦੇ ਹਨ; vibe coding ਪੈਟਰਨ ਨੂੰ ਨਵੀਂ ਸਥਿਤੀ ਲਈ ਅਨੁਕੂਲ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਫੈਸਲਿਆਂ ਨੂੰ ਸਮਝਾ ਸਕਦਾ ਹੈ (ਹਾਲਾਂਕਿ ਤੁਹਾਨੂੰ ਫਿਰ ਵੀ ਵੈਰੀਫਾਈ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ)।
ਇਹ no-code ਨਹੀਂ ਹੈ। No-code ਟੂਲ UI ਬਿਲਡਰਾਂ ਪਿੱਛੇ ਕੋਡ ਨੂੰ ਛੁਪਾਉਂਦੇ ਹਨ। Vibe coding ਫਿਰ ਵੀ ਕੋਡ ਪੈਦਾ ਅਤੇ ਸੋਧਦਾ ਹੈ—ਅਕਸਰ ਤੇਜ਼ੀ ਨਾਲ—ਪਰ ਤੁਸੀਂ ਕੋਡਬੇਸ ਵਿੱਚ ਰਹਿੰਦੇ ਹੋ।
ਇਹ ਪ੍ਰੋਟੋਟਾਈਪ, “ਗਲੂ ਕੋਡ” (APIs, ਡੇਟਾ ਫਾਰਮੈਟ, ਸਰਵਿਸز ਨੂੰ ਜੋੜਨਾ), ਅਤੇ ਰਿਫੈਕਟਰ ਜਿਵੇਂ ਨਾਂ‑ਬਦਲੋ, ਮੋਡਿਊਲਾਂ ਨੂੰ ਦੁਬਾਰਾ ਸੰਗਠਿਤ ਕਰਨਾ ਜਾਂ ਇੱਕ ਲਾਇਬਰੇਰੀ ਤੋਂ ਦੂਜੇ 'ਤੇ ਮਾਈਗਰੇਟ ਕਰਨਾ ਵਿੱਚ ਚਮਕਦਾ ਹੈ। ਇਹ ਟੈਸਟ, ਡੌਕਸ, ਅਤੇ ਛੋਟੇ ਯੂਟਿਲਿਟੀ ਲਿਖਣ ਲਈ ਵੀ ਲਾਭਦਾਇਕ ਹੈ—ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਤੁਸੀਂ ਇਨਪੁੱਟ ਤੇ ਉਮੀਦ ਕੀਤੀ ਆਉਟਪੁੱਟ ਦੀਆਂ ਉਦਾਹਰਨ ਦੇ ਸਕਦੇ ਹੋ।
ਇਹ ਗਹਿਰੇ, ਬਹੁ‑ਕਦਮੀ ਬੱਗਾਂ 'ਤੇ ਕਮਜ਼ੋਰ ਹੈ ਜਿੱਥੇ ਅਸਲ ਕਾਰਨ ਸਿਸਟਮ ਵਿਹਾਰ, ਟਾਇਮਿੰਗ ਜਾਂ ਗੁੰਮ ਡੋਮੇਨ ਗਿਆਨ ਵਿੱਚ ਛੁਪਿਆ ਹੋਵੈ। ਜਦੋਂ ਲੋੜਾਂ ਅਸਪੱਸ਼ਟ ਜਾਂ ਭਿੰਨ‑ਭਿੰਨ ਹੁੰਦੀਆਂ ਹਨ—ਜੇ ਤੁਸੀਂ ਇਹ ਨਾ ਦੱਸ ਸਕੋ ਕਿ "ਸਹੀ" ਕੀ ਹੈ—ਤਾਂ ਟੂਲ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਉਸਨੂੰ ਪੈਦਾ ਨਹੀਂ ਕਰ ਸਕਦਾ।
ਇਹਨਾਂ ਪਲਾਂ ਵਿੱਚ ਕੰਮ "ਕੋਡ ਜਨਰੇਟ ਕਰੋ" ਤੋਂ ਬਦਲ ਕੇ "ਇਰਾਦਾ ਸਾਫ ਕਰੋ" ਬਣ ਜਾਂਦਾ ਹੈ, ਜਿਥੇ AI ਸਮਰਥਨ ਕਰਦਾ ਹੈ—ਪਰ ਸੋਚ ਨੂੰ ਬਦਲ ਨਹੀਂ ਕਰਦਾ।
Vibe coding ਇਸ ਲਈ ਲੋਕਪ੍ਰਿਯ ਹੋ ਰਿਹਾ ਹੈ ਕਿਉਂਕਿ "ਇੱਕ ਵਿਚਾਰ ਖ਼ਤਮ ਕਰਕੇ ਦੇਖਣ" ਦੀ ਲਾਗਤ ਬਹੁਤ ਘੱਟ ਹੋ ਗਈ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਬਦਲਾਅ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਸਕਿੰਟਾਂ ਵਿੱਚ ਵਰਕਿੰਗ ਡਰਾਫਟ ਮਿਲਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਤੁਰੰਤ ਟੈਸਟ ਕਰ ਸਕਦੇ ਹੋ, ਤਾਂ ਪ੍ਰਯੋਗ ਰਾਹ ਨਹੀਂ ਬਣਦਾ—ਸਹਜ ਰੁਟੀਨ ਬਣ ਜਾਂਦੀ ਹੈ।
ਦੈਨਿਕ ਵਿਕਾਸ ਦਾ ਕਈ ਸਮਾਂ ਉਦੇਸ਼ ਨੂੰ ਸਿੰਟੈਕਸ, ਵਾਇਰਿੰਗ, ਅਤੇ ਬੋਇਲਰਪਲੇਟ ਵਿੱਚ ਬਦਲਣ ਤੇ ਲੰਘਦਾ ਹੈ—ਫਿਰ ਦੇਖਣਾ ਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ। AI-ਸਹਾਇਤ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਇਹ ਚੱਕਰ ਸੰਘਣੇ ਲੂਪ ਵਿੱਚ ਸੰਕੁਚਿਤ ਕਰਦੀ ਹੈ:
ਇਹ ਗਤੀ ਸਭ ਤੋਂ ਵੱਧ ਗੁਣਕਾਰੀ ਕੰਮਾਂ ਲਈ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ: ਨਵਾਂ ਐਂਡਪੋਇੰਟ ਜੋੜਨਾ, ਕੰਪੋਨੈਂਟ ਰਿਫੈਕਟਰ, ਵੈਲਿਡੇਸ਼ਨ ਅਪਡੇਟ ਕਰਨਾ, ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਿਖਣਾ, ਜਾਂ ਇੱਕ ਤੇਜ਼ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣਾ। ਇਹ ਉਹ ਕੰਮ ਹਨ ਜੋ "ਭਾਰੀ ਯੋਜਨਾ ਲਈ ਛੋਟੇ" ਹੁੰਦੇ ਹਨ, ਪਰ ਇਕੱਠੇ ਵੱਡੇ ਅਸਰ ਪਾਉਂਦੇ ਹਨ।
ਟੀਮਾਂ ਨਤੀਜੇ ਭੇਜਣ ਦੇ ਦਬਾਅ ਵਿੱਚ ਹਨ, ਕੇਵਲ ਆਉਟਪੁੱਟ ਨਹੀਂ। ਜਦੋਂ AI ਤੇਜ਼ੀ ਨਾਲ ਕੋਡ ਡਰਾਫਟ ਕਰ ਸਕਦਾ ਹੈ, ਤਵੱਜੋ ਉਤਪਾਦਕ ਇਰਾਦੇ ਨੂੰ ਸਾਫ ਕਰਨ ਵੱਲ ਵੱਧਦੀ ਹੈ: ਉਪਭੋਗੀ ਲਈ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਕਿਹੜੇ ਟਰੇਡ‑ਆਫ ਠੀਕ ਹਨ, ਅਤੇ ਸਿਸਟਮ ਅਸਲ ਦੁਨੀਆ ਹਾਲਾਤਾਂ ਵਿੱਚ ਕਿਵੇਂ ਵਰਤਵੇ।
ਇਹ ਖਾਸ ਕਰਕੇ ਪ੍ਰਾਰੰਭਿਕ ਪ੍ਰੋਜੈਕਟਾਂ, ਅੰਦਰੂਨੀ ਟੂਲਾਂ, ਅਤੇ ਵੇਹਲੇ ਉਤਪਾਦ ਕੰਮਾਂ ਵਿੱਚ ਨਜ਼ਰ ਆਉਂਦਾ ਹੈ ਜਿੱਥੇ ਲੋੜਾਂ ਹਫ਼ਤੇ-ਹਫ਼ਤੇ ਬਦਲਦੀਆਂ ਹਨ।
ਵੱਡਾ ਬਦਲਾਅ ਸਿਰਫ ਮਾਡਲ ਗੁਣਵੱਤਾ ਨਹੀਂ—ਇਸਦੀ ਇਕੀਕਰਨ ਹੈ। ਮਦਦ ਹੁਣ ਉਹਨਾਂ ਥਾਵਾਂ 'ਤੇ ਉਪਲਬਧ ਹੋ ਰਹੀ ਹੈ ਜਿੱਥੇ ਫੈਸਲੇ ਹੁੰਦੇ ਹਨ: ਏਡੀਟਰ, ਕੋਡ ਰिवਿਊ, ਟੈਸਟ ਅਤੇ ਡੀਬੱਗਿੰਗ ਵਿੱਚ। ਇਹ "ਕੰਟੈਕਸਟ-ਸਵਿੱਚਿੰਗ ਟੈਕਸ" ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਜੋ ਟੂਲਾਂ ਵਿੱਚ ਟੁਕੜਿਆਂ ਨੂੰ ਕਾਪੀ‑ਪੇਸਟ ਕਰਨ ਨਾਲ ਹੁੰਦਾ ਸੀ।
ਜਿਵੇਂ ਜਨਰੇਸ਼ਨ ਸਸਤੀ ਹੁੰਦੀ ਜਾ ਰਹੀ ਹੈ, ਵਰਿਫਿਕੇਸ਼ਨ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦੀ ਹੈ। ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਲਾਭ ਵਾਲੀਆਂ ਟੀਮਾਂ AI ਨਤੀਜੇ ਨੂੰ ਇੱਕ ਡਰਾਫਟ ਮੰਨਦੀਆਂ ਹਨ—ਫਿਰ ਟੈਸਟ, ਧਿਆਨਪੂਰਵਕ ਸਮੀਖਿਆ, ਅਤੇ "ਕਿੱਧੇ ਹੋਣਾ" ਦੀ ਸਪੱਸ਼ਟ ਪਰਿਭਾਸ਼ਾ ਨਾਲ ਵੈਲਿਡੇਟ ਕਰਦੀਆਂ ਹਨ।
ਸ਼ੁਰੂਆਤੀ AI ਕੋਡਿੰਗ ਟੂਲ ਆਮ ਤੌਰ 'ਤੇ autocomplete ਵਾਂਗ ਕੰਮ ਕਰਦੇ ਸਨ: ਉਹ ਤੁਹਾਨੂੰ ਤੇਜ਼ ਟਾਈਪ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਸਨ, ਪਰ ਤੁਸੀਂ ਅਜੇ ਵੀ "ਡਰਾਈਵ" ਕਰਦੇ ਸੀ। ਜਿਵੇਂ-जਿਵੇਂ ਮਾਡਲ ਬਿਹਤਰ ਹੋ ਰਹੇ ਹਨ, ਉਹ ਸੁਝਾਅ ਡੱਬੇ ਵਾਂਗ ਨਹੀਂ ਰਹਿੰਦੇ—ਉਹ ਇੱਕ ਸਾਥੀ ਵਾਂਗ ਕੰਮ ਕਰਨ ਲੱਗਦੇ ਹਨ ਜੋ ਇਰਾਦੇ ਤੋਂ ਲੈ ਕੇ ਲਾਗੂ ਕਰਨ ਤਕ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ।
ਨਵੇਂ ਮਾਡਲ ਬਹੁ-ਕਦਮੀ ਕੰਮਾਂ ਨੂੰ ਸੰਭਾਲਣ ਵਿੱਚ ਕਾਬਿਲ ਹੋ ਰਹੇ ਹਨ: ਤਬਦੀਲੀਆਂ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣਾ, ਕਈ ਸਬੰਧਤ ਸੋਧਾਂ ਕਰਨਾ, ਅਤੇ ਹਰ ਕਦਮ ਦਾ ਕਾਰਨ ਯਾਦ ਰੱਖਣਾ।
ਅਮਲੀ ਤੌਰ ਤੇ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਨਤੀਜੇ ਮੰਗ ਸਕਦੇ ਹੋ ("ਇੱਕ ਬਿਲਿੰਗ ਟਿਅਰ ਜੋੜੋ ਅਤੇ ਚੈਕਆਊਟ ਫਲੋ ਅਪਡੇਟ ਕਰੋ") ਬਜਾਏ ਹਰ ਲਾਈਨ ਨੂੰ ਨਿਰਦੇਸ਼ ਦੇਣ ਦੇ। ਮਾਡਲ ਇੱਕ ਕ੍ਰਮ ਸੁਝਾ ਸਕਦਾ ਹੈ: ਡੇਟਾ ਸਟਰੱਕਚਰ ਅਪਡੇਟ ਕਰੋ, UI ਸਮਾਂਜਸ ਕਰੋ, ਵੈਲਿਡੇਸ਼ਨ ਬਦਲੋ, ਅਤੇ ਟੈਸਟ ਜੋੜੋ।
ਸੀਮਾ ਇਹ ਹੈ ਕਿ "ਬਿਹਤਰ" ਦਾ ਮਤਲਬ "ਬੇਹਦ" ਨਹੀਂ। ਲੰਬੇ ਨਿਰਭਰ ਫੈਸਲਿਆਂ ਦੀ ਲੜੀ ਅਜੇ ਵੀ ਟੁੱਟ ਜਾਂਦੀ ਹੈ ਜੇ ਲੋੜਾਂ ਅਸਪਸ਼ਟ ਹੋਣ ਜਾਂ ਕੋਡਬੇਸ ਵਿੱਚ ਲੁਕੀਆਂ ਪਾਬੰਦੀਆਂ ਹੋਣ। ਤੁਸੀਂ ਸੁਧਾਰ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਉਹਨਾਂ ਟਾਸਕਾਂ 'ਤੇ ਮਹਿਸੂਸ ਕਰੋਗੇ ਜਿਨ੍ਹਾਂ ਦੇ ਲਕੜੀ-ਮਕਸਦ ਅਤੇ ਪਰਿਭਾਸ਼ਤ ਇੰਟਰਫੇਸ ਹਨ।
ਮਾਡਲ ਉਹਨਾਂ ਹਾਲਾਤਾਂ ਵਿੱਚ ਸਭ ਤੋਂ ਚੰਗਾ ਕੰਮ ਕਰਦੇ ਹਨ ਜਦੋਂ ਤੁਸੀਂ ਠੋਸ ਪਾਬੰਦੀਆਂ ਦਿੰਦੇ ਹੋ: ਇਨਪੁੱਟ/ਆਉਟਪੁੱਟ, ਐਕਸੈਪਟੈਂਸ ਮਾਪਦੰਡ, ਏਜ‑ਕੇਸ ਅਤੇ ਨਾ‑ਲੱਖੇ. ਜਦੋਂ ਤੁਸੀਂ ਇਹ ਕਰਦੇ ਹੋ, ਕੋਡ ਜਨਰੇਸ਼ਨ ਜ਼ਿਆਦਾ ਮਿਆਰੀ ਹੋ ਜਾਂਦਾ ਹੈ—ਘੱਟ ਕਮੀ, ਘੱਟ ਨਾਮਾਂ ਦੀ ਗਲਤ ਮੈਚਿੰਗ, ਘੱਟ ਇਨਵੇਂਟ ਕੀਤੇ ਹੋਏ APIs।
ਇੱਕ ਉਪਯੋਗੀ ਮਾਨਸਿਕ ਮਾਡਲ: ਮਾਡਲ ਇੱਕ ਸਪੈਕ ਚੱਲਾਉਣ ਵਿੱਚ ਮਹਾਨ ਹੈ, ਪਰ ਇੱਕ ਸਪੈਕ ਅਨੁਮਾਨ ਲਾਉਣ ਵਿੱਚ ਠੀਕ ਨਹੀਂ।
ਇੱਕ ਵੱਡਾ ਬਦਲਾਅ ਇਹ ਹੈ ਕਿ ਨਵੀਂ ਫਾਇਲ ਬਣਾਉਣ ਤੋਂ ਬਦਲ ਕੇ "ਮੌਜੂਦਾ ਮੌਜੂਦ ਕੋਡ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸੋਧਣਾ" ਹੋ ਰਿਹਾ ਹੈ। ਸੁਧਾਰਤ ਮਾਡਲ ਇਸ ਵਿੱਚ ਵਧੀਆ ਹਨ:
ਇੱਥੇ ਤਜਰਬਾ ਉਸ ਤਰ੍ਹਾਂ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਤੁਸੀਂ ਫੈਸਲੇ ਸੌਂਪ ਰਹੇ ਹੋ ਨਾ ਕਿ ਸਿਰਫ ਸੁਝਾਅ ਲੈ ਰਹੇ ਹੋ: ਤੁਸੀਂ ਇੱਕ ਬਦਲਾਅ ਮੰਗਦੇ ਹੋ, ਅਤੇ ਟੂਲ ਪ੍ਰੋਜੈਕਟ ਦੀ ਸ਼ੈਲੀ ਨਾਲ ਮਿਲਦੇ ਹੋਏ ਸੰਕਲਪ ਉਤਪन्न ਕਰਨ ਲਈ ਇੱਕ ਢੰਗ ਦੇ ਢਿਫ਼ ਰਿਟਰਨ ਕਰਦਾ ਹੈ।
ਭਾਵੇਂ ਮਾਡਲ ਹੋਸ਼ਿਆਰ ਹੋਣ, ਇੱਕ ਮੁੱਖ ਜੋਖਮ ਰਹਿੰਦਾ ਹੈ: ਉਹ ਪੱਕਾ ਲੱਗ ਸਕਦੇ ਹਨ ਜਦੋਂ ਕਿ ਉਹ ਗਲਤ ਹੋਣ। ਫੇਲ੍ਯੋਗ ਮੋਡ ਹੁਣ ਨਰਮ ਹੋ ਜਾਂਦਾ ਹੈ—ਘੱਟ ਸਪੱਸ਼ਟ ਸਿੰਟੈਕਸ ਤ੍ਰੁੱਟੀਆਂ, ਪਰ ਵਰਤਣਯੋਗ ਲੱਗਣ ਵਾਲੀਆਂ ਭੁੱਲਾਂ ਜਿਹੜੀਆਂ ਨਿਯਮਾਂ ਦੀ ਉਲੰਘਣਾ ਕਰਦੀਆਂ ਹਨ।
ਇਸ ਲਈ ਮਨੁੱਖੀ ਭੂਮਿਕਾ ਟਾਈਪ ਕਰਨ ਤੋਂ ਵੈਰੀਫਾਈ ਕਰਨ ਵੱਲ ਬਦਲਦੀ ਹੈ। ਤੁਸੀਂ ਹੁਣ ਪੁੱਛੋਗੇ, "ਕੀ ਇਹ ਕਿਰਿਆ ਸਹੀ ਹੈ?" ਅਤੇ "ਕੀ ਇਹ ਸਾਡੇ ਸੁਰੱਖਿਆ ਅਤੇ ਕਾਰੋਬਾਰੀ ਬੰਧਨਾਂ ਦਾ ਆਦਰ ਕਰਦੀ ਹੈ?"
ਉਪਕਾਰ ਤੇਜ਼ੀ ਹੈ। ਕੀਮਤ ਨਵਾਂ ਤਰ੍ਹਾਂ ਦਾ ਚੌਕਸ ਰਹਿਣਾ ਹੈ: AI ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਮਜ਼ਬੂਤ ਪਹਿਲਾ ਡਰਾਫਟ ਮੰਨੋ ਜੋ ਫਿਰ ਵੀ ਸਮੀਖਿਆ, ਟੈਸਟ ਅਤੇ ਸਪੱਸ਼ਟ ਐਕਸੈਪਟੈਂਸ ਚੈੱਕ ਜ਼ਰੂਰੀ ਹੈ ਤਾਂ ਕਿ ਇਹ "ਕਰਿਆਤਮਕ" ਮੰਨੀ ਜਾਵੇ।
"ਸੰਦਰਭ ਵਿਂਡੋ" ਸਿੱਧਾ ਅਰਥ ਹੈ ਕਿ AI ਮਾਡਲ ਕੋਡ ਲਿਖਦੇ ਜਾਂ ਸੋਧਦੇ ਸਮੇਂ ਕਿੰਨੀ ਜਾਣਕਾਰੀ ਆਪਣੀ ਵਰਕਿੰਗ ਮੈਮੋਰੀ ਵਿੱਚ ਰੱਖ ਸਕਦਾ ਹੈ। ਇਕ ਸਧਾਰਣ ਤੁਲਨਾ: ਕਿਸੇ ٹھੇਕਦਾਰ ਨੂੰ ਆਪਣੇ ਘਰ ਦੀ ਰੀਨੋਵੇਸ਼ਨ ਕਰਵਾਉਣ ਦੀ ਬੇਨਤ ਕਰੋ। ਇੱਕ ਛੋਟੀ ਵਿਂਡੋ ਹੋਣ 'ਤੇ ਉਹ ਸਿਰਫ ਇੱਕ ਕਮਰਾ ਵੇਖ ਸਕਦਾ—ਉਹ ਸ਼ਾਇਦ ਸੁੰਦਰ ਪੇਂਟ ਕਰੇ, ਪਰ ਅਗਲੇ ਕਮਰੇ ਨਾਲ ਜੋੜੇ ਦਰਵੇਜ਼ ਨੂੰ ਰੋਕ ਦੇਵੇ। ਵੱਡੀ ਵਿਂਡੋ ਹੋਣ 'ਤੇ ਉਹ ਸਾਰੇ ਘਰ ਵਿਚੋਂ ਹੋ ਕੇ ਸਮਝ ਸਕਦਾ ਹੈ ਕਿ ਰਸੋਈ ਵਿੱਚ ਬਦਲਾਅ ਬੇਹਤਰ ਤੌਰ 'ਤੇ ਬਾਝੀਰ ਦੀ ਪਲੰਬਿੰਗ 'ਤੇ ਕਿਸ ਪ੍ਰਭਾਵ ਪਾਏਗਾ।
ਜਦੋਂ AI ਇੱਕ ਵਾਰੀ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਦਾ ਹੋਰ ਜਿਆਦਾ ਹਿੱਸਾ "ਦੇਖ" ਸਕਦਾ ਹੈ—ਕੋਰ ਮੋਡੀਊਲ, ਸਾਂਝੇ ਯੂਟਿਲਿਟੀ, API ਉਪਕਰਮ, ਟੈਸਟ ਅਤੇ ਡੌਕਸ—ਤਾਂ ਇਹ ਸੋਧਾਂ ਨੂੰ ਕੋਡਬੇਸ ਭਰ ਵਿੱਚ ਇਕਸਾਰ ਕਰ ਸਕਦਾ ਹੈ ਨਾ ਕਿ ਵਿਛੜੇ ਫਿਕਸ ਬਣਾਉਣ।
ਇਹ ਅਮਲੀ ਤਰੀਕੇ ਨਾਲ ਦਿੱਸਦਾ ਹੈ:
ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਵੱਡੀ ਸੰਦਰਭ ਵਿਂਡੋ AI ਮਦਦ ਨੂੰ "ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਲਿਖਉ" ਤੋਂ "ਇਸ ਸਿਸਟਮ ਨੂੰ ਬਦਲਣ ਵਿੱਚ ਮਦਦ ਕਰੋ ਬਿਨਾਂ ਤੋੜਨ ਦੇ" ਵੱਲ ਧਕੇਲਦੀ ਹੈ।
ਭਾਵੇਂ ਮਾਡਲ ਪੂਰਾ ਰਿਪੋ ਇਕੱਠਾ ਕਰ ਸਕਣ, ਉਹ ਅਜੇ ਵੀ ਆਪਣੇ ਆਪ ਇਹ ਨਹੀਂ ਜਾਣਦੇ ਜੋ ਲਿਖਿਆ ਹੀ ਨਹੀਂ ਗਿਆ।
ਇਸ ਲਈ "ਪੂਰੇ ਕੋਡਬੇਸ ਦੀ ਸਮਝ" ਦਾ ਮਤਲਬ ਨਹੀਂ ਕਿ ਮਾਡਲ "ਪੂਰੇ ਪ੍ਰੋਡਕਟ ਦੀ ਸਮਝ" ਰੱਖ ਲੈਗਾ। ਟੀਮਾਂ ਨੂੰ ਅਜੇ ਵੀ ਉਹ ਮਨੁੱਖੀ ਸੰਦਰਭ ਦਿੰਦੇ ਰਹਿਣਾ ਪਏਗਾ ਜੋ ਕੋਡ ਵਿੱਚ ਦਰਜ ਨਹੀਂ ਹੈ।
ਜਿਵੇਂ ਸੰਦਰਭ ਵਿੰਡੋ ਵੱਡੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਬੋਤਲਨੈਕ ਟੋਕਨ ਸੀਮਾ ਤੋਂ ਘੱਟ ਹੁੰਦਾ ਹੈ ਤੇ ਸਿਗਨਲ ਗੁਣਵੱਤਾ ਬਣ ਜਾਂਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਗੁੰਝਲਦਾਰ, ਵਿਰੋਧੀ ਫਾਇਲਾਂ ਦਾ ਢੇਰ ਪੇਸ਼ ਕਰੋਂਗੇ, ਤਾਂ ਨਤੀਜੇ ਵੀ ਗੁੰਝਲਦਾਰ ਆਉਣਗੇ।
ਜਿਹੜੀਆਂ ਟੀਮਾਂ ਸਭ ਤੋਂ ਵਧੀਆ ਫਾਇਦਾ ਲੈਂਦੀਆਂ ਹਨ ਉਹ ਸੰਦਰਭ ਨੂੰ ਇੱਕ ਸਮਪਤੀ ਵਾਂਗ ਦੇਖਦੀਆਂ ਹਨ:
ਭਵਿੱਖ ਸਿਰਫ ਵੱਡਾ ਸੰਦਰਭ ਨਹੀਂ—ਇਹ ਬਿਹਤਰ ਸੰਦਰਭ ਹੈ, ਉਸ ਤਰ੍ਹਾਂ ਪੈਕੇਜ ਕੀਤਾ ਗਿਆ ਜੋ AI ਉਸੇ ਸੱਚੇ ਸੂਤਰ ਨੂੰ ਦੇਖੇ ਜਿਸ 'ਤੇ ਤੁਹਾਡੇ ਸਿਰੇ ਡਿਵੈਲਪਰ ਭਰੋਸਾ ਕਰਦੇ ਹਨ।
ਸਭ ਤੋਂ ਵੱਡਾ ਬਦਲਾਅ "ਚੈਟ ਟੈਬ ਬਿਹਤਰ ਹੋਣਾ" ਹੀ ਨਹੀਂ ਹੋਵੇਗਾ। ਇਹ AI ਸਹਾਇਤਾ ਉਹਨਾਂ ਥਾਵਾਂ 'ਤੇ ਜੁੜੇਗੀ ਜਿਥੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੰਮ ਕਰਦੇ ਹੋ: ਏਡੀਟਰ, ਟਰਮੀਨਲ, ਬਰਾਊਜ਼ਰ, ਅਤੇ ਤੁਹਾਡੇ ਪਲ-ਰਿਕਵੈੱਸਟਾਂ ਵਿੱਚ। ਨਤੀਜੇ ਨੂੰ ਕਾਪੀ‑ਪੇਸਟ ਕਰਨ ਦੀ ਥਾਂ, ਸੁਝਾਅ ਓਥੇ ਹੀ ਉਤਰੇਗਾ ਜਿੱਥੇ ਫੈਸਲਾ ਹੋ ਰਿਹਾ ਹੈ।
ਮਨ ਕਰੋ AI ਤੁਹਾਡੇ ਸਾਰੇ ਚੱਕਰ 'ਤੇ ਤੁਹਾਡੇ ਨਾਲ ਚੱਲੇਗਾ:
ਮਾਹੌਲੀ ਟੂਲ ਵੱਧ ਤੋਂ ਵੱਧ ਤੁਹਾਡੇ ਲਈ ਸਹੀ ਫਾਇਲਾਂ, ਕਨਫਿਗ, ਟੈਸਟ, ADRs, ਅਤੇ ਪਿਛਲੇ PR ਚਰਚਿਆਂ ਨੂੰ ਖੋਜ ਲੈਣਗੇ। ਕਦੇ ਵੀ "ਇੱਥੇ ਜਵਾਬ" ਦੇਣ ਦੀ ਥਾਂ, ਡਿਫੌਲਟ ਹੋਵੇਗਾ "ਇੱਥੇ ਸਬੂਤ ਹੈ"—ਉਹ ਸਹੀ ਕੋਡ ਰੈਫਰੈਂਸ ਅਤੇ ਪਿਛਲੇ ਫੈਸਲਿਆਂ ਦੀ ਸੂਚੀ ਜਿਨ੍ਹਾਂ 'ਤੇ ਸੁਝਾਅ ਆਧਾਰਿਤ ਹੈ।
ਇਹ ਰੀਟਰੀਵਲ ਲੇਅਰ ਹੀ ਹੈ ਜੋ ਸਹਾਇਤਾ ਨੂੰ "ਨਜ਼ਰਅੰਦਾਜ਼ੀਯੋਗ" ਮਹਿਸੂਸ ਕਰਵਾਉਂਦਾ: ਤੁਸੀਂ ਸੰਦਰਭ ਲਈ ਪੁੱਛਦੇ ਨਹੀਂ; ਇਹ ਨਤੀਜੇ ਨਾਲ ਨਾਲ ਆ ਜਾਂਦਾ ਹੈ।
ਸਭ ਤੋਂ ਵਧੀਆ ਮਦਦ ਸ਼ਾਂਤ ਅਤੇ ਨਿਰਧਾਰਤ ਹੁੰਦੀ ਹੈ:
ਮਾਹੌਲੀ ਸਹਾਇਤਾ ਸ਼ੋਰ ਵਿੱਚ ਬਦਲ ਸਕਦੀ ਹੈ—ਪੋਪਅੱਪ, ਆਟੋ‑ਐਡੀਟ ਅਤੇ ਮੁਕਾਬਲੇਦਾਰ ਸੁਝਾਅ ਜੋ ਫੋਕਸ ਭੰਗ ਕਰਦੇ ਹਨ। ਟੀਮਾਂ ਨੂੰ ਚੰਗੇ ਕੰਟਰੋਲਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ: ਸਮਝਣਯੋਗ "ਸ਼ਾਂਤ ਮੋਡ", ਸਪੱਸ਼ਟ ਭਰੋਸਾ ਸਿਗਨਲ, ਅਤੇ ਨੀਤੀਆਂ ਕਿ ਕਦੋਂ ਆਟੋ‑ਚੇਂਜ ਆਟੋਮੈਟਿਕ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਕਦੋਂ ਟੂਲ ਨੂੰ ਪਹਿਲਾਂ ਪੁੱਛਣਾ ਚਾਹੀਦਾ ਹੈ।
Vibe coding ਕੰਮ ਦਾ ਕੇਂਦਰ "ਕੋਡ ਲਿਖੋ, ਫਿਰ ਸਮਝਾਓ" ਤੋਂ "ਇਰਾਦਾ ਦੱਸੋ, ਫਿਰ ਨਤੀਜਾ ਢਾਲੋ" ਵੱਲ ਸਟੇਪ ਕਰਦਾ ਹੈ। ਕੀਬੋਰਡ ਗੁੰਮ ਨਹੀਂ ਹੋ ਜਾਂਦਾ—ਪਰ ਤੁਹਾਡੇ ਵੱਡੇ ਹਿੱਸੇ ਦਾ ਸਮਾਂ ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਨ, ਨਤੀਜੇ ਦੀ ਜਾਂਚ ਕਰਨ, ਅਤੇ ਸਪੱਸ਼ਟ ਫੀਡਬੈਕ ਨਾਲ ਟੂਲ ਨੂੰ ਸਟੇਰ ਕਰਨ 'ਚ ਲੱਗੇਗਾ।
ਫਾਇਲਾਂ ਵਿੱਚ ਛੱਲੀ ਮਾਰਨ ਦੀ ਥਾਂ, ਬਹੁਤ ਸਾਰੇ ਡਿਵੈਲਪਰ ਇਕ ਛੋਟਾ "ਵਰਕ ਆਰਡਰ" ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰਨਗੇ: ਲਕੜੀ, ਬੰਧਨ, ਅਤੇ ਐਕਸੈਪਟੈਂਸ ਮੈਟ੍ਰਿਕਸ। ਸੋਚੋ: ਸਮਰਥਿਤ ਇਨਪੁੱਟ, ਪ੍ਰਦਰਸ਼ਨ ਸੀਮਾਵਾਂ, ਸੁਰੱਖਿਆ ਹੱਦਾਂ, ਅਤੇ ਕੀ ਸਹੀ ਨਤੀਜਾ ਲੱਗਦਾ ਹੈ।
ਅਚੋ ਛੋਟਾ ਪ੍ਰਾਂਪਟ ਅਕਸਰ ਇੱਕ ਮਿਨੀ ਸਪੈਕ ਵਾਂਗ ਪੜ੍ਹਦਾ ਹੈ:
ਇੱਕ-ਵਾਰੀ ਪ੍ਰੋੰਪਟ ਜੋ ਸਾਰੇ ਫੀਚਰ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਦਾ ਹੈ ਖਤਰਨਾਕ ਮਹਿਸੂਸ ਹੋਏਗਾ—ਖਾਸ ਕਰਕੇ ਸਾਂਝੇ ਕੋਡਬੇਸਾਂ ਵਿੱਚ। ਸਿਹਤਮੰਦ ਰਿਦਮ ਹੈ: ਇੱਕ ਛੋਟਾ ਬਦਲਾਅ ਮੰਗੋ, ਟੈਸਟ ਚਲਾਓ, ਡਿਫ ਦੇਖੋ, ਫਿਰ ਅਗਲੇ ਕਦਮ 'ਤੇ ਜਾਓ।
ਇਸ ਨਾਲ ਤੁਸੀਂ ਕੰਟਰੋਲ ਵਿੱਚ ਰਹਿੰਦੇ ਹੋ ਅਤੇ ਰੋਲਬੈਕ ਆਸਾਨ ਬਣ ਜਾਂਦੇ ਹਨ। ਇਹ ਰਿਵਿਊز ਨੂੰ ਵੀ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ ਕਿਉਂਕਿ ਹਰ ਬਦਲਾਅ ਦਾ ਸਪਸ਼ਟ ਮਕਸਦ ਹੁੰਦਾ ਹੈ।
ਇੱਕ ਸਧਾਰਣ ਆਦਤ ਬਚਤ ਕਰੇਗੀ: ਟੂਲ ਨੂੰ ਕਹੋ ਕਿ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਟਾਸਕ ਨੂੰ ਦੁਬਾਰਾ ਵਰਨਨ ਕਰੇ ਅਤੇ ਯੋਜਨਾ ਦੱਸੇ। ਜੇ ਉਸਨੇ ਤੁਹਾਡੀ ਪਾਬੰਦੀ ਗਲਤ ਸਮਝ ਲਈ ("ਪਬਲਿਕ API ਨਾ ਬਦਲੋ") ਜਾਂ ਕੋਈ ਮੁੱਖ ਏਜ‑ਕੇਸ ਛੱਡ ਦਿੱਤਾ, ਤਾਂ ਤੁਸੀਂ ਕੋਡ ਬਣਨ ਤੋਂ ਪਹਿਲਾਂ ਜਾਣ ਲੈਓਗੇ।
ਇਹ ਕਦਮ ਪ੍ਰਾਂਪਟਾਂ ਨੂੰ ਇੱਕ-ਹਰੇਕ ਗੱਲਬਾਤ ਬਣਾਉਂਦਾ ਹੈ, ਨਾਂ ਕਿ ਸਿਰਫ ਇਕ ਵੈਂਡਿੰਗ ਮਸ਼ੀਨ।
ਜਿਵੇਂ AI ਹੋਰ ਫਾਇਲਾਂ ਨੂੰ ਛੇਡਦਾ ਹੈ, ਟੀਮਾਂ ਲਈ ਇੱਕ ਛੋਟੀ, ਸਿੱਧੀ ਰਿਕਾਰਡ ਲਾਹੇਮੰਦ ਰਹੇਗੀ:
ਸਮੇਂ ਦੇ ਨਾਲ, ਇਹ ਇਰਾਦਾ, ਕੋਡ ਰਿਵਿਊ ਅਤੇ ਡੀਬੱਗਿੰਗ ਵਿਚਕਾਰ ਗਲੂ ਬਣ ਜਾਂਦਾ ਹੈ—ਖਾਸ ਕਰਕੇ ਜਦੋਂ "ਲੇਖਕ" ਹਿੱਸੇ ਤੌਰ 'ਤੇ ਏਜੰਟ ਹੋਵੇ।
Vibe coding ਟੀਮ ਦੇ ਧੁਰੇ ਨੂੰ "ਠੀਕ ਸਿੰਟੈਕਸ ਲਿਖਣਾ" ਤੋਂ "AI-ਸਹਾਇਤ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਟੇਰ ਕਰਨਾ" ਵੱਲ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਜਿਵੇਂ ਮਾਡਲ ਅਤੇ ਸੰਦਰਭ ਵਿੰਡੋ ਵਧਦੇ ਹਨ, ਤੁਹਾਡਾ ਲੈਵਰੇਜ ਇਸ 'ਤੇ ਨਿਰਭਰ ਹੋਵੇਗਾ ਕਿ ਤੁਸੀਂ ਸਮੱਸਿਆ ਨੂੰ ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ—ਅਤੇ ਤੁਸੀਂ ਨਤੀਜਾ ਨੂੰ ਕਿੰਨੀ ਤੇਜ਼ੀ ਨਾਲ ਵੈਰੀਫਾਈ ਕਰ ਸਕਦੇ ਹੋ।
ਇੱਕ ਉਪਯੋਗੀ ਮਾਨਸਿਕ ਮਾਡਲ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ "ਕੋਡ ਲਿਖੋ" ਤੋਂ "ਬੰਧਨ ਡਿਜ਼ਾਇਨ ਕਰੋ ਅਤੇ ਨਤੀਜੇ ਵੈਰੀਫਾਈ ਕਰੋ" ਵੱਲ ਜਾ ਰਹੇ ਹੋ। ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਵੇਰਵੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਵਧੇਰੇ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਲਗਾਓਗੇ:
ਇਹ ਉਸ ਤਰੀਕੇ ਨਾਲ ਏਜੰਟਿਕ ਟੂਲਾਂ ਨੂੰ ਅਲਾਈਨ ਰੱਖਦਾ ਹੈ ਜਦੋਂ ਉਹ ਤੁਹਾਡੀ ਥਾਂ ਤੇ ਕਈ ਛੋਟੇ ਫੈਸਲੇ ਕਰ ਰਹੇ ਹੋਣ।
ਜਿਵੇਂ ਮਾਹੌਲੀ IDE ਸਹਾਇਤਾ ਕੋਡ ਬਣਾਉਣਾ ਸਸਤਾ ਕਰਦੀ ਹੈ, ਡੀਬੱਗਿੰਗ ਵੱਖਰਾ ਕਰਦਾ ਹੈ। ਜਦੋਂ AI ਆਉਟਪੁੱਟ ਫੇਲ ਹੁੰਦਾ ਹੈ, ਉਹ ਅਕਸਰ "ਮੰਨਣਯੋਗ ਤਰੀਕੇ ਨਾਲ" ਫੇਲ ਹੁੰਦਾ ਹੈ—ਕਾਫੀ ਨੇੜੇ ਕਿ ਚੰਗੀ ਨਜਰ ਨਾਲ ਵੀ ਪਤਾ ਨਾ ਲੱਗੇ, ਪਰ ਕਾਫੀ ਗਲਤ ਕਿ ਬਾਅਦ ਵਿੱਚ ਸਮੱਸਿਆ ਖੜੀ ਕਰ ਦੇਵੇ। ਮਜ਼ਬੂਤ ਡਿਵੈਲਪਰ ਉਹ ਹੋਣਗੇ ਜੋ:
ਇਹ ਹੈ ਸਿਸਟਮ ਸੋਚ: ਟੁਕੜਿਆਂ ਦੇ ਇੱਕ ਦੂਜੇ ਨਾਲ ਕਰਦਿਆਂ ਦੇ ਬਾਰੇ ਸਮਝਵਾਂ, ਸਿਰਫ ਇਹ ਕਿ ਫੰਕਸ਼ਨ ਕਿਵੇਂ ਕੰਪਾਈਲ ਹੁੰਦੇ ਹਨ।
ਡਿਵੈਲਪਰਾਂ ਲਈ ਪ੍ਰਾਂਪਟਿੰਗ ਮਹੱਤਵ ਰੱਖੇਗੀ, ਪਰ ਚਲਾਕ ਟ੍ਰਿਕ ਜਾਂ ਦਿਲਚਸਪ ਕਲਾਵਾਂ ਨਹੀਂ। ਉੱਚ-ਲੈਵਰੇਜ ਤਰੀਕਾ ਸਪੱਸ਼ਟਤਾ ਹੈ: ਸਕੋਪ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਉਦਾਹਰਨ ਦਿਓ, ਪਾਬੰਦੀਆਂ ਦਾ ਨਾਮ ਲਵੋ ਅਤੇ ਫੇਲ੍ਹ ਮੋਡ ਵਰਨਨ ਕਰੋ। ਪ੍ਰਾਂਪਟਾਂ ਨੂੰ ਇੱਕ-ਮਿਨੀ ਸਪੈਕ ਵਾਂਗ ਸੋਚੋ—ਖਾਸ ਕਰਕੇ ਉਹ ਟਾਸਕ ਜਿਹੜੇ ਕਈ ਮੋਡੀਊਲਾਂ ਨੂੰ ਛੁਹਦੇ ਹਨ।
ਇੱਕ ਸਿਹਤਮੰਦ ਆਦਤ ਹੈ ਮੰਨਣਾ ਕਿ ਮਾਡਲ ਨੇ ਇੱਕ ਮਜ਼ਬੂਤ ਪਹਿਲਾ ਡਰਾਫਟ ਬਣਾਇਆ ਹੈ, ਪਰ ਅੰਤਿਮ ਉੱਤਰ ਨਹੀਂ। ਇਨ੍ਹਾਂ ਦੀ ਸਮੀਖਿਆ Junior teammate ਦੇ PR ਵਾਂਗ ਕਰੋ: ਸਹੀ ਹੋਣਾ, ਸੁਰੱਖਿਆ ਹੱਦਾਂ ਅਤੇ ਰੱਖ-ਰਖਾਵ ਦੀ ਜਾਂਚ ਕਰੋ।
Vibe coding ਮੈਜਿਕ ਵਰਗਾ ਮਹਿਸੂਸ ਹੋ ਸਕਦਾ ਹੈ: ਤੁਸੀਂ ਇਰਾਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਟੂਲ ਕੰਮ ਕਰਨ-ਵਾਲਾ ਕੋਡ ਉਪਜਾਉਂਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਅੱਗੇ ਵੱਧਦੇ ਹੋ। ਜੋਖਮ ਇਹ ਹੈ ਕਿ "ਕਮ ਕਰ ਰਿਹਾ ਹੈ ਲੱਗਦਾ" ਦਾ ਅਰਥ ਸਹੀ, ਸੁਰੱਖਿਅਤ, ਜਾਂ ਨਿਭਾਊ ਨਹੀਂ ਹੁੰਦਾ। ਜਿਵੇਂ AI ਸਹਾਇਤਾ ਵੱਧ ਰਹੀ ਹੈ—ਅਤੇ ਵੱਧ ਆਟੋਮੈਟਿਕ—ਛੋਟੀਆਂ ਗਲਤੀਆਂ ਦੀ ਕੀਮਤ ਤੇਜ਼ੀ ਨਾਲ ਜੋੜ ਸਕਦੀ ਹੈ।
ਜਨਰੇਟ ਕੀਤਾ ਕੋਡ ਅਕਸਰ ਮੰਨਣਯੋਗ ਪਰ ਗਲਤ ਹੁੰਦਾ ਹੈ। ਇਹ ਕੰਪਾਈਲ ਹੋ ਸਕਦਾ ਹੈ, ਖੁਸ਼-ਮਾਰਗ ਹੱਥ-ਚੈੱਕ ਪਾਸ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਵੀ ਅਸਲ ਦੁਨੀਆ ਹਾਲਾਤਾਂ ਵਿੱਚ ਫੇਲ ਹੋ ਸਕਦਾ ਹੈ: ਏਜ‑ਕੇਸ, concurrency, ਅਜਿਹੇ ਇਨਪੁੱਟ ਜਾਂ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਖਾਮੀਆਂ। ਹੋਰ ਖਤਰਨਾਕ ਗੱਲ ਇਹ ਹੈ ਕਿ ਕੋਡ ਅਜਿਹੇ ਢੰਗ ਨਾਲ ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਨਜ਼ਰਅੰਦਾਜ਼ ਰਹਿ ਜਾਵੇ—ਉਦਾਹਰਨ ਲਈ ਸੁਚੇਤਣੇ ਤੌਰ 'ਤੇ ਐਰਰ ਡ੍ਰੌਪ ਕਰ ਦੇਣਾ, ਗਲਤ ਟਾਈਮਜ਼ੋਨ ਵਰਤਣਾ, ਜਾਂ ਆਪਣੇ ਅਨுமான ਦੇ ਆਧਾਰ 'ਤੇ ਵਿਵਹਾਰ ਬਦਲ ਦੇਣਾ।
ਵਿਹਾਰਕ ਨਤੀਜਾ: ਤੇਜ਼ੀ ਟਾਈਪ ਕਰਨ ਤੋਂ ਬਦਲ ਕੇ ਵੈਰੀਫਿਕੇਸ਼ਨ ਵਿਖੇ ਗਤੀਸ਼ੀਲਤਾ ਵਧਦੀ ਹੈ।
AI ਟੂਲ ਅਕਸਰ ਕੁਝ ਆਮ ਤਰੀਕਿਆਂ ਨਾਲ ਤੁਹਾਡਾ ਐਟੈਕ ਸਰਫੇਸ ਵਧਾ ਸਕਦੇ ਹਨ:
ਆਪਣੇ ਗਾਰਡਰੇਲ ਇਥੇ ਪ੍ਰਕਿਰਿਆ ਅਤੇ ਟੈਕਨੌਲੋਜੀ ਦੋਹਾਂ ਬਾਰੇ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
Vibe-coded ਬਦਲਾਅ ਕੋਡਬੇਸ ਨੂੰ ਬੇਹਤਰੀਨ ਢੰਗ ਨਾਲ ਖਰਾਬ ਕਰ ਸਕਦੇ ਹਨ:
ਇਹ ਅਕਸਰ ਅੱਜ ਪ੍ਰੋਡਕਸ਼ਨ ਨੂੰ ਤੁਰੰਤ ਨਹੀਂ ਤੋੜਦੇ—ਪਰ ਇਹ ਰੱਖ-ਰਖਾਵ ਦੀ ਕੀਮਤ ਵਧਾਉਂਦੇ ਹਨ ਅਤੇ ਭਵਿੱਖੀ ਬਦਲਾਵਾਂ ਨੂੰ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੇ ਹਨ।
ਸੁਰੱਖਿਅਤ ਟੀਮ AI ਨਤੀਜੇ ਨੂੰ ਉਹਨਾਂ ਤਰੀਕਿਆਂ ਨਾਲ ਡਰਾਫਟ ਮੰਨਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੇ ਕੋਡਬੇਸ ਵਿੱਚ ਜਾਇਜ਼ ਹੋਣ ਲਈ ਢੰਗ ਕੀਤਾ ਹੋਵੇ:
Vibe coding ਤਦ ਹੀ ਤਾਕਤਵਰ ਰਹਿੰਦਾ ਹੈ ਜਦੋਂ "ਵਾਈਬ" ਰਚਨਾਤਮਕਤਾ ਨੂੰ ਤੇਜ਼ ਕਰੇ—ਪਰ ਵਰਿਫਿਕੇਸ਼ਨ ਉਪਭੋਗੀਆਂ, ਸਿਸਟਮਾਂ ਅਤੇ ਟੀਮਾਂ ਦੀ ਰੱਖਿਆ ਕਰੇ।
Copilot ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ। Agent ਕਰਦਾ ਹੈ।
ਇਸ ਇੱਕ ਬਦਲਾਅ ਕਾਰਜ ਦੇ ਰੂਪ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ: ਤੁਸੀਂ ਕਟਕਟ snippets ਮੰਗ ਕੇ ਆਪਣੇ ਆਪ ਜੋੜਨ ਦੀ ਥਾਂ, ਇੱਕ ਟਾਸਕ ਸੌਂਪਦੇ ਹੋ ("ਪੂਰੇ ਰਿਪੋ 'ਚ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਅੱਪਗ੍ਰੇਡ ਕਰੋ" ਜਾਂ "ਇਨ੍ਹਾਂ ਐਂਡਪੋਇੰਟਾਂ ਲਈ ਟੈਸਟ ਜੋੜੋ"), ਅਤੇ ਟੂਲ ਯੋਜਨਾ ਬਣਾਂਦਾ, ਫਾਇਲਾਂ ਸੋਧਦਾ, ਚੈੱਕ ਚਲਾਉਂਦਾ, ਅਤੇ ਸਬੂਤ ਨਾਲ ਵਾਪਸ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ।
ਏਜੰਟਿਕ ਟੂਲ ਇੱਕ ਜੂਨੀਅਰ ਟੀਮਮੇਟ ਵਾਂਗ ਕੰਮ ਕਰਦੇ ਹਨ ਜਿਸਨੂੰ ਤੁਸੀਂ ਕੰਮ ਸੌਂਪ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਇੱਕ ਟਾਸਕ ਦਿਓ, ਉਹ ਉਸਨੂੰ ਛੋਟੇ‑ਛੋਟੇ ਕਦਮਾਂ ਵਿੱਚ ਤੋੜਦਾ ਹੈ, ਕੀ ਛੇਡਿਆ ਗਿਆ ਇਹ ਟਰੈਕ ਕਰਦਾ ਹੈ, ਅਤੇ ਨਤੀਜਿਆਂ ਦਾ ਸੰਖੇਪ ਦਿੰਦਾ ਹੈ: ਕੀ ਬਦਲਿਆ, ਕੀ ਫੇਲ ਹੋਇਆ, ਅਤੇ ਕੀ ਉਹ ਭਰੋਸੇ ਨਾਲ ਫੈਸਲਾ ਨਹੀਂ ਕਰ ਸਕਿਆ।
ਚੰਗੇ ਏਜੰਟ ਡਿਫ, ਕਮਾਂਡ ਆਉਟਪੁੱਟ, ਅਤੇ ਨੋਟਾਂ ਛੱਡਦੇ ਹਨ ਜਿਸਨੂੰ ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਦੇਖ ਸਕਦੇ ਹੋ ਬਜਾਏ ਹਰ ਚੀਜ਼ ਨੂੰ ਮੁੜ-ਉਤਪੰਨ ਕਰਨ ਦੇ।
ਏਜੰਟ ਉਹ ਕੰਮ ਚੰਗੇ ਕਰਦੇ ਹਨ ਜੋ ਨਿਰਮਲ, ਦੁਹਰਾਓ ਆਧਾਰ ਅਤੇ ਆਸਾਨੀ ਨਾਲ ਵੈਰਿਫਾਇ ਹੋ ਸਕਦੇ ਹਨ:
ਚਾਬੀ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਸਫਲਤਾ ਨੂੰ ਟੂਲਿੰਗ ਨਾਲ ਵੈਰਿਫਾਈ ਕਰ ਸਕਦੇ ਹੋ: ਬਿਲਡ, ਟੈਸਟ, ਲਿੰਟਰ, ਸਨੇਪਸ਼ਾਟ ਜਾਂ ਕੁਝ ਪਛਾਣੇ ਹੋਏ ਵਿਹਾਰ।
ਉੱਚਤ ਮਾਡਲਾਂ ਦੇ ਬਾਵਜੂਦ, ਮਨੁੱਖ ਅਜੇ ਵੀ ਉਹ ਫੈਸਲੇ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਰਹਿੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ ਇੱਕ ਇਕਲੋਤਾ "ਸਹੀ" ਜਵਾਬ ਨਹੀਂ ਹੋਦਾ:
ਏਜੰਟ ਵਿਕਲਪ ਸੁਝਾ ਸਕਦੇ ਹਨ, ਪਰ ਇਰਾਦਾ ਤੁਹਾਡੀ ਮਾਲਕੀ ਹੈ।
ਜਦੋਂ ਟੂਲ ਕਈ ਕਦਮ ਲੈ ਸਕਦਾ ਹੈ, ਉਹ ਭੀ ਭਟਕ ਸਕਦਾ ਹੈ। ਡ੍ਰਿਫਟ ਰੋਕਣ ਲਈ ਸੰਰਚਨਾ ਲਗਾਓ:
ਏਜੰਟ ਦੌਰਾਨ ਦੇ ਜਾਂਦੇ ਕੰਮ ਨੂੰ ਛੋਟੀ-ਪ੍ਰੋਜੈਕਟ ਵਾਂਗ ਸਮਝੋ: ਸੀਮਤ ਲਕੜੀ, ਦਿੱਖਯੋਗੀ ਪ੍ਰਗਟਿ, ਅਤੇ ਸਪਸ਼ਟ ਰੋਕ ਪ੍ਰਬੰਧ।
ਜਿਵੇਂ AI ਹੋਰ ਕੋਡ ਲਿਖਦਾ ਹੈ, ਟੀਮ ਉਹ ਪ੍ਰਕਿਰਿਆ ਅਨੁਸਾਰ ਜਿੱਤਦੀਆਂ ਜਾਂ ਹਾਰਦੀਆਂ ਹਨ। ਤਕਨੀਕੀ ਨਿਕਾਸ ਤੇਜ਼ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਸਾਂਝੀ ਸਮਝ ਬਣਾਉਣ ਫਿਰ ਵੀ ਟੀਮ ਦੀ ਆਦਤ ਹੈ, ਨਾਂ ਕਿ ਮਾਡਲ ਦੀ ਖਾਸੀਅਤ।
ਪੁੱਲ ਰਿਕਵੈਸਟ ਹੁਣ GENERATED ਬਦਲਾਅ ਦਾ ਬੰਡਲ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਨਾਲ "ਡਿਫ ਸਕੈਨ ਕਰਕੇ ਭਰੋਸਾ ਕਰੋ" ਔਖਾ ਹੋ ਜਾਦਾ ਹੈ।
PR ਟੈਮਪਲੇਟ ਇਰਾਦਾ ਅਤੇ ਜੋਖਮ 'ਤੇ ਜੋਰ ਦੇਣਗੇ: ਬਦਲਾਅ ਦਾ ਉਦੇਸ਼, ਕੀ ਟੂਟ ਸਕਦਾ ਹੈ, ਅਤੇ ਕਿਵੇਂ ਇਹ ਚੈੱਕ ਕੀਤਾ ਗਿਆ। ਸਮੀਖਿਆਵਾਂ ਇਨਵੈਰੀਅੰਟਸ (ਸੁਰੱਖਿਆ ਨਿਯਮ, ਡੋਮੇਨ ਲੋਗਿਕ, ਪ੍ਰਦਰਸ਼ਨ ਹੱਦਾਂ) 'ਤੇ ਵੱਧ ਧਿਆਨ ਦੇਣਗੀਆਂ ਅਤੇ ਫਾਰਮੈਟਿੰਗ/ਬੋਇਲਰਪਲੇਟ 'ਤੇ ਘੱਟ।
ਟਿਕਟ ਵੀ ਹੋਰ ਰਚਿਤ ਹੋ ਸਕਦੇ ਹਨ: ਸਪਸ਼ਟ ਸਫਲਤਾ ਮਾਪਦੰਡ, ਏਜ‑ਕੇਸ, ਅਤੇ ਨਮੂਨਾ ਇਨਪੁੱਟ/ਆਉਟਪੁੱਟ ਜੋ ਮਨੁੱਖਾਂ ਅਤੇ ਟੂਲਾਂ ਦੋਹਾਂ ਲਈ ਭਰੋਸੇਯੋਗ ਲਕੜੀ ਬਣਾਉਂਦੇ ਹਨ। ਚੰਗਾ ਟਿਕਟ ਇੱਕ ਠੇਕਾ ਬਣ ਜਾਂਦਾ ਹੈ ਜੋ AI ਨਤੀਜੇ ਨੂੰ ਰਸਤਾ 'ਤੇ ਰੱਖਦਾ ਹੈ।
ਉੱਚ-ਪਰਦਰਸ਼ੀ ਟੀਮਾਂ ਕੁਝ ਹਲਕੇ-ਫੁਲਕੇ ਆਰਟੀਫੈਕਟ ਹਨ ਜੋ ਅੰਧੇਰੇ ਘਟਾਉਂਦੇ ਹਨ:
ਇਹ ਕਾਗਜ਼ੀ ਕਾਰਵਾਈ ਨਹੀਂ—ਇਹ ਯਾਦ ਹੈ। ਜਦ ਕਿਸੇ ਨੂੰ ਸਮਝ ਨਹੀਂ ਆਉਂਦਾ ਕਿ ਕੋਈ ਜਨਰੇਟ ਕੀਤੀ ਪੈਟਰਨ ਕਿਉਂ ਹੈ, ਇਹ ਭਵਿੱਖੀ ਮੁੜ-ਕੰਮ ਨੂੰ ਰੋਕਦਾ ਹੈ।
ਟੀਮਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਨੀਤੀਆਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ:
ਕੇਵਲ ਵੇਲੋਕਿਟੀ ਗਲਤ ਸੂਚਕ ਹੈ। ਨਤੀਜੇ ਮਾਪੋ: ਲੀਡ ਟਾਈਮ, escaped defects, ਪ੍ਰੋਡਕਸ਼ਨ ਘਟਨਾਵਾਂ, ਅਤੇ ਰੱਖ-ਰਖਾਵ ਸੰਕੇਤ (ਲਿੰਟ/ਐਰਰ ਰੁਝਾਨ, ਘਣਤਾ, ਫਲੇਕੀ ਟੈਸਟ)। ਜੇ AI throughput ਵਧਾਉਂਦਾ ਹੈ ਪਰ ਇਹ ਖ਼ਰਾਬ ਕਰਦਾ ਹੈ, ਤਾਂ ਪ੍ਰਕਿਰਿਆ—ਨੀਂਦਾ ਕਿ ਲੋਕ—ਸੰਸ਼ੋਧਨ ਦੀ ਲੋੜ ਹੈ।
Vibe coding "ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਲਿਖਣ ਵਿੱਚ ਮਦਦ" ਤੋਂ "ਇਸ ਸਿਸਟਮ ਨੂੰ ਸਟੇਰ ਕਰਨ ਵਿੱਚ ਮਦਦ" ਵੱਲ ਜਾ ਰਿਹਾ ਹੈ। ਇਹ ਇੱਕ ਝਟਕੇ ਨਾਲ ਨਹੀਂ ਆਏਗਾ—ਇਹ ਬਿਹਤਰ ਮਾਡਲ, ਲੰਬੇ ਸੰਦਰਭ, ਅਤੇ ਐਸੇ ਟੂਲਾਂ ਦਾ ਧੀਰੇ-ਧੀਰੇ ਮਿਲਣਾ ਹੋਵੇਗਾ ਜਿਹੜੇ ਚੈਟ ਵਾਂਗ ਨਹੀਂ ਪਰ ਹਰ ਵੇਲੇ ਦੇ ਟੀਮਮੇਟ ਵਾਂਗ ਮਹਿਸੂਸ ਹੋਣ।
ਕਾਪੀ‑ਪੇਸਟ ਘਟਣ ਅਤੇ "ਸਰਜੀਕਲ" ਮਦਦ ਵੱਧਣ ਦੀ ਉਮੀਦ ਕਰੋ: ਬਹੁ-ਫਾਇਲ ਸੋਧ ਜੋ ਵਾਸਤਵ ਵਿੱਚ ਕੰਪਾਈਲ ਹੁੰਦੇ ਹਨ, ਰਿਪੋ ਦੀਆਂ ਰਿਵਾਜ਼ਾਂ 'ਤੇ ਅਧਾਰਤ ਸੁਝਾਅ, ਅਤੇ ਸਹਾਇਕ ਜੋ ਬਿਨਾਂ ਤੁਹਾਡੇ ਕੋਨ्टੈਕਸਟ ਦੇ ਘੱਟ-ਹੱਥ-ਹਿਸਾਬੋਂ ਸੰਦਰਭ ਖਿੱਚਦੇ ਹਨ।
ਤੁਹਾਨੂੰ ਹੋਰ ਮਾਹੌਲੀ ਸਹਾਇਤਾ ਵੀ ਦੇਖਣ ਨੂੰ ਮਿਲੇਗੀ: inline ਵਿਆਖਿਆਵਾਂ, ਛੋਟੇ ਟੈਸਟਾਂ ਦੀ ਆਟੋਮੈਟਿਕ ਤਿਆਰੀ, ਅਤੇ ਤੇਜ਼ ਕੋਡ ਰਿਵਿਊ ਸਹਾਇਤਾ—ਹਾਲਾਂਕਿ ਅਜੇ ਵੀ ਤੁਹਾਡੇ ਦੌਰਾ ਚਲਾਈ ਜਾਂਦੀ ਹੈ।
ਵੱਡਾ ਕਦਮ ਰਿਫੈਕਟਰਨ ਅਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕੰਮ ਵਿੱਚ ਆਏਗਾ: ਰਿਪੋ ਭਰ ਵਿੱਚ ਨਾਂ-ਬਦਲਣਾ, ਡਿਪੈਂਡੈਂਸੀ ਅੱਪਗ੍ਰੇਡ, ਡੀਪ੍ਰੀਕੇਸ਼ਨ, ਪ੍ਰਦਰਸ਼ਨ ਸੁਧਾਰ ਅਤੇ ਸੰਰਚਨਾ-ਇਕਸਾਰ ਕਰਨ ਵਰਗੇ ਚੋਰੇ। ਇਹ ਏਜੰਟ ਲਈ ਆਦਰਸ਼ ਹਨ—ਜੇ ਰੋਕ‑ਰਕਾਵਲ ਅਸਲ ਹੋਣ।
ਪ੍ਰਬੰਧ ਇਹ ਹੋਏਗਾ: ਟੂਲ ਯੋਜਨਾ ਪ੍ਰਸਤਾਵ ਕਰੇ, ਚੈੱਕ ਚਲਾਏ, ਅਤੇ ਸਮੀਖਿਆਯੋਗ ਚੇਨ (PR) ਤਿਆਰ ਕਰੇ, ਸੀਧਾ ਮੇਨ ਸ਼ਾਖਾ ਤੇ ਸੋਧ ਨਹੀਂ ਕਰੇ। ਵਧੀਆ ਟੀਮ AI ਆਉਟਪੁੱਟ ਨੂੰ ਹੋਰ ਕਿਸੇ ਹਿੱਸੇ ਵਰਗ ਤਰ੍ਹਾਂ ਮੰਨਦੇ ਹਨ: ਟੈਸਟ ਕੀਤਾ, ਰਿਵਿਊ ਕੀਤਾ ਅਤੇ ਮਾਪਿਆ।
ਵਕਤ ਦੇ ਨਾਲ, ਹੋਰ ਕੰਮ ਇਰਾਦੇ ਤੋਂ ਸ਼ੁਰੂ ਹੋਵੇਗਾ: "ਇਹ ਕੰਪਨੀ SSO ਇਨ੍ਹਾਂ ਬੰਧਨਾਂ ਨਾਲ ਜੋੜੋ", "p95 ਲੈਟੈਂਸੀ 20% ਘਟਾਓ ਬਿਨਾਂ ਲਾਗਤ ਵਧਾਉਂਦੇ", ਜਾਂ "ਆਨਬੋਰਡਿੰਗ 10 ਮਿੰਟ ਤੋਂ ਘੱਟ ਕਰੋ"। ਪ੍ਰਣਾਲੀ ਇਸ ਇਰਾਦੇ ਨੂੰ ਛੋਟੇ, ਵੈਰੀਫਾਇਡ ਬਦਲਾਵਾਂ ਦੀ ਲੜੀ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗੀ—लगਾਤਾਰ ਤੌਰ ਤੇ ਸਹੀਪਨ, ਸੁਰੱਖਿਆ, ਅਤੇ ਰੀਗ੍ਰੈਸ਼ਨ ਚੈੱਕ ਕਰਦਿਆਂ।
ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਮਨੁੱਖ ਹਟ ਜਾਂਦੇ ਹਨ; ਇਹ ਮਨੁੱਖਾਂ ਨੂੰ constraints ਡਿਫਾਈਨ ਕਰਨ, ਟਰੇਡ‑ਆਫ਼ ਮੁਲਾਂਕਣ ਕਰਨ, ਅਤੇ ਗੁਣਵੱਤਾ ਸੈਟ ਕਰਨ ਵੱਲ ਧੱਕਦਾ ਹੈ।
ਛੋਟੇ ਅਤੇ ਮਾਪਯੋਗ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ। ਇੱਕ ਪਾਇਲਟ ਲਿਆਉ ਜੋ ਸੀਖਣ ਲਈ ਸਸਤਾ ਹੋਵੇ (ਅੰਦਰੂਨੀ ਟੂਲ, ਟੈਸਟ ਜਨਰੇਸ਼ਨ, ਡੌਕਸ, ਇੱਕ ਸੀਮਤ ਸਰਵਿਸ)। ਸਫਲਤਾ ਮਾਪੋ: ਸਾਈਕਲ ਸਮਾਂ, ਡਿਫੈਕਟ ਦਰ, ਸਮੀਖਿਆ ਸਮਾਂ, ਅਤੇ ਰੋਲਬੈਕ ਅਵਰੰਤੀ।
ਟੂਲਾਂ ਦੀ ਮੁਲਾਂਕਣ ਕਰਦੇ ਸਮੇਂ ਤਰਜੀਹ ਦਿਓ: ਰਿਪੋ-ਜਾਣੂ ਸੰਦਰਭ ਰੀਟਰੀਵਲ, ਪਾਰਦਰਸ਼ੀ ਯੋਜਨਾ-ਪੇਸ਼ਕਰ, ਮਜ਼ਬੂਤ ਡਿਫ/PR ਵਰਕਫਲੋ, ਅਤੇ ਤੁਹਾਡੇ ਮੌਜੂਦਾ CI ਅਤੇ ਸੁਰੱਖਿਆ ਚੈੱਕਾਂ ਨਾਲ ਇਕੀਕਰਨ।
ਜੇ ਤੁਸੀਂ ਐਡੀਟਰ ਤੋਂ ਹੀ ਬਾਹਰ "vibe coding" ਦਾ ਤਜਰਬਾ ਲੈ ਰਹੇ ਹੋ—ਖਾਸ ਕਰਕੇ ਪੂਰੇ ਐਪਲੀਕੇਸ਼ਨ ਲਈ—ਤਾਂ Koder.ai ਵਰਗੇ ਪਲੇਟਫਾਰਮ ਇੱਥੇ ਟੂਲਾਂ ਕਿੱਥੇ ਜਾ ਰਹੇ ਹਨ ਦਾ ਇੱਕ ਉੱਦਾਹਰਨ ਹਨ: ਇਰਾਦਾ-ਪਹਿਲਾਂ ਵਿਕਾਸ ਚੈਟ ਇੰਟਰਫੇਸ ਵਿੱਚ, ਸਪੈਕ ‘ਤੇ ਸਹਿਮਤੀ ਲਈ ਯੋਜਨਾ ਮੋਡ, ਅਤੇ ਸੇਫਟੀ ਫੀਚਰ ਜਿਵੇਂ ਸਨੈਪਸ਼ਾਟ ਅਤੇ ਰੋਲਬੈਕ। ਅਮਲੀ ਤੌਰ ਤੇ, ਸੋਰਸ ਕੋਡ ਐਕਸਪੋਰਟ ਅਤੇ ਸਮੀਖਿਆਯੋਗ ਸੋਧ (ਨਾਲ ਡਿਪлойਮੈਂਟ / ਹੋਸਟਿੰਗ ਵਿਕਲਪ ਜਦੋਂ ਤੁਸੀਂ ਚਾਹੋ) ਇਸ ਲੇਖ ਦਾ ਮੁੱਖ ਪಾಠ ਦੁਹਰਾਉਂਦੇ ਹਨ: ਤੇਜ਼ੀ ਸੱਚੀ ਹੈ, ਪਰ ਇਹ ਤਦ ਹੀ ਕੀਮਤੀ ਰਹਿੰਦੀ ਹੈ ਜਦੋਂ ਵਰਿਫਿਕੇਸ਼ਨ ਅਤੇ ਕੰਟਰੋਲ ਵਰਕਫਲੋ ਵਿੱਚ ਜੁੜੇ ਹੋਣ।
ਅਖੀਰਕਾਰ, ਉਹ ਸਕਿੱਲਾਂ ਵਿੱਚ ਨਿਵੇਸ਼ ਕਰੋ ਜੋ ਸੰਘਣੇ ਹੁੰਦੇ ਹਨ: ਨਿਰਧਾਰਿਤ ਇरਾਦੇ ਅਤੇ ਬੰਧਨ ਲਿਖਣਾ, ਚੰਗੇ ਐਕਸੈਪਟੈਂਸ ਟੈਸਤ ਬਣਾਉਣਾ, ਅਤੇ ਵੈਰੀਫਿਕੇਸ਼ਨ ਆਦਤਾਂ (ਟੈਸਟ, ਲਿੰਟਰ, ਖ਼ਤਰੇ-ਮਾਡਲਿੰਗ) ਤਿਆਰ ਕਰਨਾ ਤਾਂ ਜੋ AI ਦੀ ਤੇਜ਼ੀ AI ਕਰਜ਼ੇ ਵਿੱਚ ਨਾ ਬਦਲੇ।
Vibe coding ਇੱਕ ਇੰਤਜ਼ਾਮ-ਪਹਿਲਾਂ ਵਰਕਫਲੋ ਹੈ: ਤੁਸੀਂ ਉਹ ਵਿਵਹਾਰ ਵਰਣਨ ਕਰਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ (ਇਸ ਦੇ ਨਾਲ ਬੰਧਨ ਅਤੇ ਉਦਾਹਰਨ), ਇੱਕ AI ਕੋਡ ਡਰਾਫਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਸਮੀਖਿਆ, ਸੋਧ, ਅਤੇ ਦੁਹਰਾਉ ਕਰਦੇ ਹੋ। "ਕੰਮ ਦੀ ਇਕਾਈ" ਟਾਈਪਿੰਗ ਤੋਂ ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼ ਅਤੇ ਨਤੀਜੇ ਦੀ ਜਾਂਚ ਕਰਨਾ ਬਣ ਜਾਂਦੀ ਹੈ ਨਾ ਕਿ ਹਰ ਲਾਇਨ ਖੁਦ ਲਿਖਣਾ।
ਇਹ ਵੱਖਰਾ ਹੈ:
ਤੁਹਾਨੂੰ ਕੋਡ ਆਉਣੀ ਜਾਣi jaroori ਹੈ। ਤੁਸੀਂ ਅਜੇ ਵੀ ਨਤੀਜੇ, ਸੁਰੱਖਿਆ ਅਤੇ ਰੱਖ-ਰਖਾਵ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋ। ਵੇਖੋ AI ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਜੂਨੀਅਰ ਟੀਮਮੇਟ ਦੇ ਮਜ਼ਬੂਤ ਡਰਾਫਟ ਵਾਂਗ: ਅਨੁਮਾਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ, ਟੈਸਟ ਚਲਾਓ, ਅਤੇ ਪੱਕਾ ਕਰੋ ਕਿ ਇਹ ਤੁਹਾਡੇ ਬੰਧਨਾਂ ਅਤੇ ਪ੍ਰੋਡਕਟ ਇਰਾਦੇ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
ਇਹ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ:
ਇਹ ਓਹੋ ਜਗ੍ਹਾ ਵਿੱਚ ਘੱਟzor ਹੈ ਜਦੋਂ:
ਇਹਨਾਂ ਹਾਲਾਤਾਂ ਵਿੱਚ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਲਾਭ ਵਾਲਾ ਕੰਮ ਹੈ ਇਰਾਦਾ ਸਾਫ ਕਰਨਾ ਅਤੇ ਸਬੂਤ ਅਲੱਗ ਕਰ ਕੇ AI ਨੂੰ ਪੁੱਛਣਾ।
ਕਿਉਂਕਿ ਵਿਚਾਰਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਲਾਗਤ ਘਟ ਗਈ ਹੈ: ਵਰਣਨ → ਜੇਨਰੇਟ → ਚਲਾਓ → ਸਮਾਇਕ ਕਰੋ. ਜਿਵੇਂ ਕਿ ਜਨਰੇਸ਼ਨ ਸਸਤਾ ਹੋ ਰਿਹਾ ਹੈ, ਟੀਮਾਂ ਛੋਟੇ ਬਦਲਾਵਾਂ ਤੇ ਤੇਜ਼ੀ ਨਾਲ ਇਤਰੇਟ ਕਰ ਸਕਦੀਆਂ ਹਨ—ਖਾਸ ਕਰਕੇ ਉਹਨਾਂ ਕੰਮਾਂ 'ਤੇ ਜੋ ਅਕਸਰ ਨਜ਼ਰਅੰਦਾਜ਼ ਹੋ ਜਾਂਦੇ ਹਨ।
ਇੱਕ ਛੋਟਾ “ਵਰਕ ਆਰਡਰ” ਦਿਓ ਜੋ AI ਕਰ ਸਕੇ:
ਫਿਰ ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਉਸnu “ਵਰਣਨ + ਯੋਜਨਾ” ਬੂਲਵਾਓ ਤਾਂ ਕਿ ਭੁੱਲ ਪਹਿਲਾਂ ਹੀ ਫੜੀ ਜਾਵੇ।
ਇੱਕ ਕਸਕ ਲੂਪ ਵਰਤੋ:
ਇੱਕ-ਵਾਰੀ ਦੇ ਪ੍ਰੋਮਪਟ ਜਿਹੜੇ ਪੂਰੇ ਫੀਚਰ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਦੇ ਹਨ ਉਹ ਖਤਰਨਾਕ ਮਹਿਸੂਸ ਹੋ ਸਕਦੇ ਹਨ—ਖਾਸ ਕਰਕੇ ਸਾਂਝੇ ਕੋਡਬੇਸ ਵਿੱਚ।
ਸਭ ਤੋਂ ਵੱਡਾ ਖਤਰਾ ਇਹ ਹੈ ਕਿ AI-ਆਉਟਪੁੱਟ ਮੰਨਣਯੋਗ ਪਰ ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ। ਆਮ ਫੇਲਯੋਗ ਹਨ: ਛੱਡੇ ਕੇਸ ਨਹੀਂ ਮਿਟੇ, ਬਣਾਇਆ ਹੋਇਆ API, ਚੁੱਪਚਾਪ ਵਿਵਹਾਰ ਬਦਲਣਾ, ਅਤੇ ਬੇਇੰਤਹਾ ਧਰੋਹ। ਵੈਰੀਫਿਕੇਸ਼ਨ—ਟੈਸਟ, ਰਿਵਿਊ ਅਤੇ ਸਪੱਸ਼ਟ ਐਕਸੈਪਟੈਂਸ ਚੈਕ—ਮੁੱਖ ਬਾਧਾ ਬਣ ਜਾਂਦੀ ਹੈ।
ਪੱਧਰ-ਬੱਧ ਗਾਰਡਰੇਲ ਵਰਤੋਂ: