24 ਅਗ 2025·8 ਮਿੰਟ
ਵਾਇਬ ਕੋਡਿੰਗ ਅਮਲ ਵਿੱਚ: ਇਹ ਇੰਜੀਨিয়ারਿੰਗ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰੀ ਹੈ
ਵਾਇਬ ਕੋਡਿੰਗ ਇੱਕ ਤੇਜ਼, ਪਰਯੋਗ-ਪਹਿਲਾਂ ਤਰੀਕਾ ਹੈ AI ਨਾਲ ਬਣਾਉਣ ਦਾ। ਜਾਣੋ ਦਿਨ-ਬ-ਦਿਨ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਹ ਸਾਫਟਵੇਅਰ ਇੰਜੀਨਿਆਰਿੰਗ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ, ਅਤੇ ਇਹ ਕਦੋਂ ਉਚਿੱਤ ਹੈ।
ਵਾਇਬ ਕੋਡਿੰਗ ਇੱਕ ਤੇਜ਼, ਪਰਯੋਗ-ਪਹਿਲਾਂ ਤਰੀਕਾ ਹੈ AI ਨਾਲ ਬਣਾਉਣ ਦਾ। ਜਾਣੋ ਦਿਨ-ਬ-ਦਿਨ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਹ ਸਾਫਟਵੇਅਰ ਇੰਜੀਨਿਆਰਿੰਗ ਤੋਂ ਕਿਵੇਂ ਵੱਖਰਾ ਹੈ, ਅਤੇ ਇਹ ਕਦੋਂ ਉਚਿੱਤ ਹੈ।
“Vibe coding” ਇਰਾਦਾ-ਪਹਿਲਾਂ ਨਿਰਮਾਣ ਹੈ: ਤੁਸੀਂ ਪਹਿਲਾਂ ਇਹ ਦੱਸਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੀ ਹੋਣਾ ਚਾਹੁੰਦਾ ਹੈ, ਤੇਜ਼ੀ ਨਾਲ ਕੁਝ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਅਤੇ ਡਿਜ਼ਾਈਨ ਹਰ ਇਕ ਵਿਸਥਾਰ ਅੱਗੇ ਤੋਂ ਕਰਨ ਦੀ ਥਾਂ ਮਹਿਸੂਸ ਅਤੇ ਪ੍ਰਤੀਕ੍ਰਿਆ ਦੇ ਆਧਾਰ 'ਤੇ ਨਤੀਜੇ ਨੂੰ ਸੜਕਦੇ ਹੋ। “ਵਾਇਬ” ਉਹ ਤਿੱਖੀ ਲੂਪ ਹੈ—ਥੋੜ੍ਹਾ ਲਿਖੋ, ਚਲਾਓ, ਪ੍ਰਤੀਕਿਰਿਆ ਦਿਓ, ਠੀਕ ਕਰੋ—ਜਦ ਤੱਕ ਉਤਪਾਦ ਉਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤੋਂ ਨਾ ਕਰੇ ਜਿਸਨੂੰ ਤੁਸੀਂ ਸੋਚਿਆ ਸੀ।
ਚੰਗੀ ਤਰ੍ਹਾਂ, vibe coding ਪ੍ਰਾਂਪਟ-ਚਲਿਤ ਵਿਕਾਸ ਨਾਲ ਨਿਰਮਾਤਾ ਮਨੋਭਾਵ ਹੈ: ਤੁਸੀਂ ਨਤੀਜੇ ਨੂੰ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਪਹਿਲਾ ਡਰਾਫਟ ਜਨਰੇਟ ਜਾਂ ਲਿਖਦੇ ਹੋ, ਫਿਰ ਜੋ ਤੁਸੀਂ ਵੇਖਦੇ ਹੋ ਉਸਦੇ ਆਧਾਰ 'ਤੇ ਦੁਹਰਾਓ। ਇਹ ਘੱਟ “ਪੂਰਾ ਯੋਜਨਾ, ਫਿਰ ਨਿਰਵਾਹ” ਅਤੇ ਵਧੇਰੇ “ਇਸਨੂੰ ਹਕੀਕਤ ਬਣਾਓ, ਫਿਰ ਇਸਨੂੰ ਸਵਾਰੋ” ਵਰਗਾ ਹੈ।
AI-ਸਹਾਇਤ ਕੋਡਿੰਗ ਇਸ ਤਰੀਕੇ ਨੂੰ ਤੇਜ਼ ਬਣਾਉਂਦੀ ਹੈ ਕਿਉਂਕਿ ਇਹ scaffolding ਤਿਆਰ ਕਰ ਸਕਦੀ ਹੈ, ਇੰਪਲੀਮੇਂਟੇਸ਼ਨਾਂ ਸੁਝਾ ਸਕਦੀ ਹੈ, ਅਤੇ ਅਸਪਸ਼ਟ ਇਰਾਦੇ ਨੂੰ ਚਲਦੇ ਕੋਡ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਸਕਦੀ ਹੈ। ਪਰ ਇਹ ਰਵਾਇਤ ਅੱਜ ਦੇ ਟੂਲਾਂ ਤੋਂ ਪਹਿਲਾਂ ਵੀ ਸੀ—AI ਸਿਰਫ਼ ਵਿਚਾਰਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਲਾਗਤ ਘਟਾਉਂਦਾ ਹੈ।
ਮੁਢਲੀ ਕੌਸ਼ਲ ਫਿਰ ਵੀ ਮਨੁੱਖੀ ਹੈ: ਅਗਲਾ ਕੀ ਬਣਾਉਣਾ ਹੈ ਇਹ ਫੈਸਲਾ ਕਰਨਾ, ਜਦੋਂ ਕੁਝ ਗਲਤ ਹੈ ਇਹ ਪਛਾਣਨਾ, ਅਤੇ ਦੋਹਰਾਅ ਅਤੇ ਪ੍ਰਤੀਕ੍ਰਿਆ ਲੂਪ ਨੂੰ ਸੱਚਾ ਰੱਖਣਾ।
ਜੇ ਤੁਸੀਂ ਇਸ ਲੂਪ ਦੇ ਆਸ-ਪਾਸ ਬਣੀ ਵਰਕਫਲੋ ਦਾ ਉਦਾਹਰਨ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Koder.ai ਅਸਲ ਵਿੱਚ “ਪਲੇਟਫਾਰਮ ਵਜੋਂ vibe coding” ਹੈ: ਤੁਸੀਂ ਐਪ ਨੂੰ ਚੈਟ ਵਿੱਚ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਵਿਵਹਾਰ ਅਤੇ UI 'ਤੇ ਦੁਹਰਾਓ ਕਰਦੇ ਹੋ, ਅਤੇ ਏਜੰਟ-ਆਧਾਰਿਤ ਸਿਸਟਮ ਪ੍ਰੋਜੈਕਟ (React ਵੈੱਬ ਐਪ, Go/PostgreSQL ਬੈਕਏਂਡ, ਅਤੇ Flutter ਮੋਬਾਈਲ ਐਪ) ਜਨਰੇਟ ਅਤੇ ਐਡਜਸਟ ਕਰਦਾ ਹੈ। ਮਕਸਦ ਇਹ ਨਹੀਂ ਕਿ ਕੋਈ ਟੂਲ “ਇੰਜੀਨਿਆਰਿੰਗ ਨੂੰ ਬਦਲ ਦੇਵੇ”—ਬਲਕਿ ਇਹ ਕਿ ਇਸੇ ਵਿਚਾਰ → ਚਲਦਾ ਸਲਾਈਸ → ਸੁਧਾਰ ਦਾ ਸਮਾਂ ਘਟ ਜਾਂਦਾ ਹੈ।
Vibe coding ਨਿਰਮਾਤਾ ਸਭਿਆਚਾਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ: ਲੋਕ ਛੋਟੀ ਟੈਸਟ-ਪ੍ਰੋਜੈਕਟ, ਪ੍ਰੋਟੋਟਾਈਪ, ਅਤੇ ਨਿੱਜੀ ਟੂਲ ਬਿਨਾਂ ਮਨਜ਼ੂਰੀ ਲਈ ਭੇਜਣਾ ਚਾਹੁੰਦੇ ਹਨ। ਹੋ ਸਕਣ ਯਕਥ ਟੂਲ—ਹੋਸਟ ਕੀਤੇ گئے ਡਿਵ ਐਨਵਾਇਰਨਮੇਂਟ, ਐਪ ਟੈਂਪਲੇਟ, ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਕੋਪਾਇਲਟ—ਤੇਜ਼ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ ਨੂੰ ਨਾਰਮਲ ਮਹਿਸੂਸ ਕਰਵਾਉਂਦੇ ਹਨ ਨਾਂ ਕਿ “ਸਿਰਫ਼ ਮਾਹਿਰਾਂ ਲਈ”।
ਇਹ ਜਾਦੂ ਨਹੀਂ ਹੈ, ਅਤੇ ਨਾ ਹੀ ਸੋਚ ਛੱਡਣਾ ਹੈ। ਤੁਹਾਨੂੰ ਹਾਲੇ ਵੀ ਸਕੋਪ, ਟੈਸਟ, ਅਤੇ ਟਰੇਡਆਫ ਕਰਨੇ ਪੈਂਦੇ ਹਨ। Vibe coding “ਕੋਈ ਢਾਂਚਾ ਨਹੀਂ” ਵੀ ਨਹੀਂ ਹੈ: ਇਹ ਠੀਕ ਉਤਨਾ ਹੀ ਢਾਂਚਾ ਚੁਣਨ ਹੈ ਜੋ ਗਤੀ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖੇ ਜਦੋਂ ਤੁਸੀਂ ਸਿੱਖ ਰਹੇ ਹੋ ਕਿ ਉਤਪਾਦ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਅਮਲ ਵਿੱਚ, vibe coding "ਸਿਸਟਮ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣ" ਲਗਭਗ ਨਹੀ, ਬਲਕਿ "ਇੱਕ ਸਿਆਣਾ ਪੇਅਰ-ਪ੍ਰੋਗਰਾਮਰ ਨੂੰ ਇੱਕ ਉਪਯੋਗ ਨਤੀਜੇ ਵੱਲ ਮਾਰਗਦਰਸ਼ਨ" ਵਰਗਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ। ਮਕਸਦ ਗਤੀ ਹੈ: ਕੁਝ ਚੱਲਦਾ ਹੋਇਆ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰੋ, ਫਿਰ ਛੋਟੇ ਲੂਪਾਂ ਵਿੱਚ ਇਸਨੂੰ ਕਸੋ।
ਇੱਕ ਛੋਟਾ, ਟੈਸਟ ਕਰਨ ਯੋਗ ਨਤੀਜਾ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਇਕ ਬੈਠਕ ਵਿੱਚ ਖਤਮ ਕਰ ਸਕਦੇ ਹੋ—ਕੁਝ ਜੋ ਦਿੱਖ ਵਿੱਚ ਨਤੀਜਾ ਦੇਵੇ। ਉਦਾਹਰਨ: “ਇੱਕ ਪੇਜ ਜਿੱਥੇ ਮੈਂ ਆਈਟਮ ਜੋੜ ਸਕਾਂ ਅਤੇ ਰੀਫ੍ਰੈਸ਼ ਤੋਂ ਬਾਅਦ ਵੀ ਉਹ ਸੰਭਲ ਕੇ ਰਹਿਣ।” ਇੱਕ ਪਤਲੀ ਵਰਟੀਕਲ ਸਲਾਈਸ ਇੱਕ ਵੱਡੀ ਚੈੱਕਲਿਸਟ ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ ਕਿਉਂਕਿ ਇਹ ਸੱਚੀਆਂ ਪਾਬੰਦੀਆਂ ਨੂੰ ਜਲਦੀ ਸਾਹਮਣੇ ਲਿਆਉਂਦਾ ਹੈ।
ਫਾਇਲਾਂ ਦੇ ਨਾਂ ਰੱਖਣ ਜਾਂ ਆਰਕੀਟੈਕਚਰ ਦੀ ਚਰਚਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਧੀ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖੋ ਕਿ ਫੀਚਰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ: ਇਨਪੁੱਟ, ਆਉਟਪੁੱਟ, ਐਜ ਕੇਸ, ਅਤੇ "ਡਨ" ਕਿਵੇਂ ਲੱਗਦਾ ਹੈ। ਇਹ ਤੁਹਾਡੇ ਪ੍ਰਾਂਪਟਾਂ ਅਤੇ ਮੂਲਿਆਕਨ ਲਈ ਐਂਕਰ ਬਣ ਜਾਂਦਾ ਹੈ।
AI ਨੂੰ ਸ਼ੁਰੂਆਤੀ ਇੰਪਲੀਮੇਂਟੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਕਹੋ, ਫਿਰ ਤੁਰੰਤ ਗਾਰਡਰੇਲ ਜੋੜੋ:
ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਅੰਨ੍ਹੇ ਤੌਰ ਤੇ ਨਹੀਂ ਮਾਨਦੇ—ਤੁਸੀਂ ਖੋਜ ਦੇ ਖੇਤਰ ਨੂੰ ਆਕਾਰ ਦੇ ਰਹੇ ਹੋ।
ਇਸਨੂੰ ਚਲਾਓ, ਤੋੜੋ, ਠੀਕ ਕਰੋ। ਜਦੋਂ ਕੁਝ ਫੇਲ ਹੋਵੇ, AI ਨੂੰ ਠੋਸ ਸੰਕੇਤ ਦਿਓ: ਐਰਰ ਸੁਨੇਹੇ, ਮੌਜੂਦਾ ਵਿਵਹਾਰ ਬਨਾਮ ਉਮੀਦ, ਅਤੇ ਸਭ ਤੋਂ ਛੋਟੀ ਦੁਹਰਾਉਣ ਯੋਗ ਕਦਮ। ਪ੍ਰਾਂਪਟ ਠੀਕ ਕਰਨ ਅਤੇ ਛੋਟੀ ਕੋਡ ਸੋਧਾਂ ਵਿਚਕਾਰ ਬਦਲੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਜੋ ਬਦਲਿਆ ਹੈ ਉਸ 'ਤੇ ਕਾਬੂ ਨਾ ਗਵਾਓ।
ਹਲਕਾ “ਫੈਸਲਾ ਲਾਗ” ਰੱਖੋ: ਤੁਸੀਂ ਕੀ ਕੋਸ਼ਿਸ਼ ਕੀਤਾ, ਕਿਉਂ ਦਿਸ਼ਾ ਬਦਲੀ, ਅਤੇ ਕਿਹੜੇ ਟਰੇਡਆਫ ਮਨਾਏ ਗਏ। ਇਹ ਡੈਡ ਐਂਡ ਦੁਹਰਾਵਾਂ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿਚ ਪ੍ਰਾਜੈਕਟ ਹੱਥਾਂ-ਬਦਲਣ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦਾ—even ਜੇ ਸੈਸ਼ਨ ਢਿਲ੍ਹਾ-ਢਾਲੂ ਸੀ।
Vibe coding ਅਤੇ ਰਵਾਇਤੀ ਸਾਫਟਵੇਅਰ ਇੰਜੀਨਿਆਰਿੰਗ ਇੱਕੋ-ਜਿਹੇ ਨਤੀਜੇ ( ਇਕ ਚੱਲਦਾ ਫੀਚਰ, ਡਿਪਲੋਈਡ ਐਪ) ਤਿਆਰ ਕਰ ਸਕਦੇ ਹਨ, ਪਰ ਇਹ ਵੱਖ-ਵੱਖ ਗੱਲਾਂ ਲਈ ਅਨੁਕੂਲ ਹੁੰਦੇ ਹਨ।
Vibe coding ਰਫ਼ਤਾਰ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ: ਇੱਕ ਵਿਚਾਰ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਨਤੀਜਾ ਵੇਖੋ, ਤੇਜ਼ੀ ਨਾਲ ਠੀਕ ਕਰੋ। ਮਕਸਦ ਸਿੱਖਣਾ ਅਤੇ ਗਤੀ ਹੈ। ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਭਰੋਸੇਯੋਗਤਾ ਲਈ ਤਿਆਰ ਹੈ: ਕੰਮ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ, ਸਮੀਖਿਆ, ਟੈਸਟ, ਅਤੇ ਵਕਤ ਦੇ ਨਾਲ ਰੱਖ-ਰੱਖਾਅ ਯਕੀਨੀ ਬਣਾਉਣਾ।
Vibe ਵਰਕਫਲੋ ਵਿੱਚ, “ਸਪੈਸ” ਅਕਸਰ ਇੱਕ ਪ੍ਰਾਂਪਟ ਅਤੇ ਕੁਝ ਉਦਾਹਰਨ ਹੁੰਦੀ ਹੈ: “ਚੈਕਆਉਟ ਸੁਖਦ ਬਣਾਓ,” “ਇੰਜ ਫਿਲਟਰ ਜੋੜੋ,” “ਇਸ ਪੇਜ ਦਾ ਟੋਨ ਮਿਲਾਓ।” ਇਹ ਗੱਲ-ਬਾਤੀ ਅਤੇ ਲਚਕੀਲਾ ਹੁੰਦਾ ਹੈ।
ਇੰਜੀਨਿਆਰਿੰਗ ਆਮਤੌਰ 'ਤੇ ਇਰਾਦੇ ਨੂੰ ਲੋੜਾਂ, ਸਵੀਕਾਰਤਾ ਮਾਪਦੰਡ, ਅਤੇ ਟਿਕਟਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ—ਇਹ ਢਾਂਚਾ ਵਿਸ਼ੇਸ਼ ਕਰਕੇ ਜਦੋਂ ਕਈ ਲੋਕ ਇੱਕੋ ਹੀ ਖੇਤਰ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ ਤਾਂ ਕੋਆਰਡੀਨੇਸ਼ਨ ਅਤੇ ਵੇਰੀਫਿਕੇਸ਼ਨ ਆਸਾਨ ਕਰਦਾ ਹੈ।
Vibe coding ਸਥਾਨਕ ਪ੍ਰਯੋਗਾਂ ਨੂੰ ਉਤਸ਼ਾਹਤ ਕਰਦਾ ਹੈ: ਤੇਜ਼ ਸਕ੍ਰਿਪਟ, ਇਕ-ਵਾਰੀ ਕੰਪੋਨੈਂਟ, ਘੱਟ ਸਰਕਮਨੀ। ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਸਾਂਝੇ ਪੈਟਰਨ ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਵੱਲ ਧੱਕਦਾ ਹੈ ਤਾਂ ਕਿ ਸਿਸਟਮ ਵੱਧਣ ਤੇ ਸੰਗਤ ਰਹੇ।
Vibe coding ਅਕਸਰ “ਇਹ ਰਨ ਕਰਦਾ ਹੈ ਅਤੇ ਠੀਕ ਮਹਿਸੂਸ ਹੁੰਦਾ” 'ਤੇ ਰੁਕਦਾ ਹੈ। ਇੰਜੀਨਿਆਰਿੰਗ ਹੋਰ ਪ੍ਰਸ਼ਨ ਪੁੱਛਦਾ ਹੈ: ਕੀ ਇਹ ਲੋਡ ਹੇਠਾਂ ਟੁੱਟੇਗਾ? ਕੀ ਇਹ ਟੈਸਟੇਬਲ ਹੈ? ਕੀ ਗਲਤੀਆਂ ਸੰਭਾਲਣ ਇੱਕਸਾਰ ਹਨ? ਕੀ ਐਜ ਕੇਸ ਕਵਰ ਕੀਤੇ ਗਏ ਹਨ?
Vibe coding ਆਮ ਤੌਰ 'ਤੇ ਵਿਅਕਤੀਗਤ ਫਲੋ ਲਈ ਢਾਲਿਆ ਜਾਂਦਾ ਹੈ। ਇੰਜੀਨਿਆਰਿੰਗ ਟੀਮਾਂ ਲਈ ਢਾਲਿਆ ਜਾਂਦਾ ਹੈ: ਰਿਵਿਊ ਨਾਰਮਸ, ਡੌਕ, ਅਤੇ ਸਾਂਝੀ “ਡਨ” ਪਰਿਭਾਸ਼ਾ ਤਾਂ ਜੋ ਤਰੱਕੀ ਕਿਸੇ ਇਕ ਵਿਅਕਤੀ 'ਤੇ ਨਿਰਭਰ ਨਾ ਰਹੇ।
Vibe coding ਉਸ ਵੇਲੇ ਚਮਕਦਾ ਹੈ ਜਦੋਂ ਮਕਸਦ ਤੇਜ਼ੀ, ਸਿੱਖਣਾ, ਅਤੇ ਗਤੀ ਹੋਵੇ—ਨ ਕਿ ਦਿਨ ਪਹਿਲਾਂ ਹੀ ਪੂਰੀ ਆਰਕੀਟੈਕਚਰ। ਜੇ ਤੁਸੀਂ AI-ਸਹਾਇਤ ਕੋਡਿੰਗ ਨੂੰ ਤੇਜ਼ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ ਅਤੇ ਦੁਹਰਾਈ ਵਾਸਤੇ ਭਾਗੀਦਾਰ ਵਜੋਂ ਵਰਤ ਰਹੇ ਹੋ, ਤਾਂ ਇਹ ਹੇਠਾਂ ਦਿੱਤੇ ਹਾਲਤਾਂ ਵਿੱਚ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ।
ਜੇ ਤੁਹਾਨੂੰ ਇੱਕ ਡੈਮੋ, ਇੱਕ ਆੰਤਰਿਕ ਟੂਲ, ਜਾਂ ਛੋਟਾ ਫੀਚਰ ਤੇਜ਼ੀ ਨਾਲ ਚਾਹੀਦਾ ਹੈ, vibe coding ਮੁਸ਼ਕਲ-ਹਰ ਕੰਮ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਨਤੀਜਾ ਵਰਣਨ ਕਰਦੇ ਹੋ (“ਕੱਲ ਦਿਨ ਦੀਆਂ ਸਾਈਨਅਪ ਅਤੇ errors ਦਿਖਾਉਂਦਾ ਡੈਸ਼ਬੋਰਡ”) ਅਤੇ ਮਾਡਲ ਪਹਿਲੀ ਵਰਜਨ ਡਰਾਫਟ ਕਰਦਾ ਹੈ, ਫਿਰ ਪ੍ਰਤੀਕ੍ਰਿਆ ਰਾਹੀਂ ਸੁਧਾਰ ਕਰਦੇ ਹੋ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਉਤੇਜਕ ਹੈ ਜਦ ਕੰਮ ਖੁਦ-ਨਿਰਧਾਰਿਤ ਅਤੇ ਕੋਰ ਸਿਸਟਮ ਨੂੰ ਟੁੱਟਣ ਦਾ ਖ਼ਤਰਾ ਘੱਟ ਹੋਵੇ।
ਜਦ ਲੋੜਾਂ ਧੁੰਦਲੀ ਹੁੰਦੀਆਂ ਹਨ, ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਅਕਸਰ ਅਜਿਹੇ ਸੈਨਾਰਿਓਆਂ ਲਈ ਯੋਜਨਾ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਲਗਾ ਦਿੰਦੀ ਹੈ ਜੋ ਕਦੇ ਨਹੀਂ ਆਉਂਦੇ। Vibe coding ਤੁਹਾਨੂੰ ਇੱਕ ਪਤਲਾ, ਕਾਰਜਕ ਰਹਿਣ ਵਾਲਾ ਸਲਾਈਸ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ, ਇਸਨੂੰ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਸਾਹਮਣੇ ਰੱਖੋ, ਅਤੇ ਸਿੱਖੋ ਕਿ ਕਿਹੜੀ ਚੀਜ਼ ਮਹੱਤਵਪੂਰਨ ਹੈ।
ਨਿਰਮਾਤਾ ਮਨੋਭਾਵ ਅਕਸਰ ਬਣਾਉਣ ਰਾਹੀਂ ਪੜ੍ਹਨ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ ਸਿੱਖਦਾ ਹੈ। Vibe coding ਤੁਹਾਨੂੰ ਅਣਜਾਣ ਫਰੇਮਵਰਕ ਵਿੱਚ ਅਟਕਣ ਤੋਂ ਬਚਾਉਂਦਾ: ਸ਼ੁਰੂਆਤੀ ਕੋਡ ਜਨਰੇਟ ਕਰਨਾ, ਫਾਇਲ ਸਟ੍ਰਕਚਰ ਸੁਝਾਉਣਾ, ਅਤੇ ਐਰਰਾਂ ਦੀ ਵਿਆਖਿਆ। ਤੁਸੀਂ ਫਿਕਰੀ ਤੌਰ 'ਤੇ ਕਾਂਸੈਪਟ ਸਿੱਖਦੇ ਹੋ ਪਰ ਸੰਦਰਭ ਦੇ ਨਾਲ, ਸਕ੍ਰੀਨ ਉੱਤੇ ਕੁਝ ਠੋਸ ਹੋ ਕੇ।
ਸਟੇਕਹੋਲਡਰ ਅਬਸਟਰੈਕਟ ਵਰਣਨ ਦੀ ਤੁਲਨਾ ਵਿੱਚ “ਇਸਨੂੰ ਟ੍ਰਾਈ ਕਰੋ” ਨੂੰ ਜ਼ਿਆਦਾ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦੇ ਹਨ। Vibe coding ਕਲਿੱਕ ਕਰਨ ਯੋਗ ਪ੍ਰੋਟੋਟਾਈਪ ਤੱਕ ਪਹੁੰਚਣ ਲਈ ਬੜੀਆ ਹੈ—ਬੁਨਿਆਦੀ ਫਲੋ, ਸਾਦਾ UI, ਸੈਂਪਲ ਡਾਟਾ—ਤਾਕਿ ਉਤਪਾਦ ਵਿਕਾਸ ਗੱਲਬਾਤਾਂ ਵਾਸਤੇ ਵੱਸਤਵਿਕ ਬਣ ਜਾਏਂ।
ਛੋਟੇ ਆਟੋਮੇਸ਼ਨ (ਰਿਪੋਰਟ ਸਕ੍ਰਿਪਟ, ਡੇਟਾ ਕਲੀਨਅਪ ਹੈਲਪਰ, ਸਾਦੇ Slack ਬੋਟ) ਆਦਿ ਉੱਤਮ ਹਨ। ਇਹ ਆਮਤੌਰ 'ਤੇ ਘੱਟ-ਸਰਕਮਨੀ ਵਾਲੇ, ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਟੈਸਟ ਕਰਨ ਯੋਗ, ਅਤੇ ਤੁਰੰਤ ਮੁੱਲ ਦੇਣ ਵਾਲੇ ਹੁੰਦੇ ਹਨ—AI-ਸਹਾਇਤ ਕੋਡਿੰਗ ਇਨ੍ਹਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ ਉਪਯੋਗ ਹੈ।
ਸਾਂਝਾ ਧਾਗਾ: ਜਿੱਥੇ ਥੋੜ੍ਹੀ ਗੰਦੀ ਹੋਣ ਦੀ ਕੀਮਤ ਘੱਟ ਹੋਵੇ, vibe coding ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਤੇਜ਼ ਰਸਤਾ ਦਿੰਦੀ ਹੈ ਕੁਝ ਅਸਲ ਤਿਆਰ ਕਰਨ ਲਈ।
Vibe coding “ਕੀ ਇਹ ਕੰਮ ਕਰ ਸਕਦਾ?” ਦੀ ਖੋਜ ਲਈ ਵਧੀਆ ਹੈ। ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਉਸ ਵੇਲੇ ਜਿੱਤਦੀ ਹੈ ਜਦ ਸਵਾਲ ਬਣ ਜਾਂਦਾ ਹੈ: “ਕੀ ਇਹ ਲਗਾਤਾਰ, ਸੁਰੱਖਿਅਤ ਅਤੇ ਹੋਰਨਾਂ ਲੋਕਾਂ 'ਤੇ ਨਿਰਭਰ ਹੋ ਸਕਦਾ ਹੈ?”
ਜੇ ਫੀਚਰ ਭੁਗਤਾਨ, ਪ੍ਰਮਾਣਿਕਤਾ, ਪਰਮਿਸ਼ਨ, ਜਾਂ ਕਿਸੇ ਵੀ ਸੁਰੱਖਿਆ-ਆਧਾਰਿਤ ਚੀਜ਼ ਨੂੰ ਛੂੰਹਦਾ ਹੈ, ਤਾਂ ਰਫ਼ਤਾਰ ਇੱਕੱਲੀ ਬਾਧਾ ਨਹੀਂ ਹੁੰਦੀ। ਮੁਸ਼ਕਲ ਭਾਗ ਸਹੀ ਹੋਣਾ ਹੈ—ਐਜ ਕੇਸਾਂ, ਹਮਲਾ-ਸਪੱਛੇ, ਤੇ ਓਪਰੇਸ਼ਨਲ ਫੇਲਿਯਰਾਂ ਲਈ।
ਉਹ ਖੇਤਰਾਂ ਵਿੱਚ, ਤੇਜ਼ AI-ਸਹਾਇਤ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਸਕੇਚ ਵਜੋਂ ਕੀਮਤੀ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਸ਼ਿਪਿੰਗ ਲਈ ਧਿਆਨਪੂਰਵਕ ਥਰੈਟ ਮਾਡਲਿੰਗ, ਡਿਫੇਂਸੀਵ ਕੋਡਿੰਗ, ਅਤੇ ਸਮੀਖਿਆ ਜ਼ਰੂਰੀ ਹੈ। ਇਨ੍ਹਾਂ ਖੇਤਰਾਂ ਵਿੱਚ “ਅਕਸਰ ਸਹੀ” ਅਕਸਰ “ਗਲਤ” ਦੇ ਬਰਾਬਰ ਹੋ ਸਕਦਾ ਹੈ।
ਕਠੋਰ ਅਨੁਕੂਲਤਾ ਜਾਂ ਆਡਿਟ ਲੋੜਾਂ ਵਾਲੇ ਸਿਸਟਮ ਟਰੇਸਬਿਲਟੀ ਦੀ ਮੰਗ ਕਰਦੇ ਹਨ: ਕਿਸ ਨੇ ਕੀ ਬਦਲਿਆ, ਕਿਉਂ, ਅਤੇ ਪਰਖਣ ਦਾ ਸਬੂਤ। ਇਸੇ ਤਰ੍ਹਾਂ, ਉਪਟਾਈਮ-ਚਲਾਏ ਸਿਸਟਮ ਮਾਨੀਟਰਿੰਗ, ਰੋਲਬੈਕ ਯੋਜਨਾ, ਸਮਰੱਥਾ ਯੋਜਨਾ, ਅਤੇ ਇਨਸਿਡੈਂਟ ਪਲੇਬੁੱਕ ਦੀ ਲੋੜ ਰੱਖਦੇ ਹਨ।
ਇਹ ਲੋੜਾਂ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਵੱਲ ਧੱਕਦੀਆਂ ਹਨ:
ਜਿਵੇਂ ਹੀ ਕਈ ਲੋਕ ਯੋਗਦਾਨਕ ਰਹਿਣ, ਸਾਂਝੇ ਰੀਤੀ-ਰਿਵਾਜ਼ ਅਤੇ ਸਥਿਰ ਇੰਟਰਫੇਸ ਇੰਨੇ ਮਹੱਤਵਪੂਰਨ ਹੋ ਜਾਂਦੇ ਹਨ ਕਿ ਵਿਅਕਤਿਗਤ ਗਤੀ ਨਾਲੋਂ ਵੱਧ। ਪਰੰਪਰਾਗਤ ਇੰਜੀਨਿਆਰਿੰਗ ਅਭਿਆਸ—API ਠੇਕੇ, ਵਰਜ਼ਨਿੰਗ, ਕੋਡ ਦੀ ਸਮੀਖਿਆ, ਅਤੇ ਸਾਂਝੇ ਨਿਯਮ—ਸੰਯੋਜਨ ਲਾਗਤਾਂ ਘਟਾਉਂਦੇ ਹਨ ਅਤੇ “ਹੈਰਾਨ ਕਰਨ ਵਾਲਾ ਟੂਟ” ਰੋਕਦੇ ਹਨ।
ਜੇ ਉਤਪਾਦ ਸਾਲਾਂ ਤੱਕ ਲਈ ਉਮੀਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਰਖ-ਰਖਾਅ ਕাঁচੀ ਰਫ਼ਤਾਰ ਤੋਂ ਜ਼ਿਆਦਾ ਮਹੱਤਵਪੂਰਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਟੈਸਟ ਜੋ ਵਿਵਹਾਰ ਨੂੰ ਕਵਰ ਕਰਨ (ਸਿਰਫ ਲਾਈਨਾਂ ਨਹੀਂ), ਪੜ੍ਹਨਯੋਗ ਮੋਡੀਊਲ, ਲਗਾਤਾਰ ਨਾਂਕਰਨ, ਅਤੇ ਇੱਕ ਡੇਟਾ ਮਾਡਲ ਜੋ ਤੁਹਾਨੂੰ ਕੋਨੇ ਵਿੱਚ ਫਸਾ ਨਾ ਦੇਵੇ।
ਕੁਝ ਬੱਗ ਐਸੇ ਹੁੰਦੇ ਹਨ ਜੋ ਵੱਖ-ਵੱਖ ਕੋਸ਼ਿਸ਼ਾਂ ਨਾਲ ਨਹੀਂ ਸੁਲਝਦੇ। ਵੰਡੇ ਸਿਸਟਮ, ਜਟਿਲ ਕਾਰੋਬਾਰੀ ਨਿਯਮ, পারਫਾਰਮੈਂਸ ਬੋਤਲ-ਨੇਕ, ਅਤੇ "ਸਿਰਫ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਹੁੰਦਾ" ਇਸ਼ੂ ਆਮ ਤੌਰ 'ਤੇ ਡੀਪ ਡੋਮੇਨ ਸਮਝ ਅਤੇ ਵਿਧਾਨਬੱਧ ਜाँच ਦੀ ਮੰਗ ਕਰਦੇ ਹਨ—ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਅਨੁਸ਼ਾਸਨ।
ਬਾਹਰੋਂ vibe coding ਆਕਸਮਾਤੀ ਲੱਗਦੀ ਹੈ: ਤੁਸੀਂ ਜੋ ਚਾਹੁੰਦੇ ਹੋ ਉਸਨੂੰ ਵਰਣਨ ਕਰੋ, AI ਕੋਡ ਲਿਖੇ, ਅਤੇ ਤੁਸੀਂ ਨੁਡਜ ਕਰਦੇ ਰਹੋ ਜਦ ਤੱਕ ਇਹ ਕੰਮ ਨਾ ਕਰੇ। ਪਰ ਅਸਲ ਫਰਕ ਇਹ ਨਹੀਂ ਕਿ "AI ਵਿੱਚ ਮਹਿਰਤ ਹੈ"—ਇਹ ਹੈ ਸਕੋਪਿੰਗ ਵਿੱਚ ਮਹਿਰਤ: ਇੱਕ ਧੁੰਦਲੇ ਵਿਚਾਰ ਨੂੰ ਇਕ ਬੰਧ ਸmasਸ਼ੇਤ ਸਮੱਸਿਆ ਵਿੱਚ ਬਦਲਣਾ ਜੋ ਮਾਡਲ ਬਿਨਾਂ ਅਨੁਮਾਨ ਲਗਾਏ ਹੱਲ ਕਰ ਸਕੇ।
ਇੱਕ ਮਜ਼ਬੂਤ vibe ਸੈਸ਼ਨ ਇੱਕ ਛੋਟੀ ਸਮੱਸਿਆ ਬਿਆਨ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ “ਡਨ” ਦੀ ਸਪਸ਼ਟ ਪਰਿਭਾਸ਼ਾ। ਉਦਾਹਰਨ: “ਲੀਡਾਂ ਦੇ CSV ਨੂੰ ਈਮੇਲ ਦੁਆਰਾ ਡਿਡੁਪਲੀਕੇਟ ਕਰਕੇ ਸਭ ਤੋਂ ਹਾਲੀਆ ਟਾਈਮਸਟੈਂਪ ਸੰਭਾਲਨਾ” ਹੱਲਯੋਗ ਹੈ। “ਮੇਰੀ ਲੀਡ ਪਾਈਪਲਾਈਨ ਸਾਫ਼ ਕਰੋ” ਅਸਪਸ਼ਟਤਾ ਬੁਲਾਂਦਾ ਹੈ।
ਕੋਡ ਮੰਗਣ ਤੋਂ ਪਹਿਲਾਂ ਸਪਸ਼ਟ ਲਿਖੋ—ਸਫ਼ਦਭਾਸ਼ਾ ਵਿੱਚ—ਕਿ ਸਫਲਤਾ ਕਿਵੇਂ ਦਿਖੇਗੀ, ਤੁਸੀਂ ਕੀ ਅਣਡਠ ਰਹਿਣ ਲਈ ਤਿਆਰ ਹੋ, ਅਤੇ ਕੀ ਨਾਂ ਟੁੱਟਣਾ ਚਾਹੀਦਾ।
ਉਪਯੋਗੀ ਪ੍ਰਾਂਪਟ ਇਕ ਮਿਨੀ-ਸਪੈਸ ਵਾਂਗ ਪੜ੍ਹਦੇ ਹਨ:
ਇਹ AI ਨੂੰ ਉਹ ਅਨੁਮਾਨ ਬਣਾਉਣ ਤੋਂ ਰੋਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਮੰਨਦੇ ਹੀ ਨਹੀਂ।
“ਕੋਡ ਲਿਖੋ” ਦੀ ਥਾਂ ਇਹ ਕੋਸ਼ਿਸ ਕਰੋ: “2–3 ਪਹੁੰਚ ਦਿਓ, ਟਰੇਡਆਫ ਸਮਝਾਓ, ਫਿਰ ਇੱਕ ਦੀ ਸਿਫਾਰਿਸ਼ ਕਰੋ।” ਤੁਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਚੋਣਾਂ ਨੂੰ ਸਾਹਮਣੇ ਲਿਆਊਗੇ (ਤੇਜ਼ ਸਕ੍ਰਿਪਟ ਬਨਾਮ ਦੁਬਾਰਾ ਵਰਤਣ ਯੋਗ ਮੌਡਿਊਲ, ਸਖਤ ਵੈਲਿਡੇਸ਼ਨ ਬਨਾਮ ਨਰਮ ਪਾਰਸਿੰਗ) ਅਤੇ ਸਾਰਾ ਕੰਮ ਮੁੜ ਲਿਖਣ ਤੋਂ ਬਚੋਗੇ।
ਟੈਸਟ, ਉਦਾਹਰਨ ਡਾਟਾ, ਅਤੇ ਫੇਲਿਅਰ ਮੋਡ ਮੰਗੋ। ਜਿਵੇਂ ਪ੍ਰਾਂਪਟ: “ਇਹ ਕਿਸ ਇਨਪੁੱਟ ਨਾਲ ਟੁੱਟੇਗਾ?” ਜਾਂ “ਐਜ ਕੇਸ ਲਈ ਟੈਸਟ ਜੋੜੋ ਅਤੇ ਉਮੀਦ ਕੀਤੀ ਆਉਟਪੁੱਟ ਦਿਖਾਓ” ਆਮ ਤੌਰ 'ਤੇ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਮੁੱਦਿਆਂ ਨੂੰ ਫੜ ਲੈਂਦੇ ਹਨ।
ਹਰ ਪ੍ਰਾਂਪਟ ਨੂੰ ਇੱਕ ਛੋਟੀ ਬਦਲਵਾਰ ਸਮਝੋ ਜਿਸਦਾ ਇਕ ਅਣੂ ਵਰਜਨ ਹੋਵੇ। ਜਦੋਂ ਕੁਝ ਗਲਤ ਹੋਵੇ, ਮੁੜ-ਸ਼ੁਰੂ ਨਾ ਕਰੋ—ਸਪੈਸ ਨੂੰ ਤੰਗ ਕਰੋ, ਇੱਕ ਗੁੰਮਸ਼ੁਦਾ ਪਾਬੰਦੀ ਜੋੜੋ, ਅਤੇ ਦੁਬਾਰਾ ਚਲਾਓ। ਇਹ ਲਹਿਰ “ਵਾਇਬ” ਹੈ, ਪਰ ਕੌਸ਼ਲ ਦਿਸ਼ਾ-ਸਪੱਸ਼ਟਤਾ ਹੈ।
Vibe coding ਤੇਜ਼ੀ ਨਾਲ ਅੱਗੇ ਵਧਦਾ ਹੈ—ਸੋ ਮਕਸਦ “ਪੂਰੀ ਆਰਕੀਟੈਕਚਰ” ਨਹੀਂ, ਬਲਕਿ ਉਹ ਗੰਦਗੀ ਰੋਕਣਾ ਹੈ ਜੋ ਅਗਲਾ ਬਦਲਾਅ ਦੂਣਾ ਮੁਸ਼ਕਿਲ ਬਣਾ ਦੇਵੇ। ਸ਼ੁਰੂ ਵਿੱਚ ਥੋੜ੍ਹੀ ਢਾਂਚਾ ਰੱਖਣਾ ਗਤੀ ਨੂੰ ਉੱਚਾ ਰੱਖਦਾ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਘੁੰਟ-ਫੇੜ ਕਰਨ ਲਈ ਘੱਟ ਸਮਾਂ ਗਵਾਉਂਦੇ ਹੋ।
ਇੱਕ ਪਤਲੀ-ਸਲਾਈਸ ਰਾਹ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰੋ ਜੋ end-to-end ਕੰਮ ਕਰਦੀ ਹੋਵੇ: ਇੱਕ ਯੂਜ਼ਰ ਕਾਰਵਾਈ ਜੋ UI (ਜੇ ਹੋਵੇ), ਲੋਜਿਕ, ਅਤੇ ਸਟੋਰੇਜ/API ਰਾਹੀਂ ਗੁਜ਼ਰਦੀ ਹੈ, ਚਾਹੇ ਇਹ ਬੇਅਨ-ਬੋਨ ਹੋਵੇ। ਇਹ ਇੱਕ ਸਥਿਰ ਰੀੜ੍ਹੀ ਬਨਾਉਂਦੀ ਹੈ ਜਿਸ 'ਤੇ ਤੁਸੀਂ ਫੀਚਰ ਜੋੜ ਸਕਦੇ ਹੋ—ਨ ਕਿ ਅਧ-ਕਾਟੇ ਹਿੱਸੇ ਇਕੱਠੇ ਰੱਖ ਰਹੇ ਹੋ।
ਹਲਕੇ ਗਾਰਡਰੇਲ ਤੁਰੰਤ ਫਾਇਦਾ ਦਿੰਦੇ ਹਨ:
ਇਹ ਭਾਰੀ ਪ੍ਰਕਿਰਿਆ ਨਹੀਂ—ਇਹ ਬੀਮਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਪ੍ਰਯੋਗ ਜਾਰੀ ਰੱਖਣ ਦਿੰਦਾ ਹੈ।
ਕੋਡ ਨੂੰ ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਦੁਬਾਰਾ ਜਨਰੇਟ ਕਰਨ ਯੋਗ ਰੱਖੋ: ਛੋਟੀ ਫੰਕਸ਼ਨ, ਸਪਸ਼ਟ ਨਾਂ, ਅਤੇ ਆਮ ਮੋਡੀਊਲ (ਉਦਾਹਰਨ api/, services/, ui/)। ਜੇ ਤੁਸੀਂ ਇਕ ਫਾਇਲ ਦੇ ਉਦਦੇਸ਼ ਨੂੰ ਇੱਕ ਵਾਕ ਵਿੱਚ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਠੀਕ ਕਰ ਰਹੇ ਹੋ।
ਬੱਸ ਇੰਨੀ ਹੀ ਕਿ ਕੋਈ ਹੋਰ ਤੁਹਾਡੇ ਬਿਨਾਂ ਰਨ ਕਰ ਸਕੇ:
ਲਿੰਕ ਭੇਜਣ ਜਾਂ PR ਖੋਲ੍ਹਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਛੋਟੀ ਚੈੱਕਲਿਸਟ ਚਲਾ ਕਰੋ: ਮਰੇ ਕੋਡ ਨੂੰ ਹਟਾਉ, ਗੁੰਝਲਦਾਰ ਵੈਰੀਏਬਲਾਂ ਦੇ ਨਾਮ ਬਦਲੋ, TODOs ਜੋੜੋ ਜਿੱਥੇ ਤੁਸੀਂ ਜਾਣ-ਬੁਝ ਕੇ ਛੇਤੀ ਕੀਤਾ, ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਪਤਲੀ ਸਲਾਈਸ ਅਜੇ ਵੀ ਕੰਮ ਕਰਦੀ ਹੈ। ਉਹ ਪਾਂਚ ਮਿੰਟ ਅਕਸਰ “ਕੂਲ ਪ੍ਰੋਟੋਟਾਈਪ” ਤੇ “ਉਪਯੋਗ ਸ਼ੁਰੂਆਤ” ਦਾ ਫੇਰ ਕਰ ਦਿੰਦੇ ਹਨ।
Vibe coding ਤੇਜ਼ੀ ਨਾਲ ਚਲਦਾ ਹੈ, ਇਸ ਲਈ ਗੁਣਵੱਤਾ ਹਲਕੀ, ਦੁਹਰਾਏ ਜਾ ਸਕਣ ਵਾਲੀ, ਅਤੇ ਮਿਡ-ਫਲੋ ਵਿੱਚ ਲਾਗੂ ਕਰਨ ਯੋਗ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਲਕਸ਼੍ਯ ਪ੍ਰੋਟੋਟਾਈਪ ਨੂੰ ਬਿਊਰੋਕਰੇਸੀ ਵਿੱਚ ਬਦਲਣਾ ਨਹੀਂ—ਲਕਸ਼੍ਯ ਉਹ ਗਲਤੀਆਂ ਫੜਨਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਘੰਟਿਆਂ ਪਿੱਛੋਂ ਮਹਿੰਗੀਆਂ ਪੈ ਸਕਦੀਆਂ ਹਨ।
ਕਿਸੇ ਸ਼ੈ ਨੂੰ ਭਰੋਸਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਪ੍ਰੋਜੈਕਟ ਇੱਕ ਸਾਫ ਸਥਿਤੀ ਤੋਂ ਚਲਦਾ ਹੈ। ਮਤਲਬ ਹੈ ਤਾਜ਼ਾ ਇੰਸਟਾਲ, ਸਪਸ਼ਟ ਸੈਟਅੱਪ ਕਦਮ, ਅਤੇ ਇੱਕ ਕਮਾਂਡ ਜੋ ਕੰਮ ਕਰਦੀ ਹੈ।
ਜੇ ਤੁਸੀਂ ਆਪਣਾ ਨਤੀਜਾ ਦੁਹਰਾਉਣ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਉਤਪਾਦ ਨਹੀਂ—ਸਿਰਫ਼ ਕਿਸੇ ਖੁਸ਼ਕਿਸਮਤ ਮਸ਼ੀਨ ਉੱਤੇ ਚੱਲਦਾ ਕੁਝ ਹੈ।
ਪੂਰੇ ਕਵਰੇਜ ਨੂੰ ਲਕੜ ਨਾ ਬਣਾਉ। ਉਹ ਟੈਸਟ ਜੋ ਕੋਰ ਨੂੰ ਬਚਾਉਂਦੇ ਹਨ ਉੱਪਰ ਜੋੜੋ:
ਇਹ ਟੈਸਟ AI-ਸਹਾਇਤ ਦੁਹਰਾਈਆਂ ਦੌਰਾਨ ਇੱਕ ਸੁਰੱਖਿਆ ਜਾਲ ਬਣਾਉਂਦੇ ਹਨ, ਜਿੱਥੇ ਇੱਕ ਛੋਟੀ ਰਿਫੈਕਟਰ ਬੇਅਹਿਸਾਬ ਤਰੀਕੇ ਨਾਲ ਵਿਵਹਾਰ ਬਦਲ ਸਕਦੀ ਹੈ।
ਜਨਰੇਟ ਕੀਤਾ ਕੋਡ ਅਸਮਰੱਥ ਹੋ ਸਕਦਾ ਹੈ। ਇਕ ਫਾਰਮੇਟਰ ਅਤੇ ਲਿੰਟਰ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨਯੋਗ ਰੱਖਦੇ ਹਨ ਬਿਨਾਂ ਟੀਮ ਦੀਆਂ ਲੜਾਈਆਂ ਦੇ। ਇਹ ਆਮ ਗਲਤੀਆਂ (ਅਣਉਪਯੋਗ ਵੈਰੀਏਬਲ, ਗਲਤ ਇੰਪੋਰਟ) ਨੂੰ ਵੀ ਰਿਪੋਰਟ ਕਰਦੇ ਹਨ ਪਹਿਲਾਂ ਤੁਸੀਂ ਸ਼ਿਪ ਕਰੋ।
ਸਧੇ ਸਵਾਲ ਪੁੱਛੋ:
ਜਦ AI “ਤੇਜ਼ ਹਲ” ਸੁਝਾਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਵਿਆਪਕ ਐਡਮਿਨ ਅਕਸਸ ਜਾਂ ਡੀਬੱਗ ਆਉਟਪੁੱਟ ਡੰਪ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਹ ਚੈੱਕ ਖਾਸ ਵਰਤੋਂਯੋਗ ਹੈ।
AI ਪਛਾਣਯੋਗ ਸਨਿਪੇਟ ਦਾ ਉਚਾਰਨ ਕਰ ਸਕਦਾ ਹੈ। ਜੇ ਕੁਝ ਲਗਭਗ ਨਕਲ ਵਰਗਾ ਲੱਗੇ (ਖ਼ਾਸ ਕਰਕੇ ਵੱਡੇ ਬਲੌਕ), ਉਸਨੂੰ ਬਦਲੋ ਜਾਂ ਇਹ ਪੱਕਾ ਕਰੋ ਕਿ ਇਹ ਪਰਮਿਸਿਵ ਸਰੋਤ ਤੋਂ ਹੈ। ਜੇ ਸ਼ੱਕ ਹੈ, ਮੂਲ ਰੱਖੋ ਅਤੇ ਦਸਤਾਵੇਜ਼ ਸ਼ਾਮਲ ਕਰੋ।
Vibe coding ਆਮ ਤੌਰ 'ਤੇ ਅਸਧਾਰਣ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ—ਤੇਜ਼ ਪ੍ਰਾਂਪਟ, ਤੇਜ਼ ਨਤੀਜੇ—ਪਰ ਜਦ ਕੋਡ ਅਸਲੀ ਯੂਜ਼ਰਾਂ ਨੂੰ ਛੂੰਹੈ, ਜ਼ਿੰਮੇਵਾਰੀ ਤੁਹਾਡੀ ਹੈ। “AI ਨੇ ਲਿਖਿਆ” ਇਹ ਬਦਲਦਾ ਨਹੀਂ ਕਿ ਸੁਰੱਖਿਆ, ਸ਼ੁੱਧਤਾ, ਕਾਨੂੰਨੀ ਅਨੁਕੂਲਤਾ, ਜਾਂ ਨੁਕਸਾਨ ਲਈ ਕੌਣ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।
ਪ੍ਰਾਂਪਟਾਂ, ਚੈਟ ਇਤਿਹਾਸ, ਅਤੇ ਪੇਸਟ ਕੀਤੇ ਨਮੂਨੇ ਪ੍ਰੋਡਕਸ਼ਨ ਆਰਟੀਫੈਕਟ ਵਾਂਗ ਵਰਤੇ ਜਾਂ ਸਕਦੇ ਹਨ।
ਜਦ مددگار ਕੋਡ ਜਨਰੇਟ ਕਰਦਾ ਹੈ, ਤੁਹਾਨੂੰ ਅਕਸਰ ਪਤਾ ਨਹੀਂ ਹੁੰਦਾ ਕਿ ਇਹ ਕਿਸ ਨਾਲ ਮਿਲਦਾ ਹੈ। ਇਹ ਅਨਿਸ਼ਚਿਤਤਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।
ਜਦ ਤੁਸੀਂ ਕੋਡ ਕੌਪੀ ਕਰਦੇ ਹੋ ਤਾਂ ਸਰੋਤਾਂ ਬਾਰੇ ਸਪੱਸ਼ਟ ਹੋਵੋ (ਡੌਕਸ, GitHub, Stack Overflow)। "ਅਣਜਾਣ ਮੂਲ" ਸਨਿਪੇਟ ਨੂੰ ਬਿਨਾਂ ਸਮੀਖਿਆ ਦੇ ਉਤਪਾਦ ਵਿੱਚ ਨਾ ਰੱਖੋ। ਇੱਕ ਆਮ ਆਦਤ: ਜਦ ਤੁਸੀਂ ਕਿਸੇ ਨੰਦੇ ਤੋਂ ਅਨੁਕੂਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਛੋਟਾ ਟਿੱਪਣੀ ਨਾਲ ਸਰੋਤ ਦਰਜ ਕਰੋ।
AI-ਜਨਰੇਟ ਕੀਤਾ ਲੋਜਿਕ ਮਨੁੱਖੀ ਧਾਰਣਾਂ ਨੂੰ ਕੋਡ ਕਰ ਸਕਦਾ ਹੈ: ਨਾਂ, ਪਤੇ, ਮੁਦਰਾ, ਲਿੰਗ, ਭਾਸ਼ਾ, ਅਪਹੁੰਚਤਾ ਲੋੜ। ਵੱਖ-ਵੱਖ ਇਨਪੁੱਟ ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਨਾਲ ਟੈਸਟ ਕਰੋ—ਖ਼ਾਸ ਕਰਕੇ ਰਾਹਤ ਵਰਗੀਆਂ ਫਲੋਆਂ ਲਈ (ਆਨਬੋਰਡਿੰਗ, ਭੁਗਤਾਨ, ਮੋਡਰੇਸ਼ਨ, ਯੋਗਤਾ)।
Vibe coding ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ ਲਈ ਸ਼ਾਨਦਾਰ ਹੈ, ਪਰ ਪ੍ਰੋਟੋਟਾਈਪ ਇਕਰੂਪ ਤੌਰ 'ਤੇ ਮੁਕੰਮਲ ਲੱਗ ਸਕਦਾ ਹੈ। ਸਟੇਕਹੋਲਡਰਾਂ ਨੂੰ ਦੱਸੋ ਕਿ ਕੀ ਅਸਲ ਹੈ ਅਤੇ ਕੀ ਇੱਕ ਸਥਾਨਕ ਡੈਮੋ ਹੈ: ਸੁਰੱਖਿਆ ਹਾਰਡਨਿੰਗ, ਮਾਨੀਟਰਿੰਗ, ਪਰਫਾਰਮੈਂਸ, ਅਤੇ ਕਾਨੂੰਨੀ ਸਮੀਖਿਆ ਹੋ ਸਕਦੀ ਹੈ ਨਹੀਂ। README ਵਿੱਚ ਇੱਕ ਇਕ-ਪੰਗਤੀ ਲੇਬਲ (“ਡੇਮੋ ਕੁਆਲਿਟੀ”) ਮਹਿੰਗੀਆਂ ਗਲਤਫਹਿਮੀਆਂ ਨੂੰ ਰੋਕ ਸਕਦੀ ਹੈ।
Vibe-coded ਪ੍ਰੋਟੋਟਾਈਪ ਲਾਇਆ-ਪੜਤਾਲ ਲਈ ਵਧੀਆ ਹੈ, ਪਰ ਟੀਮਾਂ ਨੂੰ “ਮੇਰੇ ਲੈਪਟਾਪ 'ਤੇ ਚਲਦਾ” ਤੋਂ ਜ਼ਿਆਦਾ ਚਾਹੀਦਾ ਹੈ। ਮਕਸਦ ਉਹ ਗਤੀ ਬਚਾਉਣਾ ਹੈ ਜੋ ਤੁਸੀਂ ਪ੍ਰਾਪਤ ਕੀਤੀ, ਪਰ ਕੰਮ ਨੂੰ ਪੜ੍ਹਨਯੋਗ, ਟੈਸਟੇਬਲ, ਅਤੇ ਮਲਕੀਅਤਯੋਗ ਬਣਾਉਣਾ ਵੀ।
ਪ੍ਰੋਟੋਟਾਈਪ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪੈਕੇਜ ਕਰੋ ਜਿਵੇਂ ਤੁਸੀਂ ਬੈਟਨ-ਪਾਸ ਕਰ ਰਹੇ ਹੋ, ਇੱਕ ਰਾਜ਼ ਦੀ ਡਬੀ ਨਹੀਂ। ਇਕ ਛੋਟੀ “README for humans” ਲਿਖੋ: ਫੀਚਰ ਕੀ ਕਰਦਾ ਹੈ, ਕਿਵੇਂ ਚਲਾਉਣਾ, ਕੀ ਮੌਕ ਕੀਤਾ ਗਿਆ ਹੈ, ਕਿਹੜੀਆਂ ਚੀਜ਼ਾਂ ਹਾਰਡ-ਕੋਡ ਕੀਤੀਆਂ ਹਨ, ਅਤੇ ਕਿਹੜੇ ਹਿੱਸੇ ਤੇਜ਼ੀ ਨਾਲ ਅਨੁਭਵਸ਼ੀਲ ਹਨ। ਇੱਕ ਛੋਟਾ ਡੈਮੋ ਸਕ੍ਰਿਪਟ (ਕਦਮ + ਉਮੀਦ ਕੀਤੀ ਆਉਟਪੁੱਟ) ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਹੋਰ ਲੋਕ ਮਿੰਟਾਂ ਵਿੱਚ ਵਿਵਹਾਰ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਸਕਣ।
ਜੇ ਤੁਸੀਂ ਪ੍ਰੋਟੋਟਾਈਪ Koder.ai ਤੇ ਬਣਾਇਆ, ਤਾਂ ਪ੍ਰਾਇਕਟ-ਹੈਂਡਆਫ ਫੀਚਰ ਵਰਤੋਂ: ਸਰੋਤ ਕੋਡ ਐਕਸਪੋਰਟ ਕਰੋ, ਮਹੱਤਵਪੂਰਣ ਬਦਲਾਅ ਤੋਂ ਪਹਿਲਾਂ ਸਨੈਪਸ਼ਾਟ ਕੈਪਚਰ ਕਰੋ, ਅਤੇ ਸਧਾਰਨ ਰੋਲਬੈਕ ਪਾਥ ਰੱਖੋ ਤਾਂ ਕਿ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਯੋਗ ਅਣਵਾਪਸੀਯੋਗ ਨਾ ਬਣ ਜਾਣ।
ਤੁਹਾਡੇ ਪ੍ਰਾਂਪਟ ਕ੍ਰਿਆ ਕਰਨ ਯੋਗ ਇਤਿਹਾਸ ਹਨ, ਪਰ ਟਿਕਟਾਂ ਨੂੰ ਸਪਸ਼ਟਤਾ ਦੀ ਲੋੜ ਹੈ। ਪ੍ਰੋਟੋਟਾਈਪ ਦੀ ਮਨਸਾ ਨੂੰ ਇਹ ਚੀਜ਼ਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰੋ:
ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਮੂਲ ਪ੍ਰਾਂਪਟ ਥ੍ਰੈਡ ਹੈ, ਤਾਂ ਟਿਕਟ ਵਿੱਚ ਬੇਹਤਰੀ ਲਈ ਕੁੰਜੀਆਂ ਹਿੱਸਿਆਂ ਨੂੰ ਪੇਸਟ ਕਰੋ—ਪਰ ਇਸਨੂੰ ਸਪੈਸ ਨਾ ਸਮਝੋ।
ਸ਼ੁਰੂਆਤੀ ਪ੍ਰੋਡਕਸ਼ਨਾਈਜ਼ੇਸ਼ਨ ਵਿੱਚ, ਸਮੀਖਿਆਕਰਤਾ ਨੂੰ ਪ੍ਰਾਥਮਿਕਤਾ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ:
ਸਟਾਇਲ ਬਾਅਦ ਵਿੱਚ ਆ ਸਕਦੀ ਹੈ, ਜਦ ਖਤਰੇ ਕਾਬੂ ਵਿੱਚ ਹੋ ਜਾਣ।
“ਡਨ” ਆਮ ਤੌਰ 'ਤੇ ਮਤਲਬ ਹੁੰਦਾ ਹੈ: ਭਰੋਸੇਯੋਗਤਾ ਟਾਰਗੇਟ, ਬੁਨਿਆਦੀ ਮਾਨੀਟਰਿੰਗ/ਅਲਰਟ, ਘੱਟ ਡੌਕ, ਅਤੇ ਸਪਸ਼ਟ on-call/ਮਲਕੀਅਤ ਰਾਹ। ਜੇ ਕਿਸੇ ਦਾ ਮਾਲਕ ਨਹੀਂ, ਤਾਂ ਇਹ ਅਜੇ ਵੀ ਇੱਕ ਪ੍ਰੋਟੋਟਾਈਪ ਹੈ।
ਜਦ ਕੋਰ ਡਿਜ਼ਾਈਨ ਧਾਰਤੀ ਪਰ ਗੰਦੇ-ਚਿੱਟੇ ਹੋ ਤਾਂ ਰਿਫੈਕਟਰ ਕਰੋ। ਜਦ ਪ੍ਰੋਟੋਟਾਈਪ ਦੀ ਸੰਰਚਨਾ ਟੈਸਟਿੰਗ, ਪਰਫਾਰਮੈਂਸ, ਜਾਂ ਸੁਰੱਖਿਆ ਨੂੰ ਅਵਰੋਧਿਤ ਕਰੇ ਤਾਂ ਮੁੜ-ਲਿਖੋ। ਇੱਕ ਸਧਾਰਨ ਨਿਯਮ: ਜੇ ਤੁਸੀਂ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਕੁਝ ਵਾਕਾਂ ਵਿੱਚ ਸਮਝਾ ਨਹੀਂ ਸਕਦੇ, ਤਾਂ ਵੱਧ ਫੀਚਰ ਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਰੋਕੋ ਅਤੇ ਦੁਬਾਰਾ ਡਿਜ਼ਾਈਨ ਕਰੋ।
Vibe coding ਉਸ ਪੀੜ੍ਹੀ ਨਾਲ resonate ਕਰਦਾ ਹੈ ਜਿਸ ਨੇ ਕਰਨ-ਕੇ-ਦਰਮਿਆਨ ਸਿੱਖਿਆ: ਛੋਟੀ ਟਿਊਟੋਰੀਅਲ ਦੇਖੋ, ਤੁਰੰਤ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਅਤੇ ਨਤੀਜੇ ਤੇਜ਼ੀ ਨਾਲ ਸਾਂਝੇ ਕਰੋ। ਜਦ ਇੱਕ ਵਿਚਾਰ ਘੰਟਿਆਂ ਵਿੱਚ ਇੱਕ ਚੱਲਦਾ ਡੈਮੋ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ, “ਮੇਰੇ ਕੋਲ ਇੱਕ ਸੁਝਾਅ ਹੈ” ਅਤੇ “ਮੈਂ ਕੁਝ ਬਣਾਇਆ” ਦੇ ਵਿਚਕਾਰ ਦੀ ਦੂਰੀ ਬਹੁਤ ਘੱਟ ਹੋ ਜਾਂਦੀ ਹੈ—ਅਤੇ ਇਹ ਪਰਿਵਰਤਨ ਕਰਦਾ ਹੈ ਕਿ ਕੌਣ ਬਣਾਉਣ ਲਈ ਹੱਕਦਾਰ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ।
AI-ਸਹਾਇਤ ਟੂਲ ਸ਼ੁਰੂਆਤੀ ਰੁਕਾਵਟਾਂ ਦੂਰ ਕਰ ਦਿੰਦੇ ਹਨ: ਬੋਇਲਰਪਲੇਟ ਸੈੱਟਅੱਪ, ਸਿੰਟੈਕਸ ਡਰ, ਅਤੇ “ਖਾਲੀ ਫਾਇਲ” ਸਮੱਸਿਆ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਮੁਸ਼ਕਲ ਸਮੱਸਿਆਵਾਂ ਗਾਇਬ ਹੋ ਗਈਆਂ, ਪਰ ਸ਼ੁਰੂਆਤਕਾਰ ਨਤੀਜਿਆਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਨ—ਅਜਿਹੇ ਐਪ ਨਾਲ ਜੋ ਚੱਲਦਾ ਹੈ, ਇੱਕ ਫੀਚਰ ਜੋ ਕੰਮ ਕਰਦਾ ਹੈ—ਅਤੇ ਫਿਰ ਰਸਤੇ ਵਿੱਚ ਵਿਸਥਾਰ ਸਿੱਖਦੇ ਹਨ।
Vibe coding ਤੰਗ ਇਟਰੇਸ਼ਨ ਲੂਪਾਂ ਨਾਲ मेल ਖਾਂਦਾ ਹੈ: ਪ੍ਰਾਂਪਟ, ਚਲਾਓ, ਠੀਕ ਕਰੋ, ਦੁਹਰਾਓ। ਤੁਹਾਨੂੰ ਤੁਰੰਤ ਸਿੰਗਨਾਂ ਮਿਲਦੇ ਹਨ—ਕੀ ਇਹ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ, ਕੀ ਇਹ ਉਪਯੋਗੀ ਹੈ, ਕੀ ਇਹ ਗੁੰਝਲਦਾਰ ਹੈ? ਇਹ ਰਫ਼ਤਾਰ ਸਿੱਖਣ ਨੂੰ ਖੇਡ-ਜਿਹਾ ਬਣਾਉਂਦੀ ਹੈ ਅਤੇ ਹਫ਼ਤਿਆਂ ਦੀ ਯੋਜਨਾ ਕਰਨ ਨਾਲੋਂ ਘੱਟ ਸਜ਼ਾ-ਭਰਿਆ ਬਣਾਉਂਦੀ ਹੈ।
ਕਈ ਨਵੇਂ ਨਿਰਮਾਤਾ ਪਹਿਲੇ ਦਿਨ 'ਤੇ “ਪੂਰੀ” ਸਿਸਟਮ ਦਾ ਟੀਚਾ ਨਹੀਂ ਰੱਖਦੇ। ਉਹ ਛੋਟੇ ਟੂਲ ਸ਼ਿਪ ਕਰਕੇ, ਸਾਂਝੇ ਕਰਕੇ, ਅਤੇ ਅਸਲੀ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਆਧਾਰ 'ਤੇ ਦੁਹਰਾਓ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਨ। Vibe coding ਇਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਨੂੰ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਗਤੀ ਲਈ ਢਾਲਿਆ ਗਿਆ ਹੈ: ਤੁਸੀਂ ਇੱਕ ਵਿਚਾਰ ਨੂੰ ਇਕ ਪ੍ਰਯੋਗ ਵਾਂਗ ਟੈਸਟ ਕਰ ਸਕਦੇ ਹੋ ਨਾ ਕਿ ਲੰਬੇ ਬਿਲਡ 'ਤੇ ਕਮੇਟ ਕਰੋ।
ਸ਼ੁਰੂ ਤੋਂ ਹੀ ਇਰਾਦੇ ਨੂੰ ਕਠੋਰ ਨਿਰਦੇਸ਼ਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਸਧੀ ਭਾਸ਼ਾ ਵਿੱਚ ਆਪਣਾ ਇਰਾਦਾ ਵਰਣਨ ਕਰ ਸਕਦੇ ਹੋ, ਟੂਲ ਨਾਲ ਇਸਨੂੰ ਸਰੀp ਕਰਨ, ਅਤੇ ਨਤੀਜੇ ਵੱਲ ਰੁਖ ਕਰ ਸਕਦੇ ਹੋ। ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਲਈ ਇਹ ਸ਼ੁਰੂਆਤੀ ਸੋਚ-ਵਿਚਾਰ ਨਾਲ ਜ਼ਿਆਦਾ ਮਿਲਦਾ-ਜੁਲਦਾ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ।
ਕਾਰੀگری API ਯਾਦ ਕਰਨ ਤੋਂ ਸਵਿੱਚ ਕਰਦੀ ਹੈ: ਹੁਣ ਵਧੀਆ ਫੈਸਲੇ ਲੈਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਅਗਲਾ ਕੀ ਬਣਾਉਣਾ, ਕੀ ਸਧਾਰਨ ਕਰਨਾ, ਕੀ ਮਿਟਾਉਣਾ, ਅਤੇ ਕਦੋਂ ਨਤੀਜਾ 'ਚ “ਠੀਕ ਕਿਫ਼ਾਇਤੀ” ਦਰਜ ਕੀਤਾ ਜਾਵੇ। Vibe coding ਵਿੱਚ, ਸੁਆਦ—ਨਾਲ ਹੀ ਦੁਹਰਾਉਣ ਦੀ ਇੱਛਾ—ਇੱਕ ਅਸਲੀ ਤਕਨੀਕੀ ਫ਼ਾਇਦਾ ਬਣ ਜਾਂਦੀ ਹੈ।
Vibe coding ਖੋਜ ਵਿੱਚ ਚਮਕਦਾ ਹੈ: ਇੱਕ ਧੁੰਦਲਾ ਵਿਚਾਰ ਇਕ ਚੀਜ਼ ਵਿੱਚ ਬਦਲੋ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਕਲਿੱਕ ਕਰ ਸਕਦੇ, ਟੈਸਟ ਕਰ ਸਕਦੇ, ਅਤੇ ਉਤੇ ਪ੍ਰਤੀਕ੍ਰਿਆ ਲੈ ਸਕਦੇ ਹੋ। ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਟਿਕਾਊਪਨ ਵਿੱਚ ਚਮਕਦੀ ਹੈ: ਉਸ ਚੀਜ਼ ਨੂੰ ਭਰੋਸੇਯੋਗ, ਸਮਝਣਯੋਗ, ਅਤੇ ਬਦਲਣ ਯੋਗ ਬਣਾਉਣਾ। ਚਾਲ ਇਹ ਨਹੀ ਕਿ ਇੱਕ ਚੁਣੋ—ਬਲਕਿ ਜਾਂਚਣਾ ਕਿ ਕਦੋਂ ਮੋਡ ਬਦਲਣਾ ਹੈ।
Explore (vibe-first): ਤੇਜ਼ ਪ੍ਰਾਂਪਟ ਨਾਲ ਫੀਚਰ ਦਾ ਖਾਕਾ ਬਣਾਓ, ਗੰਦਲਾ ਕੋਡ ਮਨਜ਼ੂਰ ਕਰੋ, ਅਤੇ ਸਿੱਖਣ ਵਾਸਤੇ ਅਨੁਕੂਲ ਹੋਵੋ। "ਪਾਰਕਿੰਗ ਲੌਟ" ਨੋਟ ਰੱਖੋ ਉਹ ਚੀਜ਼ਾਂ ਜੋ ਤੁਸੀਂ ਜਾਣ-ਬੂਝ ਕੇ ਛੱਡ ਰਹੇ ਹੋ (auth, ਐਜ ਕੇਸ, ਐਰਰ ਹੈਂਡਲਿੰਗ)।
Validate (ਹਕੀਕਤ ਜਾਂਚ): ਐਪ ਚਲਾਓ, ਐਂਗੇਜਮੈਂਟ ਨਾਲ ਖੇਡੋ, ਅਤੇ ਧ੍ਰੁਵ ਕਰੋ ਕਿ ਕੋਰ ਫਲੋ ਕੰਮ ਕਰਦਾ ਹੈ। ਜੇ ਇਹ ਬਦਲਾਅ ਕਾਰਨ ਬੇਕਾਰ ਹੈ, ਤਾਂ ਜਲਦੀ ਰੋਕੋ—ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ vibe ਸਮਾਂ ਬਚਾਉਂਦਾ ਹੈ।
Harden (ਇੰਜੀਨਿਆਰਿੰਗ ਪਾਸ): ਸਾਫ ਮੋਡੀਊਲ ਵਿੱਚ ਰਿਫੈਕਟਰ ਕਰੋ, ਸਭ ਤੋਂ ਕੀਮਤੀ ਵਿਵਹਾਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਟੈਸਟ ਜੋੜੋ, ਅਤੇ ਫੇਲਿਅਰ ਨੂੰ ਸਪਸ਼ਟ ਬਣਾਓ (ਚੰਗੇ ਐਰਰ, ਸੁਰੱਖਿਅਤ ਡਿਫੌਲਟ)। ਫੈਸਲਿਆਂ ਅਤੇ ਟਰੇਡਆਫ ਨੂੰ ਲਿਖੋ ਤਾਂ ਕਿ ਭਵਿੱਖ ਦਾ ਤੁਸੀਂ ਅਨੁਮਾਨ ਨਾ ਕਰੋ।
Maintain (ਟੀਮ-ਫਰੇਂਡਲੀ): ਦਸਤਾਵੇਜ਼ ਬਦਲੋ: ਕਿਵੇਂ ਚਲਾਉਣ, ਕਿਵੇਂ ਡਿਪਲੋਈ ਕਰਨ, ਅਤੇ ਬਿਨਾਂ ਟੁੱਟਣ ਦੇ ਕਿਵੇਂ ਬਦਲਿਆ ਜਾ ਸਕਦਾ।
ਜੇ ਤੁਸੀਂ vibe ਦੀ ਗਤੀ ਬਿਨਾਂ ਗੜਬੜੀ ਦੇ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਡਿਬੱਗਿੰਗ, ਟੈਸਟਿੰਗ, ਅਤੇ ਸੁਰੱਖਿਆ ਸਫਾਈ (ਇਨਪੁੱਟ ਵੈਲਿਡੇਸ਼ਨ, auth ਬਾਊਂਡਰੀ, ਸੀਕਰੇਟ ਹੈਂਡਲਿੰਗ) ਦੇ ਬੁਨਿਆਦੀ ਪਾਠ ਸਿੱਖੋ। ਇਹ ਕਾਫ਼ੀ ਹੈ ਤਾਕਿ ਤੁਸੀਂ ਗਤੀ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹੋ ਅਤੇ ਅਟਕੀ ਹੋਈਆਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚ ਸਕਦੇ ਹੋ।
ਅਗਲੇ ਕਦਮ: ਆਪਣੇ ਪ੍ਰਾਂਪਟਿੰਗ ਵਰਕਫਲੋ ਨੂੰ ਬਿਹਤਰ ਬਣਾਓ ਨਾਲ "How to write better prompts for coding" ਬਲੌਗ ਪੋਸਟ ਅਤੇ ਜੇ ਤੁਸੀਂ ਟੂਲ ਜਾਂ ਯੋਜਨਾਵਾਂ ਦਾ ਅੰਕਲਨ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਕੀਮਤਾਂ (pricing) ਵੇਖੋ।
ਇਹ ਇੱਕ ਇਰਾਦਾ-ਪਹਿਲਾਂ ਤਰੀਕਾ ਹੈ ਸਾਫਟਵੇਅਰ ਬਣਾਉਣ ਦਾ: ਉਹ ਵਿਵਹਾਰ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਜੋ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ, ਇੱਕ ਤੇਜ਼ ਪਹਿਲਾ ਵਰਜਨ ਬਣਾਓ ਜਾਂ ਜਨਰੇਟ ਕਰੋ, ਫਿਰ ਰਨ ਕਰਨ ਦੀ ਨਸਲ ਦੇ ਆਧਾਰ 'ਤੇ ਤੀਬਰ ਲੂਪਾਂ ਵਿੱਚ ਦੁਹਰਾਓ।
ਇੱਕ ਵਧੀਆ vibe ਸੈਸ਼ਨ ਦਾ ਮਤਲਬ 'ਕੋਈ ਨਿਯਮ ਨਹੀਂ' ਨਹੀ, ਬਲਕਿ 'ਤੇਜ਼ ਪ੍ਰਤੀਕ੍ਰਿਆ + ਨਿਯੰਤਰਣ ਰੱਖਣ ਲਈ ਠੀਕ ਜਿਹੀ ਢਾਂਚਾ' ਹੈ।
ਨਹੀਂ—AI ਇਸਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ, ਪਰ ਇਹ ਵਰਕਫਲੋ (ਇੱਕ ਸਲਾਈਸ ਬਣਾਓ, ਟੈਸਟ ਕਰੋ, ਅਤੇ ਠੀਕ ਕਰੋ) ਕਾਪਿਲੌਟਾਂ ਤੋਂ ਕਈ ਸਾਲ ਪਹਿਲਾਂ ਵੀ ਮੌਜੂਦ ਸੀ।
AI ਮੁੱਖ ਰੂਪ ਵਿੱਚ ਵਿਚਾਰਿਆਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀ ਲਾਗਤ ਘਟਾਉਂਦਾ ਹੈ: scaffolding ਲਿਖਣ, импਲੀਮੇਂਟੇਸ਼ਨ ਸੁਝਾਉਣ, ਅਤੇ ਡਿਬੱਗਿੰਗ ਵਿੱਚ ਮਦਦ ਕਰਨ ਵਾਸਤੇ—ਪਰ ਫੈਸਲੇ ਇਨਸਾਨੀ ਹੁੰਦੇ ਹਨ।
ਇੱਕ ਛੋਟਾ, ਟੈਸਟ ਕਰਨ ਯੋਗ ਨਤੀਜਾ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਇੱਕ ਬੈਠਕ ਵਿੱਚ ਮੁਕੰਮਲ ਕਰ ਸਕੋ।
ਉਦਾਹਰਨ: “ਇੱਕ ਪੇਜ ਜਿੱਥੇ ਮੈਂ ਸੁੱਚੀਆਂ ਸ਼ਾਮਿਲ ਕਰ ਸਕਾਂ ਅਤੇ ਰੀਫ੍ਰੈਸ਼ ਤੋਂ ਬਾਅਦ ਵੀ ਉਹ ਸੰਭਾਲੇ ਰਹਿਣ।” ਇਹ ਥਿਨ ਸਲਾਈਸ ਸੱਚੀਆਂ ਪਾਬੰਦੀਆਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਵੱਖ ਕਰ ਦਿੰਦੀ ਹੈ ਬਿਨਾਂ ਵੱਡੇ ਆਰਕੀਟੈਕਚਰ ਦੇ ਵਚਨਬੱਧ ਹੋਣ ਦੇ।
ਇੱਕ ਛੋਟੀ ਮਿਨੀ-ਸਪੈਸ ਲਿਖੋ:
ਫਿਰ ਇਸਨੂੰ ਪ੍ਰਾਂਪਟਾਂ ਲਈ ਅੱਡ੍ਹਿਆਨ ਵਜੋਂ ਵਰਤੋ ਅਤੇ ਨਤੀਜੇ ਨੂੰ ਮਆਪਣ ਲਈ ਵੀ।
ਠੋਸ ਸੰਕੇਤ ਦਿਓ:
ਸ਼ੁਰੂ ਤੋਂ ਸਾਰਿਆਂ ਨੂੰ ਰੀ-ਸਟਾਰਟ ਕਰਨ ਦੀ ਬਜਾਏ ਇਕ-ਇਕ ਪਾਬੰਦੀ ਠੀਕ ਕਰੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਵੇਖ ਸਕੋ ਕੀ ਬਦਲਿਆ ਅਤੇ ਕਿਉਂ।
ਫੈਸਲਾ ਲੈਣ ਦੀ ਲੋਗ ਰੱਖਣ ਨਾਲ ਤੇਜ਼ ਇਟਰੇਸ਼ਨ ਦੁਹਰਾਉਂ ਤੋਂ ਬਚਦਾ ਹੈ।
ਹਲਕਾ ਰੱਖੋ—ਸਿਰਫ਼ ਬੁਲੇਟ ਪੁਆਇੰਟ:
ਇਹ ਹੈਂਡਾਫਫ ਅਤੇ ਬਾਅਦ ਦੀ ਸਾਫ਼-ਸੁਥਰੀ ਕਰਨ ਨੂੰ ਕਾਫ਼ੀ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।
Vibe ਕੋਡਿੰਗ ਰਫਤਾਰ ਅਤੇ ਖੋਜ 'ਤੇ ਧਿਆਨ ਦਿੰਦਾ ਹੈ; ਇੰਜੀਨਿਆਰਿੰਗ ਪੇਸ਼ਗੀਯਤਾ, ਸਹਿਯੋਗ ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਦੀ ਰਖ-ਰਖਾਅ ਲਈ।
ਅਮਲ ਵਿੱਚ ਇਹ ਮਤਲਬ:
ਸਮਰੱਥ ਉਪਯੋਗਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:
ਸਧਾਰਨ ਧਾਰਾ: ਜਿੱਥੇ ਥੋੜ੍ਹਾ ਗੰਦਾ ਹੋਣਾ ਘੱਟ ਕੀਮਤੀ ਹੈ, ਉੱਥੇ vibe coding ਤੇਜ਼ੀ ਅਤੇ ਸਿੱਖਣ ਦੀ ਰਫ਼ਤਾਰ ਦਿੰਦਾ ਹੈ।
ਇਹਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ ਰਵਾਇਤੀ ਇੰਜੀਨਿਆਰਿੰਗ ਜਿਦੀਵਾਂ ਜਿੱਤਦੀ ਹੈ:
Vibe ਕੋਡ ਕੀਮਤੀ ਸਕੈਚ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਸ਼ਿਪ ਕਰਨ ਲਈ ਗਹਿਰਾ ਸਮੀਖਿਆ, ਟੈਸਟ ਅਤੇ ਥਰੈਟ ਮਾਡਲਿੰਗ ਲਾਜ਼ਮੀ ਹੁੰਦੇ ਹਨ।
ਹਲਕਾ, ਦੁਹਰਾਏ ਜਾ ਸਕਣ ਵਾਲੇ ਚੈੱਕ ਜੋ ਰਫ਼ਤਾਰ ਨੁਕਸਾਨ ਨਹੀਂ ਪਹੁੰਚਾਉਂਦੇ:
ਇਹਨਾਂ ਨਾਲ ਤੁਸੀਂ ਪ੍ਰੋਟੋਟਾਈਪ ਨੂੰ ਬਿਨਾਂ ਬੋਝ ਬਣਾਏ ਸੁਤਰਧਾਰ ਰੱਖ ਸਕਦੇ ਹੋ।