ਸਿੱਖੋ ਕਿ AI ਸਧਾਰਨ ਭਾਸ਼ਾ ਵਾਲੀਆਂ ਹੁਕਮਾਂ ਨੂੰ ਕਿਵੇਂ ਸਮਝਦਾ ਹੈ, UX ਫਲੋ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਹੈ, UI ਅਤੇ ਕੋਡ ਜਨਰੇਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਫੀਡਬੈਕ ਨਾਲ ਇਟਰੇਟ ਕਰਕੇ ਕੰਮ ਕਰਦੇ ਫੀਚਰ ਅਤੇ ਸਕਰੀਨਾਂ ਦਿੰਦਾ ਹੈ।
“ਲਿਖਤੀ ਨਿਰਦੇਸ਼” ਉਹ ਸ਼ਬਦ ਹਨ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਵਰਤਦੇ ਹੋ ਇਹ ਵੇਖਾਉਣ ਲਈ ਕਿ ਤੁਸੀਂ ਕੀ ਬਣਵਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ—ਇਸ ਤਰ੍ਹਾਂ ਸੰਭਾਲਿਆ ਗਿਆ ਕਿ ਇੱਕ AI (ਅਤੇ ਇੱਕ ਟੀਮ) ਉਸ 'ਤੇ ਕਾਰਵਾਈ ਕਰ ਸਕੇ।
ਅਮਲ ਵਿੱਚ, ਮਕਸਦ ਪرفੈਕਟ prose ਨਹੀਂ ਹੈ। ਮਕਸਦ ਹੈ ਸਪੱਸ਼ਟ ਇਰਾਦਾ (ਤੁਸੀਂ ਕਿਹੜਾ ਨਤੀਜਾ ਚਾਹੁੰਦੇ ਹੋ) ਅਤੇ ਸਪੱਸ਼ਟ ਸੀਮਾਵਾਂ (ਕੀ ਮਨਜ਼ੂਰ ਹੈ, ਕੀ ਨਹੀਂ), ਤਾਂ ਜੋ ਸਿਸਟਮ ਨੂੰ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਲੋੜ ਨਾ ਪਵੇ।
ਇਹ ਫਾਰਮਲ ਜਾਂ ਗੈਰ-ਫਾਰਮਲ ਹੋ ਸਕਦੇ ਹਨ:
ਦੀਹ ਕੀ ਚਾਬੀ ਹੈ ਕਿ ਪਾਠ ਨਤੀਜਿਆਂ ਅਤੇ ਸੀਮਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਦੋਹਾਂ ਮੌਜੂਦ ਹੁੰਦੀਆਂ ਹਨ, AI ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਸਕਰੀਨਾਂ, ਫਲੋਜ਼ ਅਤੇ ਲਾਗੂ ਕਰਨ ਦੇ ਵੇਰਵੇ ਪ੍ਰਸਤਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ ਬਿਨਾਂ ਕਾਰੋਬਾਰੀ ਨਿਯਮਾਂ ਅਨੁਮਾਨ ਕੀਤੇ।
ਇੱਕ ਵਰਕਿੰਗ ਫੀਚਰ ਇੱਕ ਮੌਕਅਪ ਤੋਂ ਜ਼ਿਆਦਾ ਹੁੰਦਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ:
ਉਦਾਹਰਨ ਲਈ, “ਸੇਵ ਕੀਤੇ ਪਤੇ” ਸਿਰਫ਼ ਇੱਕ ਪੇਜ਼ ਨਹੀਂ—ਇਹ ਸਕਰੀਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਹੈ (ਲਿਸਟ, ਜੋੜੋ/ਸੰਪਾਦਨ), ਨਿਯਮ (ਲਾਜ਼ਮੀ ਫੀਲਡ, ਡਿਫਾਲਟ ਪਤਾ), ਅਤੇ ਵਾਇਰਿੰਗ (API ਕਾਲਾਂ, ਸਟੇਟ ਅਪਡੇਟ)।
ਜ਼ਿਆਦਾਤਰ ਟੀਮ ਇੱਕ ਸਧਾਰਨ ਚੱਕਰ ਵਿੱਚ ਆਉਂਦੀਆਂ ਹਨ:
Describe → generate → review → refine
ਤੁਸੀਂ ਸਪੈਸ ਦਿੰਦੇ ਹੋ, AI UI/UX ਅਤੇ ਲਾਗੂ ਕਰਨ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਤੁਸੀਂ ਸਹੀਤਾ ਅਤੇ ਪਾਸਟ ਲਈ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋ, ਫਿਰ ਤੁਸੀਂ ਨਤੀਜੇ ਨੂੰ ਬਹੁਤਰੇਅ ਤੱਕ ਸੁਧਾਰਦੇ ਹੋ ਜਦ ਤੱਕ ਉਹ ਉਹੀ ਨਹੀਂ ਹੋ ਜਾਂਦਾ ਜੋ ਤੁਸੀਂ ਚਾਹਿੜੇ ਹੋ।
ਜੇ ਤੁਸੀਂ vibe-coding ਪਲੈਟਫਾਰਮ ਵਰਗਾ Koder.ai ਵਰਤਦੇ ਹੋ, ਇਹ ਲੂਪ ਅਕਸਰ ਹੋਰ ਵੀ ਤਗੜਾ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਇੱਕ ਹੀ ਥਾਂ 'ਤੇ ਰਹਿ ਸਕਦੇ ਹੋ: ਚੈਟ ਵਿੱਚ ਫੀਚਰ ਵਰਣਨ ਕਰੋ, ਐਪ ਬਦਲਾਅ ਜਨਰੇਟ ਕਰੋ, ਫਿਰ ਨਿਸ਼ਾਨਾਬੰਦੀ ਵਾਲੇ ਫੋਲੋਅੱਪਸ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ ਇਤਰਾਫ਼ ਕਰੋ (ਅਤੇ ਜਰੂਰਤ ਪੈਣ 'ਤੇ ਰਿਵਰਟ ਕਰੋ)।
AI ਸਕਰੀਨਾਂ ਦਾ ਮਸੌਦਾ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉਣ, ਫਲੋ ਸੁਝਾਉਣ ਅਤੇ ਕੋਡ ਉਤਪਾਦਨ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਮਨੁੱਖ ਫਿਰ ਵੀ:
AI ਨੂੰ ਲਿਖਤ ਤੋਂ ਪਹਿਲਾ (ਅਤੇ ਦੂਸਰੇ) ਡਰਾਫਟ ਵਿੱਚ ਬਦਲਣ ਲਈ ਤੇਜ਼ੀਵਰ ਰਹਿਣ ਵਾਲਾ ਤਰਨ ਤਜੋਰਬਾ ਸਮਝੋ—ਅੰਤਿਮ ਨਤੀਜੇ ਲਈ ਮਨੁੱਖ ਜ਼ਿੰਮੇਵਾਰ ਰਹਿੰਦੇ ਹਨ।
AI ਫਾਰਮੇਟਾਂ ਬਾਰੇ ਲਚਕੀਲਾ ਹੈ, ਪਰ ਸਪੱਸ਼ਟਤਾ ਬਾਰੇ ਨੁਕਕੀ ਹੈ। ਇਹ ਇਕ ਪੈਰਾ, ਬੁਲਟ ਲਿਸਟ, PRD ਖੰਡ, ਜਾਂ ਯੂਜ਼ਰ ਸਟੋਰੀਜ਼ ਦੇ ਸੈੱਟ ਤੋਂ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ—ਜਦ ਤੱਕ ਇਰਾਦਾ ਅਤੇ ਸੀਮਾਵਾਂ ਸਪੱਸ਼ਟ ਹਨ।
ਸਭ ਤੋਂ ਮਦਦਗਾਰ ਸ਼ੁਰੂਆਤ ਅਮੂਮਨ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹੁੰਦੀ ਹੈ:
ਇਹ ਤੱਤ AI ਨੂੰ ਦੱਸਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਕੀ ਬਣਾ ਰਹੇ ਹੋ ਅਤੇ "ਚੰਗਾ" ਕੀ ਹੈ, ਜਿਸ ਨਾਲ ਬੈਕ-ਅੰਡ-ਫੋਰਥ ਘੱਟ ਹੁੰਦਾ ਹੈ।
ਜਦੋਂ ਲੋੜਾਂ ਗਾਇਬ ਹੁੰਦੀਆਂ ਹਨ, AI ਡਿੱਫਾਲਟ ਨਾਲ ਖਾਲੀ ਥਾਵਾਂ ਭਰ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਹਾਡੇ ਕਾਰੋਬਾਰੀ ਨਿਯਮਾਂ ਨਾਲ ਮਿਲ ਸਕਦੇ ਨਹੀਂ। ਸ਼ਾਮਿਲ ਕਰੋ:
ਅਸਪਸ਼ਟ: “ਇੱਕ ਚੈਕੇਆਉਟ ਸਕਰੀਨ ਜੋੜੋ ਅਤੇ ਉਸਨੂੰ ਸਧਾਰਨ ਬਣਾਓ।”
ਸਪਸ਼ਟ: “ਲੌਗਡ-ਇਨ ਯੂਜ਼ਰਾਂ ਲਈ ਇੱਕ ਚੈਕੇਆਉਟ ਫਲੋ ਜੜੋ। ਕਦਮ: Address → Shipping → Payment → Review. ਕਾਰਡ + Apple Pay ਸਮਰਥਨ. ਪ੍ਰਤੀ ਯੂਜ਼ਰ 3 ਪਤੇ ਸੇਵ ਕਰੋ. ਭੁਗਤਾਨ ਤੋਂ ਪਹਿਲਾਂ ਟੈਕਸ ਅਤੇ ਸ਼ਿਪਿੰਗ ਦਿਖਾਓ. ਜੇ ਭੁਗਤਾਨ ਫੇਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਕਾਰਟ ਰੱਖੋ ਅਤੇ ਰੀਟ੍ਰਾਈ ਵਿਕਲਪ ਦਿਖਾਓ. ਸਫਲਤਾ = ਆਰਡਰ ਬਣਿਆ, ਰਸੀਦ ਈਮੇਲ ਹੋਈ, ਅਤੇ ਇਨਵੈਂਟਰੀ ਘਟਾਈ ਗਈ।”
ਸਪਸ਼ਟ ਇੰਪੁੱਟ AI ਨੂੰ ਐਸੇ ਸਕਰੀਨਾਂ, ਕਾਪੀ, ਵੈਧਤਾ ਅਤੇ ਲੌਜਿਕ ਤਿਆਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ ਜੋ ਅਸਲ ਪਾਬੰਦੀਆਂ ਨਾਲ ਮਿਲਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਘੱਟ ਗਲਤ ਅਨੁਮਾਨ, ਘੱਟ ਰੀ-ਡਿਜ਼ਾਈਨ चੱਕਰ, ਅਤੇ ਪਹਿਲੇ ਡਰਾਫਟ ਤੋਂ ਕੰਮ ਕਰਨ ਯੋਗ ਨਤੀਜੇ ਤੱਕ ਤੇਜ਼ ਰਾਹ ਮਿਲਦਾ ਹੈ।
AI ਸਕਰੀਨਾਂ ਜਾਂ ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਸ ਨੂੰ ਇਹ ਸਮਝਣਾ ਪੈਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਮਤਲਬ ਰੱਖਦੇ ਹੋ, ਨਾ ਕਿ ਸਿਰਫ਼ ਕੀ ਲਿਖਿਆ ਹੈ। ਇਹ ਕਦਮ ਮੂਲ ਰੂਪ ਵਿੱਚ ਤੁਹਾਡੇ ਸਪੈਸ ਨੂੰ ਇੱਕ ਪ੍ਰੋਡਕਟ ਮੈਨੇਜਰ ਦੀ ਤਰ੍ਹਾਂ “ਪੜ੍ਹਨਾ” ਹੈ: ਲਕੜੀ, ਸ਼ਾਮਲ ਲੋਕ, ਅਤੇ ਉਹ ਨਿਯਮ ਜੋ ਫੀਚਰ ਨੂੰ ਸਹੀ ਬਣਾਉਂਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਨੂੰ ਨਿਕਲਣਾ।
ਅਧਿਕਤਮ ਸਪੈਸ ਕੁਝ ਮੁੜ-ਆਉਣ ਵਾਲੇ ਨਿਰਮਾਣ ਬਲਾਕ ਰੱਖਦੇ ਹਨ:
ਜਦੋਂ ਇਹ ਸਪਸ਼ਟ ਹੁੰਦੇ ਹਨ, AI ਪਾਠ ਨੂੰ ਇੱਕ ਢਾਂਚਾਮਾਨ ਸਮਝ ਵਿੱਚ ਢਾਲ ਸਕਦਾ ਹੈ ਜੋ ਬਾਅਦ ਵਾਲੇ ਕਦਮ ਸਕਰੀਨਾਂ, ਡੇਟਾ, ਅਤੇ ਲੌਜਿਕ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹਨ।
AI ਆਮ ਉਤਪਾਦ ਨਮੂਨੇ ਪਛਾਣਦਾ ਹੈ ਅਤੇ ਰੋਜ਼ਾਨਾ ਬੋਲਚਾਲ ਦੇ ਵਾਕਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਯੋਗ ਅਵਯਵਾਂ ਵਿੱਚ ਮੈਪ ਕਰ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਣ:
ਇਹ ਮੈਪਿੰਗ ਲਾਭਦਾਇਕ ਹੈ ਕਿਉਂਕਿ ਇਹ ਅਸਪਸ਼ਟ ਨਾਉਂ ਨੂੰ ਢਾਂਚੇਵੰਦ ਐਲੀਮੈਂਟਸ ਵਿੱਚ ਬਦਲ ਦੇਂਦੀ ਹੈ ਜੋ ਡਿਜ਼ਾਈਨਰ ਅਤੇ ਇੰਜੀਨੀਅਰ ਵਰਤਦੇ ਹਨ।
ਚੰਗੇ ਸਪੈਸ ਵੀ ਖਾਲੀਆਂ ਛੱਡ ਦੇਂਦੇ ਹਨ। AI ਕੀਮੀਅਤ ਵਸਤਾਂ ਨੂੰ ਨੋਟ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਸਪੱਸ਼ਟੀਕਰਨ ਸਵਾਲ ਸੁਝਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ:
ਕਈ ਵਾਰੀ ਤੁਸੀਂ ਜਵਾਬਾਂ ਤੋਂ ਬਿਨਾਂ ਅੱਗੇ ਵਧਣਾ ਚਾਹੁੰਦੇ ਹੋ। AI ਵਾਜਿਬ ਡੀਫਾਲਟ ਚੁਣ ਸਕਦਾ ਹੈ (ਉਦਾਹਰਣ: ਸਟੈਂਡਰਡ ਪਾਸਵਰਡ ਨਿਯਮ), ਪਰ ਧਾਰਨਾਵਾਂ ਨੂੰ ਸਮੀਖਿਆ ਲਈ ਸੂਚੀਬੱਧ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਚਾਬੀ ਹੈ ਦਿੱਖ: ਧਾਰਨਾਵਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖਿਆ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਮਨੁੱਖ ਉਹਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਜਾਂ ਠੀਕ ਕਰ ਸਕੇ।
ਜਦੋਂ ਇਰਾਦਾ ਸਪਸ਼ਟ ਹੋ ਜਾਵੇ, ਅਗਲਾ ਕਦਮ ਲਿਖਤੀ ਸਪੈਸ ਨੂੰ ਉਸ ਚੀਜ਼ ਵਿੱਚ ਬਦਲਣਾ ਹੈ ਜੋ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਬਣਾਉ ਸਕਦੇ ਹੋ: ਇੱਕ ਫੀਚਰ ਪਲਾਨ। ਇਸ ਵੇਲੇ ਕੋਡ ਨਹੀਂ—ਤੁਸੀਂ ਢਾਂਚਾ ਚਾਹੁੰਦੇ ਹੋ।
ਇੱਕ ਚੰਗਾ ਪਲਾਨ ਵਾਕਾਂਸ਼ਾਂ ਨੂੰ ਸਕਰੀਨਾਂ, ਨੈਵੀਗੇਸ਼ਨ, ਅਤੇ ਯੂਜ਼ਰ ਯਾਤਰਾਵਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਕੇ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ।
ਉਦਾਹਰਣ: “ਯੂਜ਼ਰ ਆਈਟਮਾਂ ਨੂੰ ਵਿਸ਼ਲਿਸਟ ਵਿੱਚ ਸੇਵ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਵੇਖ ਸਕਦੇ ਹਨ” ਆਮ ਤੌਰ 'ਤੇ ਇਨ੍ਹਾਂ ਦੀ ਨਿਸ਼ਾਨੀ ਹੁੰਦੀ ਹੈ: (1) ਪ੍ਰੋਡਕਟ ਡੀਟੇਲ ਇੰਟਰੇਕਸ਼ਨ, (2) ਵਿਸ਼ਲਿਸਟ ਸਕਰੀਨ, ਅਤੇ (3) ਮੇਨ ਨੇਵ ਤੋਂ ਪਹੁੰਚ ਦਾ ਤਰੀਕਾ।
AI ਨੂੰ ਪੁੱਛੋ ਕਿ ਸਕਰੀਨਾਂ ਦੀ ਸੂਚੀ ਦੱਸੀ ਜਾਵੇ ਅਤੇ ਫਿਰ “ਹੈਪੀ ਪਾਥ” ਯਾਤਰਾ ਦਾ ਵਰਣਨ ਕਰੋ, ਨਾਲ ਹੀ ਕੁਝ ਆਮ ਡੀਟੂਰਜ਼ (ਲੌਗਡ-ਆਊਟ, ਆਈਟਮ ਹਟਿਆ, ਖਾਲੀ ਲਿਸਟ)।
ਅਗਲਾ, AI ਨੂੰ ਕਹੋ ਕਿ ਫੀਚਰ ਨੂੰ ਟਾਸਕਾਂ ਵਿੱਚ ਵੰਡੇ ਜੋ ਟੀਮ ਸਮਝ ਸਕੇ:
ਇਹ ਵੀ ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ ਅਸਪਸ਼ਟ ਲੋੜਾਂ ਸਾਹਮਣੇ ਆਉਂਦੀਆਂ ਹਨ। ਜੇ ਸਪੈਸ ਨਹੀਂ ਦੱਸਦਾ ਕਿ ਯੂਜ਼ਰ ਦੋ ਵਾਰ ਇੱਕੋ ਆਈਟਮ ਸੇਵ ਕਰੇ ਤਾਂ ਪਲਾਨ ਉਸ ਸਵਾਲ ਨੂੰ ਉੱਠਾਉਣਾ ਚਾਹੀਦਾ ਹੈ।
ਐਕਸੈਪਟੈਂਸ ਕ੍ਰਾਈਟੇਰੀਆ ਸਧੀ ਭਾਸ਼ਾ ਵਿੱਚ ਰੱਖੋ। ਉਦਾਹਰਣ:
AI ਨੂੰ ਪੁੱਛੋ ਕਿ ਆਈਟਮਾਂ ਨੂੰ must-have ਅਤੇ nice-to-have ਲੇਬਲ ਕਰੇ (ਉਦਾਹਰਣ: “ਵਿਸ਼ਲਿਸਟ ਸਾਂਝਾ ਕਰਨ ਦੀ ਸੁਵਿਧਾ nice-to-have ਹੋ ਸਕਦੀ ਹੈ”)। ਇਸ ਨਾਲ ਪਲਾਨ ਇੱਕੋ-ਇਕ ਅੰਤਰ ਵਿੱਚ ਵਧਦਾ ਨਹੀਂ।
ਫੀਚਰ ਪਲਾਨ ਹੋਣ 'ਤੇ, AI ਲਿਖਤ ਨੂੰ ਇਕ ਨਿਰਧਾਰਤ "ਸਕਰੀਨ ਨਕਸ਼ਾ" ਅਤੇ early UI ਡਰਾਫਟ ਵਿੱਚ ਬਦਲਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਮਕਸਦ ਪਹਿਲੇ ਹੀ ਕੋਸ਼ਿਸ਼ 'ਤੇ ਪਿਕਸਲ-ਪੱਖੀ ਡਿਜ਼ਾਇਨ ਨਹੀਂ—ਇਹ ਸਾਂਝਾ ਕੀਤਾ ਜਾ ਸਕਣ ਵਾਲਾ, ਜਾਂਚਯੋਗ ਮਾਡਲ ਹੈ ਕਿ ਯੂਜ਼ਰ ਕੀ ਦੇਖਣਗੇ ਅਤੇ ਕੀ ਕਰਨਗੇ।
ਹੈਪੀ ਪਾਥ ਨੂੰ ਇੱਕ ਛੋਟੀ ਕਹਾਣੀ ਵਜੋਂ ਦਰਸਾਉ ਕੇ ਸ਼ੁਰੂ ਕਰੋ: ਯੂਜ਼ਰ ਕੀ ਚਾਹੁੰਦਾ ਹੈ, ਉਹ ਕਿੱਥੋਂ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਕੀ ਟੈਪ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਫਲਤਾ ਕਿਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਂਦੀ ਹੈ। ਇੱਥੋਂੋਂ AI ਘੱਟੋ-ਘੱਟ ਸਕਰੀਨਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰ ਸਕਦਾ ਹੈ (ਅਤੇ ਹਰ ਇਕ 'ਤੇ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ)।
ਫਿਰ ਆਮ ਬਦਲਾਂ ਲਈ ਪੁੱਛੋ: “ਜੇ ਉਹ ਲੌਗਡ-ਇਨ ਨਹੀਂ ਹਨ?”, “ਜੇ ਨਤੀਜੇ ਨਹੀਂ ਹਨ?”, “ਜੇ ਉਹ ਅੱਧੇ ਰਸਤੇ ਛੱਡ ਦੇਂਦੇ ਹਨ?”। ਇਸ ਤਰ੍ਹਾਂ ਤੁਸੀਂ UI ਨਹੀਂ ਬਣਾਓਗੇ ਜੋ ਸਿਰਫ ਡੈਮੋ ਵਿੱਚ ਹੀ ਚਲੇ।
ਜੇ ਤੁਹਾਡੀ ਸਪੈਸ ਲੇਆਊਟ ਸੰਕੇਤਾਂ (ਉਦਾਹਰਣ, “header with search, results list with filters, primary CTA at the bottom”) ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ, ਤਾਂ AI ਇੱਕ ਸੰਰਚਿਤ ਡਰਾਫਟ ਦਿਆਂ ਸਕਦਾ ਹੈ ਜਿਵੇਂ:
ਸਰੇਸ਼্ঠ ਪ੍ਰਾਂਪਟਾਂ ਵਿੱਚ ਸਮੱਗਰੀ ਦੀ ਤਰਜੀਹਾਂ (“ਦਰੇਆਨਾਮ ਅਤੇ ਉਪਲਬਧਤਾ ਸਬ ਤੋਂ ਉਪਰ ਦਿਖਾਓ”), ਇੰਟਰੈਕਸ਼ਨ ਨਿਯਮ (“ਫਿਲਟਰ ਸੈਸ਼ਨ ਭਰ ਟਿਕੇ ਰਹਿੰਦੇ ਹਨ”), ਅਤੇ ਸੀਮਾਵਾਂ (“ਮੋਬਾਈਲ-ਫਰਸਟ; ਇੱਕ ਅੰਗੂਲ਼ੇ ਨਾਲ ਰੀਚ ਕਰੋ”) ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।
ਇੱਕ ਵਰਕਿੰਗ ਪ੍ਰੋਡਕਟ ਨੂੰ “ਸਧਾਰਨ” ਸਕਰੀਨ ਤੋਂ ਜ਼ਿਆਦਾ ਚੀਜ਼ਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। AI ਨੂੰ ਹਰ ਅਵਸਥਾ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਕਹੋ ਜੋ ਤੁਸੀਂ ਲਾਗੂ ਕਰੋਗੇ:
ਇਹ ਸਟੇਟ ਫੈਸਲੇ ਵਿਕਾਸ ਪ੍ਰਯਾਸ ਅਤੇ ਯੂਜ਼ਰ ਭਰੋਸੇ 'ਤੇ ਸਿੱਧਾ ਅਸਰ ਪਾਉਂਦੇ ਹਨ।
AI ਦੁਹਰਾਏ ਜਾ ਸਕਣ ਵਾਲੇ ਕੰਪੋਨੈਂਟ ਅਤੇ ਨਿਯਮ ਪ੍ਰਸਤਾਵਿਤ ਕਰਕੇ ਸਥਿਰਤਾ ਬਣਾਈ ਰੱਖਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ: ਟਾਈਪ ਸਕੇਲ, ਸਪੇਸਿੰਗ ਟੋਕਨ, ਬਟਨ ਸਟਾਇਲ, ਅਤੇ ਫਾਰਮ ਪੈਟਰਨ।
ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਕੰਪੋਨੈਂਟ ਹਨ, ਤਾਂ ਆਪਣੀਆਂ ਅੰਦਰੂਨੀ ਹਦਾਇਤਾਂ (ਮਿਸਾਲ ਲਈ /design-system) ਨੋਟ ਕਰਵਾਓ ਅਤੇ AI ਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਣ ਲਈ ਕਹੋ ਤਾਂ ਕਿ ਨਵੇਂ ਪੈਟਰਨ ਬਣਨ ਤੋਂ ਬਚਿਆ ਜਾ ਸਕੇ।
ਅਗਲਾ, “ਐਪ ਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ” ਨੂੰ ਇਹ ਵਿੱਚ ਬਦਲੋ ਕਿ ਐਪ ਕੀ ਸਟੋਰ ਕਰੇਗਾ ਅਤੇ ਕੀ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਲਿਖਤੀ ਸਪੈਸ ਇੱਕ ਸਪਸ਼ਟ ਡੇਟਾ ਮਾਡਲ ਅਤੇ ਬਿਜ਼ਨਸ ਨਿਯਮਾਂ ਵਿੱਚ ਬਦਲਦੀ ਹੈ।
AI ਪਹਿਲਾਂ ਪਾਠ ਵਿੱਚੋਂ “ਨਾਉਂ” ਖਿੱਚ ਕੇ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਐਂਟਿਟੀ ਵਜੋਂ ਵਰਤ ਕੇ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਣ ਵਜੋਂ, “ਯੂਜ਼ਰ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉ ਸਕਦੇ ਹਨ ਅਤੇ ਟਾਸ্ক ਜੋੜ ਸਕਦੇ ਹਨ, ਅਤੇ ਮੈਨੇਜਰ ਟਾਈਮ ਐਂਟ੍ਰੀਆਂ ਮਨਜ਼ੂਰ ਕਰਦੇ ਹਨ” ਇਸ ਤੋਂ ਐਂਟਿਟੀ ਬਣ ਸਕਦੀਆਂ ਹਨ: User, Project, Task, ਅਤੇ TimeEntry।
ਹਰ ਐਂਟਿਟੀ ਲਈ, AI ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਫੀਲਡ ਸੁਝਾਏਗਾ (ਅਤੇ ਜੋ ਘਟ ਰਹੇ ਹਨ ਉਹਨਾਂ ਨੂੰ ਨੋਟ ਕਰੇਗਾ):
ਇਹ IMPLIED ਏਜ-ਕੇਸ ਵੀ ਕਹਿ ਸਕਦਾ ਹੈ, ਜਿਵੇਂ “ਹਰ ਖਾਤੇ ਲਈ ਇੱਕ ਹੀ active subscription” (ਯੂਨੀਕਨੈਸ) ਜਾਂ “Order total line items ਦੇ ਜੋੜ ਦੇ ਬਰਾਬਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ” (ਕੈਲਕ्युਲੇਟਿਡ ਵੈਧਤਾ)।
ਚੰਗਾ ਆਉਟਪੁੱਟ ਨਿਯਮ ਪठनਯੋਗ ਰੱਖਦਾ ਹੈ, ਨਾ ਕਿ ਕੋਡ ਵਿੱਚ ਛੁਪਾਇਆ। ਉਦਾਹਰਣ:
ਅਖੀਰਕਾਰ, ਨਕਲ ਕਰੋ ਕਿ ਰਿਕਾਰਡ ਸਮੇਂ ਦੇ ਨਾਲ ਕਿਵੇਂ ਬਦਲਦੇ ਹਨ: ਬਣਾਉ, ਅਪਡੇਟ, ਮਿਟਾਓ, ਅਤੇ ਡਿਲੀਟ ਦੀ ਥਾਂ ਕੀ ਕਰਨਾ (soft delete)। AI ਆਡੀਟ ਟ੍ਰੇਲ (ਕੌਣ ਕੀ ਬਦਲਿਆ, ਕਦੋਂ) ਅਤੇ ਇਤਿਹਾਸ/ਵਰਜ਼ਨਿੰਗ ਸੁਝਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਸਪੈਸ ਟਰੇਸਬਿਲਟੀ ਦੀ ਲੋੜ ਦਿਖਾਵੇ।
ਹੁਣ ਤੁਸੀਂ “ਪਹਿਲਾ ਵਰਕਿੰਗ ਡਰਾਫਟ” ਕੋਡ ਜਨਰੇਟ ਕਰ ਸਕਦੇ ਹੋ: UI ਜਿਸ 'ਤੇ ਲੋਕ ਕਲਿੱਕ ਕਰਦੇ ਹਨ, ਅਤੇ ਲੌਜਿਕ ਜੋ ਇਸਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ।
ਜੇ ਤੁਸੀਂ Koder.ai ਵਰਤ ਰਹੇ ਹੋ, ਇਹ ਆਮ ਤੌਰ 'ਤੇ مطلب ਹੈ ਕਿ ਪਲੈਟਫਾਰਮ ਤੁਹਾਡੇ ਗੱਲਬਾਤ-ਚੱਲੇ ਸਪੈਸ ਤੋਂ ਇੱਕ ਸੰਰਚਿਤ ਫੁੱਲ-ਸਟੈਕ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ (ਵੈੱਬ, ਬੈਕਐਂਡ, ਡੇਟਾਬੇਸ) ਜਨਰੇਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਪਾਰੰਪਰਿਕ ਵਰਕਫਲੋ ਵਿੱਚ ਜਾਰੀ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਸੋর্স ਕੋਡ ਨਿਕਾਸ ਕਰਨ ਦਾ ਵਿਕਲਪ ਦਿੰਦਾ ਹੈ।
“Create Project” ਸਕਰੀਨ ਵਰਗੇ ਸਪੈਸ ਤੋਂ, AI ਇਹ scaffold ਕਰ ਸਕਦਾ ਹੈ:
ਇਹ ਦੁਹਰਾਉਣਯੋਗ ਬਿਲਡਿੰਗ ਬਲਾਕ ਵੀ ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ (ਉਦਾਹਰਣ, ਇੱਕ <ProjectForm /> ਜੋ create ਅਤੇ edit ਦੋਹਾਂ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ), ਤਾਂ ਜੋ ਕੋਡ ਸਥਿਰ ਰਹੇ।
ਸਰਵਰ ਪਾਸੇ, AI ਫੀਚਰ ਲਈ ਬੁਨਿਆਦੀ “ਕਾਂਟ੍ਰੈਕਟ” ਡਰਾਫਟ ਕਰ ਸਕਦਾ ਹੈ:
ਚਾਬੀ ਇਹ ਹੈ ਕਿ ਬੈਕਐਂਡ ਲੌਜਿਕ ਸਪੈਸ ਦੇ ਨਿਯਮਾਂ ਨਾਲ ਜੁੜੀ ਹੋਵੇ (“ਸਿਰਫ admins visibility ਨੂੰ private ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਨ”) ਨਾ ਕਿ ਸਿਰਫ UI ਤੋਂ ਭੇਜੇ ਗਏ ਡੇਟਾ ਨੂੰ ਸੇਵ ਕਰ ਦੇਵੇ।
AI UI ਨੂੰ ਤੁਹਾਡੇ API ਕਲਾਇੰਟ (fetch/Axios/React Query ਆਦਿ) ਨਾਲ ਜੋੜ ਸਕਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਕੈਸ਼ਿੰਗ ਅਤੇ ਰੀਟ੍ਰਾਈਜ਼ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ ਜਿੱਥੇ ਲੋੜ। ਇਹ ਫੀਲਡ-ਲੈਵਲ ਏਰਰ ਹੈਂਡਲਿੰਗ ਵੀ ਜਨਰੇਟ ਕਰੇਗਾ: ਵੈਧਤਾ ਦੀਆਂ ਗਲਤੀਆਂ ਲਈ ਖੇਤਰ-ਵਿਸ਼ੇਸ਼ ਸੁਨੇਹੇ ਅਤੇ ਨੈਟਵਰਕ ਫੇਲਚੁੱਕਣ ਲਈ ਸਪੱਸ਼ਟ ਫਾਲਬੈਕ।
// Example: submit handler with loading + error state
async function onSubmit(values) {
setStatus({ loading: true, error: null });
try {
await api.post('/api/projects', values);
router.push('/projects');
} catch (e) {
setStatus({ loading: false, error: 'Could not create project. Try again.' });
}
}
ਜਨਰੇਟ ਕੀਤਾ ਗਿਆ ਕੋਡ ਉਸ ਵੇਲੇ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਉਹ ਤੁਹਾਡੇ convections ਦੇ ਅਨੁਸਾਰ ਹੋਵੇ: ਸਾਫ਼ ਨਾਂ-ਕਰਨਾ, ਪੇਦਾ ਹੋਏ ਫੋਲਡਰ ਸਟ੍ਰਕਚਰ, ਛੋਟੇ ਫੰਕਸ਼ਨ, ਅਤੇ ਸਾਂਝੇ ਉਪਯੋਗੀ (ਵੈਲਿਡੇਟਰ, API ਕਲਾਇੰਟ, ਪਰਮਿਸ਼ਨ ਹੈਲਪਰ)।
ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਕੋਡ ਸਟਾਈਲ ਗਾਈਡ ਜਾਂ ਪਸੰਦੀਦਾ ਪੈਟਰਨ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਸਪੈਸ ਵਿੱਚ ਸਪਸ਼ਟ ਕਰੋ ਅਤੇ ਅੰਦਰੂਨੀ ਦਸਤਾਵੇਜ਼ਾਂ (ਉਦਾਹਰਣ ਲਈ /engineering/frontend ਜਾਂ /engineering/api-guidelines) ਨੂੰ ਦਰਸਾਓ।
ਇਸ ਪਾਇੰਟ ਤੱਕ ਤੁਹਾਡੇ ਕੋਲ ਸਕਰੀਨਾਂ, UI ਕੰਪੋਨੈਂਟ, ਡੇਟਾ ਆਕਾਰ, ਅਤੇ ਬਿਜ਼ਨਸ ਨਿਯਮ ਹਨ। "ਵਾਇਰਿੰਗ" ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ ਉਹ ਹਿੱਸੇ ਇਕ-दੂਜੇ ਨਾਲ ਗੱਲ ਕਰਦੇ ਹਨ: ਬਟਨ ਕਾਰਵਾਈਆਂ ਨੂੰ ਟਰਿੱਗਰ ਕਰਦੇ ਹਨ, ਕਾਰਵਾਈਆਂ ਬੈਕਐਂਡ ਐਂਡਪੋਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦੀਆਂ ਹਨ, ਜਵਾਬ UI ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਪਰਮਿਸ਼ਨ ਇਹ ਫੈਸਲਾ ਕਰਦੇ ਹਨ ਕਿ ਲੋਕ ਕੀ ਵੇਖ ਸਕਦੇ ਹਨ।
AI ਸਕਰੀਨਾਂ ਨੂੰ ਲਿਖਤੀ ਸਪੈਸ ਅਨੁਸਾਰ ਰੂਟਸ (URLs ਜਾਂ ਐਪ ਪਾਥ), ਮੁੱਖ ਕਾਰਵਾਈਆਂ ਤੋਂ ਬਾਅਦ ਕੀ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਪੇਜਾਂ ਵਿਚ ਸਹੀ ਸੰਦਰਭ ਕਿਵੇਂ ਪਾਸ ਕੀਤਾ ਜਾਵੇ, ਇਹ ਜੋੜ ਸਕਦਾ ਹੈ।
ਉਦਾਹਰਣ: “ਸੇਵ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਲਿਸਟ 'ਤੇ ਵਾਪਸੀ ਕਰੋ ਅਤੇ ਨਵੇਂ ਆਈਟਮ ਨੂੰ ਹਾਇਲਾਈਟ ਕਰੋ” ਇੱਕ ਢਾਂਚਾਬੱਧ ਫਲੋ ਬਣ ਜਾਂਦਾ ਹੈ—ਫਾਰਮ ਸਬਮਿਟ → ਸਫਲਤਾ ਦੀ ਉਡੀਕ → ਲਿਸਟ 'ਤੇ ਨੈਵੀਗੇਟ → ਟੋਸਟ ਦਿਖਾਓ ਅਤੇ ਨਵੇਂ ਰੋ ਨੂੰ ਫੋਕਸ ਕਰੋ।
ਸਪੈਸ ਅਕਸਰ ਰੋਲ ਦਾ ਝਿਕਾ ਦਿੰਦੇ ਹਨ (“Admin edit ਕਰ ਸਕਦਾ ਹੈ, Viewer صرف read ਕਰ ਸਕਦਾ ਹੈ”)। ਵਾਇਰਿੰਗ ਮਤਲਬ ਹੈ ਇਹ ਨੂੰ ਇਕ ਤੋਂ ਜ਼ਿਆਦਾ ਥਾਵਾਂ 'ਤੇ ਲਾਗੂ ਕਰਨਾ:
AI ਇਥੇ ਸਹਾਇਕ ਹੈ ਕਿਉਂਕਿ ਇਹ ਐਪ 'ਚ ਲਗਾਤਾਰ ਚੈਕਸ (ਸਿਰਫ਼ ਇਕ ਸਕਰੀਨ ਨਹੀਂ) ਜਨਰੇਟ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ “ਲੱਗਦਾ ਤਹ ਸੀ ਲੌਕ, ਪਰ ਐਂਡਪੋਇੰਟ ਹੁਣ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ” ਵਾਲੀ ਸਮੱਸਿਆ ਘੱਟ ਹੁੰਦੀ ਹੈ।
ਅਧਿਕਤਰ ਫੀਚਰ ਕੰਫਿਗਰੇਸ਼ਨ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦੇ ਹਨ: API ਬੇਸ URL, ਐਨੈਲਿਟਿਕਸ ਕੀ, ਫੀਚਰ ਫ਼ਲੈਗ, ਸਟੋਰੇਜ ਬੱਕੇਟ ਆਦਿ। AI dev/staging/prod ਲਈ ਵੱਖ-ਵੱਖ ਸੈਟਿੰਗ ਬਣਾਉਣ 'ਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ ਜਦੋਂ ਕਿ ਸੀਕ੍ਰੇਟ ਕੋਡਬੇਸ ਵਿੱਚ ਨਹੀਂ ਸੁੱਟੇ ਜਾਂਦੇ।
ਆਮ ਆਉਟਪੁੱਟ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ:
.env ਟੈਂਪਲੇਟ (ਸੁਰੱਖਿਅਤ ਪਲੇਸਹੋਲਡਰ)ਲਕੜੀ ਦਾ ਮਕਸਦ ਪੂਰਾ ਲੂਪ ਹੈ: “ਕਲਿੱਕ → ਬੇਨਤੀ → ਜਵਾਬ → UI ਅਪਡੇਟ।” AI ਰੁੱਝੇ ਹੋਏ glue ਕੋਡ ਜੋੜ ਸਕਦਾ ਹੈ (ਲੋਡਿੰਗ ਸਟੇਟ, ਏਰਰ ਹੈਂਡਲਿੰਗ, ਰੀਟ੍ਰਾਈ) ਅਤੇ ਸਰਲ ਜਾਂਚਾਂ ਜਿਵੇਂ:
ਇਹ ਥਾਂ ਹੁੰਦੀ ਹੈ ਜਿੱਥੇ ਫੀਚਰ ਇੱਕ ਮੌਕ ਤੋਂ ਅਸਲ ਉਤਪਾਦ ਵਰਗਾ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦਾ ਹੈ।
ਜਦੋਂ ਫੀਚਰ “ਵਰਕਿੰਗ” ਹੋ ਜਾਂਦਾ ਹੈ, ਇਸ ਦੀ ਟੈਸਟ ਉਸੇ ਤਰ੍ਹਾਂ ਕਰੋ ਜਿਵੇਂ ਕੋਈ ਅਸਲੀ ਯੂਜ਼ਰ (ਅਤੇ ਗੰਦਗੀ ਵਾਲਾ ਅਸਲੀ ਦੁਨੀਆ) ਕਰੇਗਾ। AIAcceptancecriteria ਨੂੰ ਕConcrete checks ਵਿੱਚ ਤਬਦੀਲ ਕਰਕੇ ਅਤੇ ਡੀਬੱਗਿੰਗ ਦੀ ਥਕਾਵਟ ਨੂੰ ਤੇਜ਼ ਕਰਕੇ ਮਦਦ ਕਰਦਾ ਹੈ।
ਜੇ ਤੁਹਾਡਾ ਸਪੈਸ ਕਹਿੰਦਾ ਹੈ, “ਯੂਜ਼ਰ ਆਪਣਾ ਪਾਸਵਰਡ ਰੀਸੈੱਟ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਪੁਸ਼ਟੀ ਸੰਦੇਸ਼ ਵੇਖਦਾ ਹੈ,” ਤਾਂ AI ਉਦੋਂ-ਉਦੋਂ ਟੈਸਟ ਕੇਸ ਸੁਝਾ ਸਕਦਾ ਹੈ ਜੋ ਉਸ ਬਿਆਨ ਨਾਲ ਮਿਲਦੇ ਹਨ:
ਚਾਲ ਮੰਤਵ ਹੈ acceptance criteria + feature name + ਕੁਝ ਮੌਜੂਦਾ ਟੈਸਟ ਰਿਵਾਜ AI ਨੂੰ ਦਿਓ ਤਾਂ ਕਿ ਨਤੀਜੇ ਤੁਹਾਡੇ ਕੋਡਬੇਸ ਦੇ ਅਨੁਕੂਲ ਹੋਣ।
ਸਪੈਸ ਆਮ ਤੌਰ 'ਤੇ ਹੈਪੀ ਪਾਥ ਬਿਆਨ ਕਰਦਾ ਹੈ। AI ਉਹ “ਕਿਆ ਹੋ ਜਾਵੇ” ਸਥਿਤੀਆਂ ਲਈ ਸੋਚਣ ਵਿੱਚ ਮਦਦਗਾਰ ਹੈ ਜੋ ਸਹਾਇਤਾ ਟਿਕਟ ਬਣਾਉਣਗੇ:
ਤੁਹਾਨੂੰ ਹਰ ਏਜ-ਕੇਸ ਨੂੰ ਫਿਲਹਾਲ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ, ਪਰ ਇਹ ਫੈਸਲਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਜੋਖਮ ਤੁਹਾਡੇ ਉਤਪਾਦ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ।
ਜਦੋਂ ਟੈਸਟ ਫੇਲ ਹੋਵੇ, AI ਨੂੰ ਉਹੀ ਚੀਜ਼ ਦਿਓ ਜੋ ਇਕ ਡਿਵੈਲਪਰ ਪੁੱਛੇਗਾ: failing assertion, ਲਾਗ, stack trace, ਅਤੇ ਨਿਰਪੇਖ ਦੁਹਰਾਓ ਕਦਮ।
AI ਫਿਰ ਕਰ ਸਕਦਾ ਹੈ:
ਇਸਨੂੰ ਤੱਥਾਂ ਵਜੋਂ ਨਹੀਂ, ਪਰ ਹਿੱਪੋਥੇਸਿਸ ਵਜੋਂ ਲਓ। ਉਸਨੂੰ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਟੈਸਟ ਫਿਰ ਚਲਾਓ ਅਤੇ UI ਵਿਚ ਵਿਵਹਾਰ ਤੈਕਨੀਕੀ ਢੰਗ ਨਾਲ ਜਾਂਚੋ।
ਤੇਜ਼ ਸਮੀਖਿਆ ਚੱਕਰਾਂ ਲਈ, ਇੱਕ ਛੋਟੀ ਚੈਕਲਿਸਟ ਰੱਖੋ:
ਪਹਿਲਾ AI-ਜਨਰੇਟ ਕੀਤਾ ਡਰਾਫਟ ਆਮ ਤੌਰ 'ਤੇ “ਪ੍ਰਤਿਕਿਰਿਆ ਲਈ ਕਾਫੀ ਚੰਗਾ” ਹੁੰਦਾ ਹੈ, ਨਾ ਕਿ “ਸ਼ਿਪ ਕਰਨ ਯੋਗ।” ਇਟਰੇਸ਼ਨ ਓਥੇ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਇੱਕ ਮਨਜ਼ੂਰਯੋਗ ਫੀਚਰ ਨੂੰ ਭਰੋਸੇਯੋਗ ਬਣਾਉਂਦੇ ਹੋ—ਲੋੜਾਂ ਨੂੰ ਪੱਕਾ ਕਰਕੇ, ਏਜ-ਕੇਸ ਸੂਧਾਰ ਕੇ, ਅਤੇ ਛੋਟੇ, ਸਮੀਖਿਆਯੋਗ ਕਦਮਾਂ ਵਿੱਚ ਬਦਲਾਅ ਕਰਕੇ।
ਇੱਕ ਸਿਹਤਮੰਦ ਲੂਪ ਇਹੇ ਵਰਗਾ ਹੁੰਦਾ ਹੈ: generate → review → specific change ਮੰਗੋ → ਕੀ ਬਦਲਿਆ ਉਸ ਨੂੰ ਤੁਲਨਾ ਕਰੋ → ਦੁਹਰਾਓ।
ਸਾਰੇ ਐਪ ਲਈ ਮੁੜ-ਪ੍ਰਾਂਪਟ ਕਰਨ ਦੀ ਥਾਂ, ਨਿਸ਼ਾਨਾਬੰਦੀ ਅਪਡੇਟਾਂ ਲਈ ਕੋਸ਼ਿਸ਼ ਕਰੋ। AI ਨੂੰ ਸਿਰਫ ਇੱਕ ਹਿੱਸਾ (ਇੱਕ ਸਕਰੀਨ, ਇੱਕ ਕੰਪੋਨੈਂਟ, ਇੱਕ ਵੈਧਤਾ ਨਿਯਮ, ਇੱਕ ਕੁਐਰੀ) ਨੂੰ ਬਦਲਣ ਲਈ ਕਹੋ ਅਤੇ ਇੱਕ ਡਿਫ ਜਾਂ ਸਪਸ਼ਟ “before/after” ਵਾਪਸ ਮੰਗੋ। ਇਸ ਨਾਲ ਇਹ ਸਾਬਤ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿ ਬਦਲਾਅ ਸਮੱਸਿਆ ਸੁਝਾਈ ਗਈ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ ਬਿਨਾਂ ਕਿਸੇ ਹੋਰ ਜ਼ਰੂਰੀ ਚੀਜ਼ ਨੂੰ ਤੋੜੇ।
ਜੇ ਤੁਹਾਡਾ ਵర్కਫਲੋ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਤਾ ਛੋਟੇ commits ਰੱਖੋ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ teammate ਦੀ pull request ਵਾਂਗ ਸਮੀਖਿਆ ਕਰੋ: ਡਿਫ ਸਕੈਨ ਕਰੋ, ਐਪ ਚਲਾਓ, ਅਤੇ ਵਿਵਹਾਰ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
Koder.ai ਵਰਗੀਆਂ ਪਲੇਟਫਾਰਮਾਂ ਇਸ ਪੈਟਰਨ ਤੋਂ ਲਾਭ ਲੈਂਦੀਆਂ ਹਨ: “planning mode” (ਜਾਂ ਸਮਾਨ) ਵਰਤੋ ਤਾਂ ਕਿ ਪਹਿਲਾਂ ਸਕੋਪ ਅਤੇ ਫਲੋ 'ਤੇ ਸਹਿਮਤੀ ਹੋ ਜਾਵੇ, ਫਿਰ ਜਨਰੇਟ ਕਰੋ, ਫਿਰ ਨਿਸ਼ਾਨਾਬੰਦੀ ਟੁਕੜਿਆਂ ਵਿੱਚ ਇਟਰੇਟ ਕਰੋ—ਤੇ ਐਕਸਪੇਰੀਮੈਂਟ ਜੇ ਗਲਤ ਜਾਵੇ ਤਾਂ snapshots/rollback 'ਤੇ ਨਿਰਭਰ ਕਰੋ।
ਅਸਪਸ਼ਟ ਬੇਨਤੀਆਂ (“ਇਸਨੂੰ ਸੁੰਦਰ ਬਣਾਓ”, “ਫਲੋ ਠੀਕ ਕਰੋ”) ਅਸਪਸ਼ਟ ਨਤੀਜੇ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ। ਮਜ਼ਬੂਤ ਬਦਲਾਅ ਮੰਗਾਂ ਸੂਚਿਤ ਸਕ੍ਰੀਨ ਅਤੇ ਸਟੇਟ ਦਰਸਾਉਂਦੀਆਂ ਹਨ:
ਜੋੜੋ acceptance criteria ਜਦੋਂ ਹੋ ਸਕੇ: “Pay ਬਟਨ ਲੋੜੀਂਦੇ ਫੀਲਡਾਂ ਵੈਧ ਹੋਣ ਤੱਕ disabled ਰਹੇ” ਜਾਂ “ਜੇ shipping desh ਬਦਲਦਾ ਹੈ, ਤਾਂ ਤੁਰੰਤ ਟੈਕਸ ਰੀਕੈਲਕੁਲੇਟ ਕਰੋ।”
AI ਆਉਟਪੁੱਟ ਨੂੰ ਉਹ ਕੋਡ ਸਮਝੋ ਜੋ ਤੁਸੀਂ ਮਾਲਕ ਹੋ। ਅਪਡੇਟਸ ਦੇ ਨਾਲ ਛੋਟੇ ਚੇਜ਼ ਨੋਟ ਮੰਗੋ: ਕੀ ਬਦਲਿਆ, ਕਿਉਂ ਬਦਲਿਆ, ਅਤੇ ਕੀ ਟੈਸਟ ਕਰਨਗੇ।
ਜਦੋਂ AI ਕੋਈ ਰਿਫੈਕਟਰ ਸੁਝਾਉਂਦਾ ਹੈ, ਉਸਨੂੰ ਉਸਦੇ ਉਦੇਸ਼ ਦੀ ਵਿਆਖਿਆ ਅਤੇ ਸੰਭਾਵਿਤ ਖਤਰਿਆਂ ਦੀ ਸੂਚੀ ਮੰਗੋ (ਉਦਾਹਰਣ: “ਇਸ ਨਾਲ ਵੈਧਤਾ ਸਮਾਂ-ਸਾਰ ਬਦਲੇਗਾ” ਜਾਂ “ਇਸ ਨਾਲ API ਜਵਾਬ ਸੰਭਾਲਣ ਤਰੀਕਾ ਬਦਲੇਗਾ”)।
ਇਟਰੇਸ਼ਨ ਉਹ ਵੇਲੇ ਖਤਮ ਕਰੋ ਜਦੋਂ ਤੁਸੀਂ ਸਪੱਸ਼ਟ ਰਿਲੀਜ਼ ਮਾਪਦੰਡ ਪੂਰੇ ਕਰ ਲਿਆ ਹੋਵੇ। ਸੀਮਾਵਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ:
ਫਿਰ, ਸਪੈਸ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰੋ, ਸ਼ਿਪ ਕਰੋ, ਅਤੇ ਅਗਲੀ ਇਟਰੇਸ਼ਨ ਨੂੰ ਇਕ ਨਵੇਂ, ਨਿਰਧਾਰਿਤ ਬਦਲਾਅ ਵਜੋਂ ਯੋਜਨਾ ਬਣਾਓ।
AI ਲਿਖਤੀ ਸਪੈਸ ਨੂੰ ਕਾਫੀ ਪੂਰੇ ਫੀਚਰਾਂ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਫੈਸਲੇ ਲਈ ਬਦਲ ਨਹੀਂ ਹੈ। AI ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਡਰਾਫਟ ਸਮਝੋ ਜੋ ਸਮੀਖਿਆ ਚਾਹੀਦੀ ਹੈ—ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਇਹ ਯੂਜ਼ਰ ਡੇਟਾ, ਭੁਗਤਾਨ, ਜਾਂ ਪਰਮਿਸ਼ਨ ਨੂੰ ਛੇੜਦਾ ਹੋਵੇ।
ਧਾਰੋ ਕਿ ਜੋ ਕੁਝ ਵੀ ਤੁਸੀਂ ਪ੍ਰਾਂਪਟ ਵਿੱਚ ਪੇਸਟ ਕਰਦੇ ਹੋ ਉਹ ਸਟੋਰ ਜਾਂ ਸਮੀਖਿਆ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਨਾ ਪੇਸਟ ਕਰੋ:
ਜੇ ਤੁਹਾਨੂੰ ਰੀਅਲਿਸਮ ਚਾਹੀਦੀ ਹੈ, ਤਾਂ ਨਾਂ-ਸੂਚਕ ਕਰੋ: ਨਾਮਾਂ ਨੂੰ placeholders ਨਾਲ ਬਦਲੋ, IDs ਨੂੰ scramble ਕਰੋ, ਅਤੇ ਨਰੀਵੇਣ ਵੇਰਣਾਂ ਦੀ ਥਾਂ ਢਾਂਚੇ ਦਿਓ (“10k users, 3 roles”)।
AI ਬੇਸਲਾਈਨ ਸੁਰੱਖਿਆ ਚੈੱਕ ਜਨਰੇਟ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਦੀ ਪੁਸ਼ਟੀ ਖੁਦ ਕਰਨੀ ਹੋਵੇਗੀ।
ਕੋਡ ਜਾਂ ਸਕਰੀਨਾਂ ਮੰਗਣ ਤੋਂ ਪਹਿਲਾਂ ਸ਼ਾਮਲ ਕਰੋ:
ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਡਰਾਫਟ ਪ੍ਰੋਟੋਟਾਈਪ ਹੋਵੇ, ਇਕ ਛੋਟੀ ਸਮੀਖਿਆ ਨਿਯਤ ਕਰੋ: ਇਸਨੂੰ ਆਪਣੇ ਰੋਡਮੇਪ ਨਾਲ ਤੁਲਨਾ ਕਰੋ, ਫੈਸਲਾ ਕਰੋ ਕਿ ਹੁਣ ਕੀ ਜਾਰੀ ਕਰਨਾ ਹੈ ਅਤੇ ਕੀ ਬਾਅਦ ਲਈ ਰੱਖਣਾ ਹੈ, ਅਤੇ ਬਦਲਾਅ ਦਸਤਾਵੇਜ਼ ਕਰੋ।
ਜੇ ਤੁਸੀਂ ਡਰਾਫਟਾਂ ਨੂੰ ਯੋਜਨਾ ਵਿੱਚ ਬਦਲਣ ਵਿੱਚ ਮਦਦ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ /pricing ਵੇਖੋ ਜਾਂ /blog ਵਿੱਚ ਸੰਬੰਧਿਤ ਗਾਈਡਾਂ ਨੂੰ ਬ੍ਰਾਊਜ਼ ਕਰੋ। ਜੇ ਤੁਸੀਂ ਚੈਟ-ਚਲਿਤ ਵਿਕਾਸ ਦੀ ਖੋਜ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ Koder.ai ਇਸ ਵਰਕਫਲੋ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ: ਲਿਖਤੀ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਵੈੱਬ, ਬੈਕਐਂਡ ਅਤੇ ਮੋਬਾਈਲ ਫੀਚਰਾਂ ਵਿੱਚ ਬਦਲੋ, ਤੇਜ਼ੀ ਨਾਲ ਇਟਰੇਟ ਕਰੋ, ਅਤੇ ਜਦੋਂ ਤਿਆਰ ਹੋਵੋ ਤਾਂ ਸੋর্স ਕੋਡ ਨਿਕਾਸ ਕਰੋ।
"ਲਿਖਤੀ ਨਿਰਦੇਸ਼" ਉਹ ਕੋਈ ਵੀ ਪਾਠ ਹੈ ਜੋ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਮਕਸਦ (ਤੁਹਾਡੇ ਚਾਹਵੇ ਨਤੀਜੇ) ਅਤੇ ਸੀਮਾਵਾਂ (ਪਾਬੰਦੀਆਂ, ਨਿਯਮ ਅਤੇ ਕੀ ਮਨਜ਼ੂਰ ਨਹੀਂ) ਦਾ ਬਿਆਨ ਕਰਦਾ ਹੈ। ਇਹ ਤੁਰੰਤ Slack ਸੁਨੇਹਾ, PRD ਖੰਡ, ਯੂਜ਼ਰ ਸਟੋਰੀਜ਼, ਐਕਸੈਪਟੈਂਸ ਕ੍ਰਾਈਟੇਰੀਆ ਜਾਂ ਏਜ-ਕੇਸਾਂ ਦੀ ਸੂਚੀ ਹੋ ਸਕਦੀ ਹੈ—ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਫਾਰਮੈਲੀਟੀ ਨਹੀਂ, ਸਪਸ਼ਟਤਾ ਹੈ।
ਇੱਕ “ਵਰਕਿੰਗ” ਫੀਚਰ ਆਮ ਤੌਰ 'ਤੇ ਸਿਰਫ ਵਿਜ਼ੁਅਲ ਤੋਂ ਅੱਗੇ ਹੁੰਦਾ ਹੈ:
ਮੌਕਅਪ ਦਿਖਾਉਂਦੀ है ਕਿ UI ਕਿਵੇਂ ਲੱਗੇਗਾ; ਵਰਕਿੰਗ ਫੀਚਰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਐਂਡ-ਟੂ-ਐਂਡ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ।
ਅਕਸਰ ਟੀਮ ਇੱਕ ਸਧਾਰਨ ਇਟਰੇਸ਼ਨ ਲੂਪ ਵਰਤੀਦੀ ਹੈ:
ਤੇਜੀ ਜਿੰਨੀ ਡਰਾਫਟਾਂ ਤੋਂ ਆਉਂਦੀ ਹੈ; ਗੁਣਵੱਤਾ ਧਿਆਨਪੂਰਵਕ ਸਮੀਖਿਆ ਅਤੇ ਇਟਰੇਸ਼ਨ ਤੋਂ ਆਉਂਦੀ ਹੈ।
AI ਤੇਜ਼ੀ ਨਾਲ ਅਗੇ ਵੱਧ ਸਕਦਾ ਹੈ, ਪਰ ਜੇ ਤੁਸੀਂ ਨਿਰਦੇਸ਼ ਨਹੀਂ ਦਿੰਦੇ ਤਾਂ ਇਹ ਅਨੁਮਾਨ ਲਗਾਵੇਗਾ। ਜਿਨ੍ਹਾਂ ਗੱਲਾਂ ਨੂੰ ਸਪੈਸਿਫਾਈ ਕਰੋ:
ਇਹ ਪਹਿਲਾਂ ਹੀ ਦੇਣ ਨਾਲ ਦੁਬਾਰਾ ਕੰਮ ਘੱਟ ਹੁੰਦਾ ਹੈ।
ਸ਼ੁਰੂਆਤ ਲਈ ਚਾਰ ਐਲਿਮੈਂਟ ਸ਼ਾਮਲ ਕਰੋ:
ਇਹ AI ਨੂੰ ਦਿਸ਼ਾ ਅਤੇ ਗੁਣਵੱਤਾ ਬਾਰ ਦੇਂਦਾ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਇੱਕ ਆਈਡੀਆ।
ਕਾਂਕੜੇ ਸਪੇਸ ਨੂੰ Konkreet ਬਣਾਉਣ ਲਈ ਇਹ ਨਿਰਧਾਰਤ ਕਰੋ:
ਇਹspecs ਸਿੱਧਾ ਸਕਰੀਨਾਂ, ਨਿਯਮ ਅਤੇ API ਵਿਹਾਰ ਵਿੱਚ ਤਬਦੀਲ ਹੁੰਦੇ ਹਨ।
ਕੋਈ ਵੀ ਕੋਡ ਜਨਰੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਫੀਚਰ ਪਲਾਨ ਮੰਗੋ:
ਇਹ ਸ਼ੁਰੂ ਵਿੱਚ ਹੀ ਘੱਟ ਚੀਜ਼ਾਂ ਘੁਮਾਉਂਦਾ ਹੈ ਅਤੇ ਲੋੜੀਂਦੇ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ।
ਹਰ ਇਕ ਮੁੱਖ ਸਕਰੀਨ ਸਥਿਤੀ ਲਈ ਖੁੱਲ੍ਹ ਕੇ ਨਿਰਧਾਰਤ ਕਰਵਾਓ:
ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਡਕਸ਼ਨ ਬੱਗ ਅਤੇ UX ਸਮੱਸਿਆਵਾਂ ਹੈਪੀ ਪਾਥ ਨਹੀਂ, ਸਟੇਟ ਹੈਂਡਲਿੰਗ ਦੀ ਕਮੀ ਤੋਂ ਆਉਂਦੀਆਂ ਹਨ।
AI ਆਮ ਤੌਰ 'ਤੇ ਪਾਠ ਵਿੱਚੋਂ ਨਾਉਂ (entities) ਖਿੱਚਦਾ ਹੈ ਅਤੇ ਫਿਰ ਸੁਝਾਓ ਦਿੰਦਾ ਹੈ:
ਇਸਦੇ ਨਾਲ ਨਾਲ ਡਾਟਾ ਲਾਈਫਸਾਈਕਲ ਵੀ ਮੈਪ ਕਰੋ: ਬਣਾਉ/ਅਪਡੇਟ/ਸਾਫਟ-ਡਿਲੀਟ ਅਤੇ ਕੀ ਆਡੀਟ ਟ੍ਰੇਲ ਚਾਹੀਦੀ ਹੈ।
AI ਆਉਟਪੁਟ ਨੂੰ ਡਰਾਫਟ ਸਮਝੋ ਅਤੇ ਗਾਰਡਰੇਲਸ ਲਗਾਓ:
AI ਨੂੰ ਤੇਜ਼ੀ ਲਈ ਵਰਤੋ, ਪਰ ਸਹੀਤਾ, ਸੁਰੱਖਿਆ ਅਤੇ ਗੁਣਵੱਤਾ ਲਈ ਇਨਸਾਨਾਂ ਨੂੰ ਜ਼ਿੰਮੇਵਾਰ ਰੱਖੋ।