AI ਟੂਲਾਂ ਨਾਲ ਗੱਲਬਾਤ ਕਰਕੇ ਅਸਲ ਸੌਫਟਵੇਅਰ ਬਣਾਉਣ ਦੀ ਕਾਰਗਰ ਗਾਈਡ—ਵਰਕਫਲੋ, ਉਦਾਹਰਨ, ਸੀਮਾਵਾਂ, ਅਤੇ ਸਭ ਤੋਂ ਚੰਗੀਆਂ ਪ੍ਰਥਾਵਾਂ।

ਸੰਵਾਦਾਤਮਕ ਸੌਫਟਵੇਅਰ ਬਿਲਡਿੰਗ ਇਸ ਗੱਲ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕੁਦਰਤੀ ਭਾਸ਼ਾ — ਚੈਟ, ਵੌਇਸ, ਜਾਂ ਲਿਖਤੀ ਸੰਖੇਪ — ਨੂੰ “ਪ੍ਰੋਗਰਾਮ” ਕਰਨ ਦਾ ਮੁੱਖ ਤਰੀਕਾ ਮੰਨਿਆ ਜਾਵੇ। ਕੋਡ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਥਾਂ ਤੁਸੀਂ ਦੱਸਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹੋ, ਪਹਿਲਾ ਵਰਜ਼ਨ ਮੰਗਦੇ ਹੋ, ਜੋ ਮਿਲਿਆ ਉਸ ਦੀ ਸਮੀਖਿਆ ਕਰਦੇ ਹੋ, ਅਤੇ ਵਾਪਸ-ਅਤੇ-ਵਾਪਸ ਸੁਧਾਰ ਕਰਦੇ ਹੋ।
ਹਕੀਕਤ ਵਿੱਚ ਬਦਲਾਵ ਇਹ ਹੈ ਕਿ ਤੁਹਾਡੇ ਸ਼ਬਦ ਉਹ ਇਨਪੁੱਟ ਬਣ ਜਾਂਦੇ ਹਨ ਜੋ ਰਿਕਾਇਰਮੈਂਟ, UI, ਡੇਟਾ ਸਟ੍ਰਕਚਰ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਕੋਡ ਨੂੰ ਰੂਪ ਦਿੰਦੇ ਹਨ। ਤੁਸੀਂ ਅਜੇ ਵੀ ਉਤਪਾਦ-ਸੰਬੰਧੀ ਕੰਮ ਕਰ ਰਹੇ ਹੋ — ਮਨੋਰਥ ਸਪਸ਼ਟ ਕਰਨਾ, ਟਰੇਡ-ਆਫ਼ ਕਰਨੇ, ਅਤੇ ਨਤੀਜੇ ਚੈੱਕ ਕਰਨਾ — ਪਰ ਟੂਲ ਡਰਾਫਟਿੰਗ ਦਾ ਵੱਧ ਹਿੱਸਾ ਸੰਭਾਲ ਲੈਂਦਾ ਹੈ।
ਹਰ ਸੈਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ ਇਰਾਦਾ ਵਰਨਣ ਅਤੇ ਆઉਟਪੁੱਟ 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਵਿਚਕਾਰ ਬਦਲਦਾ ਰਹਿੰਦਾ ਹੈ:
ਮੁੱਦਾ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਸਟੀਅਰ ਕਰ ਰਹੇ ਹੋ, ਸਿਰਫ਼ ਮੰਗ ਨਹੀਂ ਕਰ ਰਹੇ। ਚੰਗੀ ਸੰਵਾਦਾਤਮਕ ਬਿਲਡਿੰਗ ਐਸਾ ਮਹਿਸੂਸ ਹੁੰਦੀ ਹੈ ਜਿਵੇਂ ਇੱਕ ਨੌਜਵਾਨ ਸਾਥੀ ਨੂੰ ਨਿਰਦੇਸ਼ ਦੇ ਰਹੇ ਹੋ — ਬਾਰ-ਬਾਰ ਚੈੱਕ-ਇਨ ਨਾਲ।
ਇਹ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਚਮਕਦਾ ਹੈ ਜਿੱਥੇ ਸਮੱਸਿਆ ਸਮਝਣਯੋਗ ਹੋਵੇ ਅਤੇ ਨਿਯਮ ਸਿੱਧੇ ਹੋਣ:
ਫਾਇਦਾ ਤੇਜ਼ੀ ਹੈ: ਤੁਸੀਂ ਕੋਈ ਐਸੀ ਚੀਜ਼ ਜਲਦੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਕਲਿੱਕਯੋਗ ਜਾਂ ਰਨ ਕਰਨਯੋਗ ਹੋਵੇ, ਫਿਰ ਫੈਸਲਾ ਕਰੋ ਕਿ ਕੀ ਇਸਨੂੰ ਪਾਲਿਸ਼ ਕਰਨ ਵਾਲੀ ਲਾਇਕ ਹੈ।
ਜਦੋਂ ਡੋਮੇਨ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਏਜ ਕੇਸ ਜਾਂ ਕਠੋਰ ਪਾਬੰਦੀਆਂ ਹੋਣ ਤਾਂ ਇਹ ਥੋੜ੍ਹਾ ਝਟਪਟ ਹੋ ਜਾਂਦਾ ਹੈ:
ਇਹਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ, AI ਕੁਝ ਐਸਾ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਠੀਕ ਲੱਗੇ ਪਰ ਮਹੱਤਵਪੂਰਨ ਛੱਡ-ਪੈਰਾਂ ਨੂੰ ਮਿਸ ਕਰ ਦੇਵੇ।
ਸੰਵਾਦਾਤਮਕ ਬਿਲਡਿੰਗ ਆਮ ਤੌਰ 'ਤੇ ਪਹਿਲਾਂ ਤੇਜ਼ੀ ਲਈ ਅਪਟੀਮਾਈਜ਼ ਕਰਦੀ ਹੈ। ਜੇ ਤੁਹਾਨੂੰ ਸਹੀਪਨ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਜ਼ਿਆਦਾ ਨਿਰਦੇਸ਼ ਅਤੇ ਟੇਸਟਿੰਗ 'ਤੇ ਸਮਾਂ ਲੱਗੇਗਾ। ਜੇ ਤੁਹਾਨੂੰ ਨਿਯੰਤਰਣ (ਆਰਕੀਟੈਕਚਰ, ਮੈਨਟੇਨੇਬਿਲਿਟੀ, ਆਡਿਟ) ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਪਹਿਲਾਂ ਇੱਕ ਇੰਜੀਨੀਅਰ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰੋ — ਜਾਂ AI ਆਉਟਪੁੱਟ ਨੂੰ ਖ਼ਾਕਾ ਸਮਝੋ, ਆਖਰੀ ਉਤਪਾਦ ਨਹੀਂ।
ਜਦੋਂ ਲੋਕ ਕਹਿੰਦੇ ਹਨ “ਮੈਂ ਇਹ ਐਪ ਚੈਟ ਕਰਕੇ ਬਣਾਇਆ,” ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਕੁਝ ਟੂਲ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚੋਂ ਇੱਕ ਵਰਤ ਰਹੇ ਹੁੰਦੇ ਹਨ। ਹਰ ਇੱਕ ਕੰਮ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸੇ ਵਿੱਚ ਚੰਗਾ ਹੈ: ਸ਼ਬਦਾਂ ਨੂੰ ਸਕ੍ਰੀਨਾਂ, ਲਾਜਿਕ, ਡੇਟਾ ਕਨੈਕਸ਼ਨ, ਜਾਂ ਅਸਲ ਕੋਡ ਵਿੱਚ ਬਦਲਣਾ ਜਿਸਨੂੰ ਤੁਸੀਂ ਰਿਲੀਜ਼ ਕਰ ਸਕਦੇ ਹੋ।
IDE ਸਹਾਇਕ ਓਥੇ ਰਹਿੰਦੇ ਹਨ ਜਿੱਥੇ ਡਿਵੈਲਪਰ ਕੋਡ ਲਿਖਦੇ ਹਨ (ਟੂਲਾਂ ਜਿਵੇਂ VS Code, JetBrains ਆਦਿ)। ਉਹ ਚੰਗੇ ਹਨ ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਕੋਡਬੇਸ ਹੋਵੇ ਜਾਂ ਤੁਸੀਂ ਇੱਕ ਚਾਹੁੰਦੇ ਹੋ: ਫੰਕਸ਼ਨ ਜਨਰੇਟ ਕਰਨਾ, ਗਲਤੀਆਂ ਦੀ ਵਿਆਖਿਆ, ਰੀਫੈਕਟਰਿੰਗ, ਅਤੇ ਟੈਸਟ ਲਿਖਣਾ।
ਵੈੱਬ ਐਪ ਬਿਲਡਰ ਬਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦੇ ਹਨ ਅਤੇ ਤੇਜ਼ ਤਿਆਰੀ 'ਤੇ ਧਿਆਨ ਦਿੰਦੇ ਹਨ: ਫਾਰਮ, ਡੈਸ਼ਬੋਰਡ, ਸਧਾਰਨ ਵਰਕਫਲੋ, ਅਤੇ ਹੋਸਟਿੰਗ। ਉਹ ਅਕਸਰ “ਦੱਸੋ ਤੇ ਵੇਖੋ” ਦੇ ਨੇੜੇ ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ, ਖ਼ਾਸ ਕਰਕੇ ਅੰਦਰੂਨੀ ਟੂਲਾਂ ਲਈ।
ਇੱਕ ਉਪਯੋਗ ਮਨੌਵਿੱਜ্ঞান: IDE ਸਹਾਇਕ ਕੋਡ ਗੁਣਵੱਤਾ ਅਤੇ ਨਿਯੰਤਰਣ ਲਈ ਅਪਟੀਮਾਈਜ਼ ਕਰਦੇ ਹਨ; ਵੈੱਬ ਬਿਲਡਰ ਤੇਜ਼ੀ ਅਤੇ ਸੁਵਿਧਾ ਲਈ।
ਇੱਕ ਕੋਪਾਈਲਟ ਤੁਹਾਡੇ ਨਾਲ ਹੁਣੀ-ਹੁਣੀ ਕੀਤਿਆਂ ਅਗਲੇ ਕਦਮ 'ਚ ਮਦਦ ਕਰਦਾ ਹੈ: “ਇਹ ਕਿੁਐਰੀ ਲਿਖੋ”, “ਇਹ UI ਕੰਪੋਨੈਂਟ ਡਰਾਫਟ ਕਰੋ”, “ਇਹ ਲੋੜਾਂ ਨੂੰ ਸੰਖੇਪ ਕਰੋ।” ਤੁਸੀਂ ਡਰਾਈਵਰ ਸੀਟ 'ਚ ਰਹਿੰਦੇ ਹੋ।
ਇੱਕ ਏਜੰਟ ਨਿਯੁਕਤ ਕੰਮ ਕਰਦੇ ਵਰਗਾ ਹੁੰਦਾ ਹੈ: “ਲੋਗਿਨ ਅਤੇ ਐਡਮਿਨ ਪੇਜ਼ ਨਾਲ ਇੱਕ ਵਰਕਿੰਗ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਓ,” ਫਿਰ ਇਹ ਟਾਸਕ ਯੋਜਨਾ ਬਣਾਉਂਦਾ, ਕਈ ਫਾਇਲਾਂ ਜਨਰੇਟ ਕਰਦਾ, ਅਤੇ ਦੁਹਰਾਉਂਦਾ ਹੈ। ਏਜੰਟ ਸਮਾਂ ਬਚਾ ਸਕਦੇ ਹਨ, ਪਰ ਤੁਸੀਂ ਚੈੱਕਪੌਇੰਟ ਰੱਖਣਾ ਚਾਹੋਗੇ ਤਾਂ ਜੋ ਉਹ ਬਹੁਤ ਸਾਰਾ ਆਉਟਪੁੱਟ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਦਿਸ਼ਾ ਦੀ ਮਨਜ਼ੂਰੀ ਲੈ ਸਕਣ।
Koder.ai ਵਰਗੇ ਟੂਲਾਂ ਇਸ ਏਜੰਟ-ਸ਼ੈਲੀ ਵਰਕਫਲੋ ਵਿੱਚ ਲੀਨ ਹਨ: ਤੁਸੀਂ ਚੈਟ ਵਿੱਚ ਨਤੀਜੇ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਪਲੈਟਫਾਰਮ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਅਤੇ ਵਰਕਿੰਗ ਐਪ ਜਨਰੇਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਰਚਨਾਤਮਕ ਕਦਮਾਂ (ਯੋਜਨਾ ਮੋਡ, ਸਨੇਪਸ਼ਾਟ, ਰੋਲਬੈਕ) ਦੇ ਨਾਲ دوبਾਰ-ਦੋਹਰਾਅ ਕਰਦੇ ਹੋ ਤਾਂ ਬਦਲਾਵ ਦਿਸ਼ਾ ਤੋਂ ਬਾਹਰ ਨਾ ਚਲੇ ਜਾਣ।
ਅਨੇਕ “ਸੰਵਾਦਾਤਮਕ” ਟੂਲ ਹੇਠਾਂ ਨਾਲ ਚਲਦੇ ਹਨ:
ਟੈਂਪਲੇਟਸ ਅਤੇ ਕਨੈਕਟਰ ਤੁਹਾਡੇ ਕੋਲ Specify ਕਰਨ ਦੀ ਮਾਤਰਾ ਘਟਾਉਂਦੇ ਹਨ। ਜਨਰੇਟ ਕੀਤਾ ਕੋਡ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਤੁਹਾਡਾ ਨਤੀਜਾ ਕਿੰਨਾ ਪੋਰਟੇਬਲ ਅਤੇ ਮੈਨਟੇਨੇਬਲ ਹੈ।
ਜੇ ਤੁਸੀਂ ਉਹ ਚੀਜ਼ ਮਲਕੀਅਤ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਬਣਾਉਂਦੇ ਹੋ, ਤਾਂ ਉਹ ਪਲੈਟਫਾਰਮ ਪ੍ਰਾਥਮਿਕਤਾ ਦਿਓ ਜੋ ਇੱਕ ਆਮ ਸਟੈਕ ਜਨਰੇਟ ਕਰਦਾ ਅਤੇ ਕੋਡ ਐਕਸਪੋਰਟ ਕਰਨ ਦੀ ਆਜ਼ਾਦੀ ਦਿੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, Koder.ai React ਨੂੰ ਵੈੱਬ ਲਈ, Go + PostgreSQL ਬੈਕਐਂਡ ਲਈ, ਅਤੇ Flutter ਮੋਬਾਈਲ ਲਈ ਫੋਕਸ ਕਰਦਾ ਹੈ — ਇਸ ਲਈ ਆਉਟਪੁੱਟ ਇੱਕ ਆਮ ਸੌਫਟਵੇਅਰ ਪ੍ਰੋਜੈਕਟ ਵਰਗਾ ਲੱਗਦਾ ਹੈ ਨਾ ਕਿ ਇੱਕ ਲਾਕ-ਇਨ ਕਨਫਿਗਰੇਸ਼ਨ।
ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ AI ਟੂਲ ਨੂੰ "ਇਕ ਐਪ ਬਣਾਓ" ਕਹਿੰਦੇ ਹੋ, ਉਹ ਖੁਸ਼ੀ-ਖੁਸ਼ੀ ਲੰਬੀ ਫੀਚਰ ਲਿਸਟ ਜਨਰੇਟ ਕਰ ਦੇਵੇਗਾ। ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਫੀਚਰ ਲਿਸਟਾਂ ਇਹ ਨਹੀਂ ਦੱਸਦੀਆਂ ਕਿ ਐਪ ਕਿਉਂ ਮੌਜੂਦ ਹੈ, ਇਹ ਕਿਸ ਲਈ ਹੈ, ਜਾਂ ਤੁਸੀਂ ਕਿਵੇਂ ਜਾਣੋਗੇ ਕਿ ਇਹ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ। ਇੱਕ ਵਾਜ਼ਿਬ ਸਮੱਸਿਆ ਬਿਆਨ ਇਹ ਸਾਰਾ ਦਿੰਦਾ ਹੈ।
ਆਪਣਾ ਸਮੱਸਿਆ ਬਿਆਨ ਇਸ ਤਰ੍ਹਾਂ ਲਿਖੋ:
ਲਈ [ਮੁੱਖ ਉਪਭੋਗੀ], ਜੋ [X ਨਾਲ ਮੁਸ਼ਕਲ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ], ਅਸੀਂ [ਨਤੀਜਾ Y ਦਿੰਦੇ ਹਾਂ] ਤਾਂ ਜੋ [ਨਾਪਣਯੋਗ ਲਾਭ Z].
ਉਦਾਹਰਨ:
ਇੱਕ ਛੋਟੀ ਕਲੀਨਿਕ ਦੇ ਰਿਸੈਪਸ਼ਨਿਸਟ ਲਈ, ਜੋ ਮਰੀਜ਼ਾਂ ਨੂੰ ਐਪਿੰਟਮੈਂਟ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਬਹੁਤ ਸਮਾਂ ਲਗਾਉਂਦਾ ਹੈ, ਅਸੀਂ ਆਟੋਮੇਟਿਕ SMS ਪੁਸ਼ਟੀ ਭੇਜਾਂਗੇ ਤਾਂ ਜੋ 30 ਦਿਨਾਂ ਵਿੱਚ ਨੋ-ਸ਼ੋਜ਼ 20% ਘਟ ਜਾਣ।
ਇਕੋ-ਇੱਕ ਪੈਰਾਗ੍ਰਾਫ AI (ਅਤੇ ਤੁਹਾਨੂੰ) ਇੱਕ ਲਕਸ਼ਤ ਨਿਸ਼ਾਨ ਦਿੰਦਾ ਹੈ। ਫੀਚਰ ਹੁਣ "ਮੰਜ਼ਿਲ ਤੱਕ ਪਹੁੰਚਣ ਦੇ ਸੰਭਵ ਤਰੀਕੇ" ਬਣ ਜਾਂਦੇ ਹਨ, ਨਾ ਕਿ ਮੰਜ਼ਿਲ ਖੁਦ।
ਇਰਾਦਾ ਰੱਖ ਕੇ ਇੱਕ ਸੰਕੁਚਿਤ ਉਪਭੋਗੀ ਸਮੱਸਿਆ ਅਤੇ ਇੱਕ ਪ੍ਰਧਾਨ ਉਪਭੋਗੀ ਤੇ ਸ਼ੁਰੂ ਕਰੋ। ਜੇ ਤੁਸੀਂ ਦਰਸ਼ਕਾਂ ਨੂੰ ਮਿਕਸ ਕਰ ਦਿਤਾ ("ਗਾਹਕ, ਐਡਮਿਨ, ਫਾਇਨੈਂਸ"), ਤਾਂ AI ਇੱਕ ਜਨਰਿਕ ਸਿਸਟਮ ਬਣਾ ਦੇਵੇਗਾ ਜੋ ਪੂਰਾ ਕਰਨਾ ਔਖਾ ਹੋਵੇਗਾ।
ਪੂਰਾ ਹੋਣ ਦੀ ਪਰਿਭਾਸ਼ ਇੱਕ ਵਾਕ ਵਿੱਚ ਦਿਓ — ਜੋ ਮਾਪ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਉਸਨੂੰ ਡਿਜ਼ਾਇਨ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।
ਹੁਣ AI ਨੂੰ coherent ਬਣਾਉਣ ਲਈ ਕਾਫੀ ਢਾਂਚਾ ਸ਼ਾਮِل ਕਰੋ:
ਜੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਇਹ ਕਰਦੇ ਹੋ, ਤੁਹਾਡੇ ਪ੍ਰੌਂਪਟ ਸਾਫ਼ ਹੋ ਜਾਂਦੇ ਹਨ ("ਉਹ ਸਭ ਤੋਂ ਛੋਟੀ ਚੀਜ਼ ਬਣਾਓ ਜੋ Z ਪ੍ਰਾਪਤ ਕਰੇ"), ਅਤੇ ਤੁਹਾਡਾ ਪ੍ਰੋਟੋਟਾਈਪ ਜ਼ਿਆਦਾ ਸੰਭਾਵਨਾ ਨਾਲ ਉਹੀ ਹੋਵੇਗਾ ਜੋ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਸੀ।
ਜੇ ਤੁਸੀਂ ਆਪਣੀ 아이dea ਇਕ ਸਾਥੀ ਨੂੰ ਸਪਸ਼ਟ ਤਰੀਕੇ ਨਾਲ ਸਮਝਾ ਸਕਦੇ ਹੋ, ਤਾਂ ਆਮ ਤੌਰ 'ਤੇ ਤੁਸੀਂ AI ਨੂੰ ਵੀ ਸਮਝਾ ਸਕਦੇ ਹੋ — ਥੋੜ੍ਹੀ ਹੋਰ ਢਾਂਚੇਦਾਰ। ਮਕਸਦ fancy "prompt engineering" ਨਹੀਂ, ਬਲਕਿ ਮਾਡਲ ਨੂੰ ਕਾਫੀ ਸੰਦਰਭ ਦੇਣਾ ਹੈ ਤਾਂ ਜੋ ਉਹ ਚੰਗੇ ਫੈਸਲੇ ਕਰ ਸਕੇ, ਅਤੇ ਉਹ ਫੈਸਲੇ ਦਿਖਾਈ ਦੇਣ ਤਾਂ ਜੋ ਤੁਸੀਂ ਠੀਕ ਕਰ ਸਕੋ।
ਆਪਣੇ ਪ੍ਰੌਂਪਟ ਦੀ ਸ਼ੁਰੂਆਤ ਚਾਰ ਬਲਾਕਾਂ ਨਾਲ ਕਰੋ:
ਇਸ ਨਾਲ ਬੈਕ-ਅਤੇ-ਫੋਰਥ ਘੱਟ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ AI ਤੁਹਾਡੇ 아이dea ਨੂੰ ਫਲੋ, ਸਕ੍ਰੀਨਾਂ, ਡੇਟਾ ਫੀਲਡ, ਅਤੇ ਵੈਲੀਡੇਸ਼ਨ ਨਾਲ ਮੇਪ ਕਰ ਸਕਦਾ ਹੈ।
ਇੱਕ "Constraints" ਬਲਾਕ ਸ਼ਾਮِل ਕਰੋ ਜੋ ਉੱਤਰ ਦੇਵੇ:
ਇਕੋ ਇੱਕ ਲਾਈਨ ਜਿਵੇਂ "ਕੋਈ ਨਜ਼ਦੀਕੀ ਡੇਟਾ ਸਾਡੇ ਅੰਦਰੂਨੀ ਟੂਲਾਂ ਤੋਂ ਬਾਹਰ ਨਹੀਂ ਜਾਵੇ" AI ਦੀ ਪ੍ਰਸਤਾਵਿਤ ਚੀਜ਼ ਨੂੰ ਬਦਲ ਸਕਦੀ ਹੈ।
ਆਪਣੇ ਪ੍ਰੌਂਪਟ ਦਾ ਅਖੀਰ ਰੱਖੋ: “ਕਿਸੇ ਚੀਜ਼ ਨੂੰ ਜਨਰੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਮੇਰੇ ਕੋਲ 5–10 ਸਪਸ਼ਟ ਕਰਨ ਵਾਲੇ ਸਵਾਲ ਪੁੱਛੋ।” ਇਹ ਇੱਕ ਬੇਹੋਸਲਾ ਪਰ ਪਹਿਲਾ ਡਰਾਫਟ ਰੋਕਦਾ ਹੈ ਅਤੇ ਛੁਪੇ ਫੈਸਲਿਆਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਸਾਹਮਣੇ ਲਿਆਉਂਦਾ ਹੈ।
ਜਿਵੇਂ ਤੁਸੀਂ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦਿੰਦੇ ਹੋ, AI ਨੂੰ ਕਹੋ ਕਿ ਚੈਟ ਵਿੱਚ ਇੱਕ ਛੋਟੀ Decision Log ਰੱਖੇ:
ਫਿਰ ਹਰ ਵਾਰੀ ਜਦੋਂ ਤੁਸੀਂ "X ਚੇੰਜ ਕਰੋ" ਕਹੋ, AI ਲੌਗ ਅਪਡੇਟ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਬਿਲਡ ਸੰਰਬੱਧ ਰਹਿੰਦਾ ਹੈ ਇਸਦੇ ਬਦਲੇ ਦਿਸ਼ਾ 'ਤੇ ਨਿਹਹਾਂ।
ਜੇ ਤੁਸੀਂ AI ਨੂੰ ਇੱਕ ਵਾਰੀ-ਕਾ-ਨੌਕਰੀ ਐਪ ਜਨਰੇਟਰ ਸਮਝ ਕੇ ਵਰਤੋਂਗੇ, ਤਾਂ ਅਕਸਰ ਤੁਸੀਂ ਐਸੀ ਚੀਜ਼ ਮਿਲੇਗੀ ਜੋ ਲਗਦੀ ਤਾਂ ਠੀਕ ਹੈ ਪਰ ਅਸਲ ਹਾਲਤ 'ਚ ਟੁੱਟ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਚੰਗਾ ਤਰੀਕਾ ਇੱਕ ਛੋਟੀ, ਦੁਹਰਾਊ ਲੂਪ ਹੈ: ਵਰਣਨ ਕਰੋ, ਜਨਰੇਟ ਕਰੋ, ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਠੀਕ ਕਰੋ।
ਉਸ ਸਧਾਰਨ ਯਾਤਰਾ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਜੋ ਉਪਭੋਗੀ ਨੂੰ ਪੂਰੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ("ਹੈਪੀ ਪਾਥ"). ਇਸਨੂੰ ਇੱਕ ਛੋਟੀ ਕਹਾਣੀ ਵਾਂਗ ਲਿਖੋ:
AI ਨੂੰ ਕਹੋ ਕਿ ਉਹ ਇਸ ਕਹਾਣੀ ਨੂੰ ਸਕ੍ਰੀਨ ਦੀ ਸੂਚੀ ਅਤੇ ਹਰ ਸਕ੍ਰੀਨ ਦੇ ਬਟਨ/ਫੀਲਡ ਵਿੱਚ ਬਦਲ ਦੇ। ਸੰਕੁਚਿਤ ਰਹੋ: "ਲੌਗਿਨ ਸਕ੍ਰੀਨ: ਈਮੇਲ + ਪਾਸਵਰਡ + ਐਰਰ ਸੁਨੇਹਾ" ਫਰਮਾ ਵਿੱਚ, ਨਾ ਕਿ "ਸੁਰੱਖਿਅਤ ਪ੍ਰਮਾਣਿਕਤਾ"।
ਜਦ ਸਕ੍ਰੀਨਾਂ ਸਪਸ਼ਟ ਹੋ ਜਾਣ, ਫੋਕਸ ਉਸ ਜਾਣਕਾਰੀ 'ਤੇ ਕਰੋ ਜੋ ਤੁਹਾਡੇ ਪ੍ਰੋਟੋਟਾਈਪ ਨੂੰ ਸਟੋਰ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।
AI ਨੂੰ ਪ੍ਰੌਂਪਟ ਕਰੋ: “ਇਨ੍ਹਾਂ ਸਕ੍ਰੀਨਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਡੇਟਾ ਫੀਲਡ, ਸੈਂਪਲ ਮੁੱਲ, ਅਤੇ ਵੈਲੀਡੇਸ਼ਨ ਨਿਯਮ ਪ੍ਰਸਤਾਵਿਤ ਕਰੋ।” ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ تلاش ਕਰ ਰਹੇ ਹੋ:
ਇਹ ਕਦਮ ਸਮਾਤਿ ਪ੍ਰੋਟੋਟਾਈਪ ਸਮੱਸਿਆ ਹੈ ਜਿੱਥੇ UI ਮੌਜੂਦ ਹੁੰਦਾ ਹੈ ਪਰ ਡੇਟਾ ਮਾਡਲ ਅਸਪਸ਼ਟ।
ਹੁਣ ਇੱਕ ਕੰਮ ਦੇ ਟੁਕੜੇ ਲਈ ਪੁੱਛੋ, ਪੂਰੇ ਉਤਪਾਦ ਲਈ ਨਹੀਂ। ਦੱਸੋ ਕਿ ਕਿਹੜਾ ਸਿੰਗਲ ਫਲੋ end-to-end ਵਾਇਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਉਦਾਹਰਨ: “ਆਈਟਮ ਬਣਾਵੋ → ਸੇਵ ਕਰੋ → ਪੁਸ਼ਟੀ ਵੇਖੋ”)। ਜੇ ਟੂਲ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਤਾਂ ਸੀਡ ਕੀਤੀ ਸੈਂਪਲ ਡੇਟਾ ਮੰਗੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਤੁਰੰਤ ਕਲਿੱਕ ਕਰ ਸਕੋ।
ਜੇ ਤੁਸੀਂ Koder.ai ਵਰਗੇ ਪਲੈਟਫਾਰਮ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਇਥੇ ਉਸ ਦੀਆਂ ਬਿਲਟ-ਇਨ ਹੋਸਟਿੰਗ, ਡਿਪਲੋਯਮੈਂਟ, ਅਤੇ ਕੋਡ ਐਕਸਪੋਰਟ ਵਰਗੀਆਂ ਸੁਵਿਧਾਵਾਂ ਮਹੱਤਵਪੂਰਨ ਹੋ ਸਕਦੀਆਂ ਹਨ: ਤੁਸੀਂ ਲਾਈਵ ਵਾਤਾਵਰਣ ਵਿੱਚ ਫਲੋ ਨੂੰ ਵੈਧ ਕਰ ਸਕਦੇ ਹੋ, ਫਿਰ ਫੈਸਲਾ ਕਰੋ ਕਿ ਕੀ ਪਲੈਟਫਾਰਮ ਵਿੱਚ ਹੀ ਦੁਹਰਾਉ ਜਾਂ ਇੰਜੀਨੀਅਰਿੰਗ ਨੂੰ ਸੌਂਪਣਾ ਹੈ।
ਪ੍ਰੋਟੋਟਾਈਪ ਨੂੰ ਉਪਭੋਗੀ ਵਾਂਗ ਚਲਾਓ ਅਤੇ ਨੋਟਸ ਬਹੁਤ ਹੀ ਸੰક્ષਿਪ ਰੱਖੋ:
ਇਨ੍ਹਾਂ ਨੋਟਸ ਨੂੰ ਛੋਟੇ ਬੈਚਾਂ ਵਿੱਚ AI ਨੂੰ ਵਾਪਸ ਖਿਲਾਓ। ਹਦਫ਼ ਲਗਾਤਾਰ ਤਰੱਕੀ ਹੈ: ਇੱਕ ਸਪਸ਼ਟ ਬਦਲਾਅ, ਇੱਕ ਅਪਡੇਟ, ਇੱਕ ਰੀ-ਟੈਸਟ। ਇਹ ਲਹਿਰ ਹੈ ਜੋ "ਚੈਟ ਵਾਲੀਆਂ ਆਈਡੀਆ" ਨੂੰ ਅਜਿਹਾ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਂਦੀ ਜੋ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਅੰਕਲਣ ਕਰ ਸਕੋ।
ਹੇਠਾਂ ਤਿੰਨ ਛੋਟੀ ਬਣਤਾਂ ਹਨ ਜੋ ਤੁਸੀਂ ਇੱਕ ਹੀ ਚੈਟ ਵਿੱਚ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ। “ਤੁਸੀਂ ਕੀ ਕਹੋ” ਟੈਕਸਟ ਨੂੰ ਕਾਪੀ ਕਰੋ, ਫਿਰ ਨਾਮ, ਫੀਲਡ, ਅਤੇ ਨਿਯਮ ਆਪਣੀ ਸਥਿਤੀ ਅਨੁਸਾਰ ਅਨੁਕੂਲ ਕਰੋ।
ਤੁਸੀਂ ਕੀ ਕਹੋ: “ਇੱਕ ਹਲਕਾ-ਫੁਲਕਾ ‘Habit + Mood Tracker’ ਬਣਾਓ। ਫੀਲਡ: date (ਲਾਜ਼ਮੀ), habit (ਪਿਕ ਲਿਸਟ: Sleep, Walk, Reading), did_it (ਹਾਂ/ਨਹੀਂ), mood (1–5), notes (ਵਿਕਲਪਕ)। ਵੇਖ: (1) Today, (2) This week grouped by habit, (3) Mood trends. ਫਿਲਟਰ: current week ਲਈ صرف ‘did_it = no’ ਦਿਖਾਓ। ਡੇਟਾ ਮਾਡਲ ਅਤੇ ਇੱਕ ਸਧਾਰਨ UI ਜਨਰੇਟ ਕਰੋ।”
AI ਜੋ ਨਿਕਾਲਦਾ ਹੈ: ਇੱਕ ਸੁਝਾਇਆ ਹੋਇਆ ਟੇਬਲ/ਸਕીમਾ, ਇੱਕ ਮੂਲ ਸਕ੍ਰੀਨ ਲੇਆਉਟ, ਅਤੇ ਟੂਲ ਦੇ ਆਧਾਰ 'ਤੇ ਤਿੰਨ ਵੇਖ ਅਤੇ ਫਿਲਟਰ ਲਈ ਨੂੰ-ਕਾਪੀ-ਪੇਸਟ ਕੰਫਿਗ/ਕੋਡ।
ਤੁਸੀਂ ਜੋ ਜਾਂਚਦੇ ਹੋ: ਫੀਲਡ ਟਾਈਪ (ਤਾਰੀਖ ਬਨਾਮ ਟੈਕਸਟ), ਡਿਫ਼ਾਲਟ (ਅੱਜ ਦੀ ਤਾਰੀਖ), ਅਤੇ ਫਿਲਟਰ ਲਈ ਠੀਕ ਸਮਾਂ ਵਿੰਡੋ (ਹਫ਼ਤਾ ਸੋਮਵਾਰ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਜਾਂ ਐਤਵਾਰ)।
ਤੁਸੀਂ ਕੀ ਕਹੋ: “ਇੱਕ ‘Client Intake’ ਫਾਰਮ ਬਣਾਓ ਜਿਸ ਵਿੱਚ: name, email, phone, service_needed, preferred_date, budget_range, consent checkbox। ਜਮ੍ਹਾਂ ਕਰਨ 'ਤੇ: ਸਪ੍ਰੈਡਸੀਟ/ਟੇਬਲ ਵਿੱਚ ਸੇਵ ਕਰੋ ਅਤੇ ਮੈਨੂੰ ਇੱਕ ਈਮੇਲ ਅਤੇ ਕਲਾਇਂਟ ਨੂੰ ਇੱਕ ਆਟੋ-ਰਿਪਲਾਈ ਭੇਜੋ। ਈਮੇਲ ਸਬਜੈਕਟ/ਬਾਡੀ ਟੈਂਪਲੇਟ ਸ਼ਾਮِل ਕਰੋ।”
AI ਜੋ ਨਿਕਾਲਦਾ ਹੈ: ਇੱਕ ਫਾਰਮ, ਇੱਕ ਸਟੋਰੇਜ ਡੈਸਟੀਨੇਸ਼ਨ, ਅਤੇ ਦੋ ਈਮੇਲ ਟੈਂਪਲੇਟ ਵੈਰੀਏਬਲ ਪਲੇਸਹੋਲਡਰਾਂ ਨਾਲ।
ਤੁਸੀਂ ਜੋ ਜਾਂਚਦੇ ਹੋ: ਈਮੇਲ ਡਿਲਿਵਰੇਬਿਲਿਟੀ (from/reply-to), ਸਹਿਮਤੀ ਟੈਕਸਟ, ਅਤੇ ਇਹ ਕਿ ਨੋਟੀਫਿਕੇਸ਼ਨ ਹਰ ਸਮਰਪਣ 'ਤੇ ਇੱਕ ਵਾਰੀ ਹੀ ਟ੍ਰਿਗਰ ਹੁੰਦੀ ਹੈ।
ਤੁਸੀਂ ਕੀ ਕਹੋ: “ਮੇਰੇ ਕੋਲ ਇੱਕ CSV ਹੈ ਜਿਸ ਵਿੱਚ: Full Name, Phone, State। ਫੋਨ ਨੂੰ E.164 ਵਿੱਚ ਨਾਰਮਲਾਈਜ਼ ਕਰੋ, ਵਾਧੂ ਖਾਲੀ ਥਾਂਆਂ ਹਟਾਓ, ਨਾਮਾਂ ਨੂੰ Title-case ਕਰੋ, ਅਤੇ ਰਾਜ ਦੇ ਨਾਮਾਂ ਨੂੰ 2-ਅੱਖਰ ਕੋਡ 'ਤੇ ਮੈਪ ਕਰੋ। ਸਾਫ਼ ਕੀਤੀ CSV ਅਤੇ ਬਦਲੇ ਗਏ ਰੋਜ਼ ਦਾ ਇੱਕ ਸਾਰਾਂਸ਼ ਦਿਓ।”
AI ਜੋ ਨਿਕਾਲਦਾ ਹੈ: ਇੱਕ ਸਕ੍ਰਿਪਟ (ਅਕਸਰ Python) ਜਾਂ ਸਪ੍ਰੈਡਸੀਟ ਕਦਮ, ਨਾਲ-ਨਾਲ ਇੱਕ ‘changes report’ ਵਿਚਾਰ।
ਤੁਸੀਂ ਜੋ ਜਾਂਚਦੇ ਹੋ: ਪਹਿਲਾਂ 20 ਰੋਜ਼ 'ਤੇ ਚਲਾਓ, ਏਜ ਕੇਸਾਂ (ਗਾਇਬ ਫੋਨ, एक्सਟੈਂਸ਼ਨ) ਨੂੰ ਚੈੱਕ ਕਰੋ, ਅਤੇ ਯਕੀਨ ਕਰੋ ਕਿ ਕੋਈ ਕਾਲਮ ਅਣਗੌਲ ਨਾ ਹੋਵੇ।
AI ਤੁਹਾਨੂੰ ਜ਼ਲਦੀ ਨਾਲ ਵਰਕਿੰਗ ਡੈਮੋ ਦੇ ਸਕਦਾ ਹੈ — ਪਰ ਡੈਮੋ ਆਮ ਤੌਰ 'ਤੇ ਨਾਜੁਕ ਹੁੰਦਾ ਹੈ। ਆਮ ਨੁਕਸਾਨ ਦਾ ਤਰੀਕਾ ਉਹ ਬਣਾਇਆ ਗਿਆ ਹੈ ਜੋ ਸਿਰਫ਼ ਉਸੀ ਸ਼ਬਦਬੰਦੀ 'ਤੇ ਸਫਲ ਹੁੰਦਾ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਟੈਸਟ ਕੀਤਾ। ਕਿਸੇ ਭਰੋਸੇਯੋਗ ਚੀਜ਼ ਨੂੰ ਸ਼ਿਪ ਕਰਨ ਲਈ, ਹਰ AI-ਜਨਰੇਟ ਕੀਤੇ ਨਤੀਜੇ ਨੂੰ ਪਹਿਲਾ ਖ਼ਾਕਾ ਮੰਨੋ ਅਤੇ ਉਸਨੂੰ ਜਾਣ-ਬੂਝ ਕੇ ਟੁੱਟਾਉ।
ਜਦੋਂ ਕੋਡ “ਚੱਲਦਾ” ਵੀ ਹੋਵੇ, ਲਾਜਿਕ ਅਕਸਰ ਅਧੂਰਾ ਹੋ ਸਕਦਾ ਹੈ। AI ਨੂੰ ਪੂਛੋ ਕਿ ਉਹ ਅਨੁਮਾਨ ਕੀ ਕਰ ਰਿਹਾ ਹੈ ਅਤੇ ਏਜ ਕੇਸ ਦੀ ਸੂਚੀ ਦਿਓ: ਖਾਲੀ ਫੀਲਡ, ਬਹੁਤ ਲੰਬੇ ਇਨਪੁੱਟ, ਗਾਇਬ ਰਿਕਾਰਡ, ਟਾਈਮਜ਼ੋਨ, ਮੁਦਰਾ ਗੋਲ-ਚੱਕਰ, ਨੈੱਟਵਰਕ ਟਾਇਮਆਉਟ, ਅਤੇ ਇੱਕੱਠ-ਸੰਪਾਦਨ।
ਇੱਕ ਮਦਦਗਾਰ ਆਦਤ: ਇੱਕ ਫੀਚਰ ਜਨਰੇਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, AI ਨੂੰ ਪੁਛੋ “ਕੀ ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ” ਦੀ ਛੋਟੀ ਚੈਕਲਿਸਟ, ਫਿਰ ਹਰ ਆਇਟਮ ਨੂੰ ਖੁਦ ਵੈਰੀਫਾਈ ਕਰੋ।
ਅਧਿਕਤਰ AI-ਬਨਾਏ ਹੋਏ ਐਪ ਬੁਨਿਆਦੀਆਂ ਤੇ ਫੇਲ ਹੁੰਦੇ ਹਨ, ਨਾ ਕਿ ਸ਼ਾਨਦਾਰ ਹਮਲਿਆਂ 'ਤੇ। ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਜਾਂਚ ਕਰੋ:
ਜੇ ਤੁਸੀਂ ਅਣਿਸ਼ਚਿਤ ਹੋ, ਤਾਂ AI ਨੂੰ ਪੁੱਛੋ: “ਮੈਨੂੰ ਦਿਖਾਓ ਕਿ ਕਿੱਥੇ auth ਲਾਗੂ ਕੀਤੀ ਗਈ ਹੈ, ਕਿਹੜੇ ਫਾਇਲਾਂ/ਲਾਈਨਾਂ ਵਿੱਚ ਸੀਕ੍ਰੇਟਸ ਰਹਿੰਦੇ ਹਨ, ਅਤੇ ਇਨਪੁੱਟ ਕਿਵੇਂ ਵੈਲਿਡੇਟ ਹੁੰਦਾ ਹੈ।” ਜੇ ਇਹ ਨਿਰਦਿਸ਼ਟ ਫਾਇਲਾਂ/ਲਾਈਨਾਂ ਨੂੰ ਨਹੀਂ ਦਿਖਾ ਸਕਦਾ, ਤਾਂ ਕੰਮ ਮੁਕੰਮਲ ਨਹੀਂ ਹੈ।
ਹੈਪੀ ਪਾਥ ਬਗਾਂ ਨੂੰ ਛੁਪਾ ਲੈਂਦਾ ਹੈ। ਛੋਟੀ "ਨਾਸਟੀ" ਟੈਸਟ ਕੇਸ ਬਣਾਓ: ਖਾਲੀ ਮੁੱਲ, ਅਸਧਾਰਣ ਅੱਖਰ, ਬਹੁਤ ਵੱਡੇ ਨੰਬਰ, ਡੁਪਲੀਕੇਟ ਇਨਟਰੀਜ਼, ਅਤੇ ਗਲਤ ਕਿਸਮ ਦੀ ਫਾਈਲ। ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਯਥਾਰਥ (ਅਤੇ ਅਨੁਮਤ) ਸੈਂਪਲ ਡੇਟਾ ਹੈ, ਉਸਨੂੰ ਵਰਤੋਂ — ਕਈ ਮੁੱਦੇ ਸਿਰਫ਼ ਵਾਸਤਵਿਕ-ਦੁਨੀਆ ਦੀ ਗੰਦੀ ਨਾਲ ਹੀ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ।
ਚੁੱਪ ਚਪਟੀਆਂ ਨਾਕਾਮੀਆਂ ਮਹਿੰਗੀ ਗਲਤਫ਼ਹਮੀ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਯੂਜ਼ਰ ਲਈ ਸਪਸ਼ਟ ਐਰਰ ਸੁਨੇਹੇ ("ਭੁਗਤਾਨ ਅਸਫਲ — ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ") ਅਤੇ ਤੁਹਾਡੇ ਲਈ ਵਿਸਤ੍ਰਿਤ ਲੌਗਸ (ਰਿਕਵੈਸਟ IDs, ਟਾਈਮਸਟੈਂਪ, ਅਤੇ ਨਾਕਾਮ ਕਦਮ) ਸ਼ਾਮِل ਕਰੋ। ਜਦੋਂ ਤੁਸੀਂ AI ਨੂੰ ਲੋਗਿੰਗ ਸ਼ਾਮِل ਕਰਨ ਲਈ ਕਹੋ, ਦੱਸੋ ਕਿ ਤੁਹਾਨੂੰ ਬਾਅਦ ਵਿੱਚ ਡੀਬੱਗ ਕਰਨ ਲਈ ਕੀ ਚਾਹੀਦਾ ਹੈ: (ਸੈਨਾਈਟਾਈਜ਼ਡ) ਇਨਪੁੱਟ, ਕੀ ਫੈਸਲੇ ਲਏ ਗਏ, ਅਤੇ ਬਾਹਰੀ API ਜਵਾਬ।
ਜਦੋਂ ਗੁਣਵੱਤਾ ਤੁਹਾਡਾ ਲਕਸ਼ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ "ਸਿਰਫ਼ ਬਿਹਤਰ ਪ੍ਰੌਂਪਟ" ਨਹੀਂ ਕਰ ਰਹੇ — ਤੁਸੀਂ ਇੱਕ ਸੇਫਟੀ ਨੈੱਟ ਤਿਆਰ ਕਰ ਰਹੇ ਹੋ।
AI ਕੋਡ ਤੇਜ਼ੀ ਨਾਲ ਜਨਰੇਟ ਕਰਦਾ ਹੈ, ਪਰ ਅਸਲ ਤੇਜ਼ੀ ਉਸ ਵੇਲੇ ਆਉਂਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਸਹਿਯੋਗੀ ਵਾਂਗ ਦਿਖਾਈ ਦਿਓ: ਛੋਟਾ ਸੰਦਰਭ ਦਿਓ, ਯੋਜਨਾ ਮੰਗੋ, ਬਦਲਾਅ ਦੀ ਸਮੀਖਿਆ ਕਰੋ, ਅਤੇ ਇੱਕ ਟਰੇਲ ਰੱਖੋ ਜਿਸਨੂੰ ਤੁਸੀਂ ਰੋਲਬੈਕ ਕਰ ਸਕੋ।
ਲੰਬੇ ਪ੍ਰੌਂਪਟ ਮਹੱਤਵਪੂਰਨ ਵੇਰਵਿਆਂ ਨੂੰ ਛੁਪਾ ਦਿੰਦੇ ਹਨ। ਇੱਕ "v1, v2, v3" ਆਦਤ ਵਰਤੋ:
ਇਸ ਨਾਲ ਕੋਸ਼ਿਸ਼ਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨੀ ਆਸਾਨ ਹੁੰਦੀ ਹੈ ਅਤੇ ਨਵੇਂ ਫੀਚਰਾਂ ਵਿੱਚ ਡ੍ਰਿਫਟਿੰਗ ਰੁਕਦੀ ਹੈ।
ਕਿਸੇ ਵੀ ਸੋਧ ਤੋਂ ਪਹਿਲਾਂ, AI ਨੂੰ ਪੂਛੋ ਕਿ ਉਹ ਕੀ ਮੰਨਿਆ ਕਰਦਾ ਹੈ:
ਬਾਅਦ ਵਿੱਚ, ਜਾਂਚ-ਪੱਤਰ ਦੀ ਤਰ੍ਹਾਂ ਇਕ ਰੀਕੈਪ ਮੰਗੋ: ਛੇਤੀ-ਛੇਤੀ ਚੈਕਲਿਸਟ: ਛੇਤੀ-ਛੇਤੀ ਫਾਇਲਾਂ ਜਿਨ੍ਹਾਂ 'ਤੇ ਕੰਮ ਕੀਤਾ, ਫੰਕਸ਼ਨ ਬਦਲੇ, ਅਤੇ ਹੁਣ ਕੀ ਵੱਖਰਾ ਹੋਣਾ ਚਾਹੀਦਾ।
ਦੋਹਰਾਉਂ ਕਦਮ ਸੌਖੇ ਹੁੰਦੇ ਹਨ ਜਦ ਤੁਸੀਂ ਵਾਪਸੀ-ਯੋਗ ਹੋ:
ਜੇ ਤੁਸੀਂ ਇੱਕ ਸੰਵਾਦਾਤਮਕ ਬਿਲਡਰ ਵਰਤ ਰਹੇ ਹੋ ਜਿਸ ਵਿੱਚ ਸਨੇਪਸ਼ਾਟ ਅਤੇ ਰੋਲਬੈਕ (Koder.ai ਸਹਿਤ) ਹਨ, ਤਾਂ ਉਨ੍ਹਾਂ ਚੈਕਪੌਇੰਟਾਂ ਨੂੰ Git ਕਮਿਟ ਵਾਂਗ ਵਰਤੋਂ: ਛੋਟੇ, ਵਾਪਸੀ ਯੋਗ ਬਦਲਾਅ ਕਰੋ, ਅਤੇ "ਆਖਰੀ ਜਾਣ-ਪਛਾਣ-ਯੋਗ" ਵਰਜ਼ਨ ਸੁਰੱਖਿਅਤ ਰੱਖੋ।
"ਇਹ ਕੰਮ ਨਹੀਂ ਕਰਦਾ" ਦੀ ਥਾਂ, ਦਾਇਰਾ ਘਟਾਓ:
ਇਹ ਤਰੀਕਾ ਤੁਹਾਨੂੰ ਇੱਕ ਅਸਪਸ਼ਟ ਮੁੱਦੇ ਨੂੰ AI ਲਈ ਇੱਕ ਹੱਲਯੋਗ ਟਾਸਕ ਵਿਚ ਬਦਲਦਾ ਹੈ।
ਸੰਵਾਦਾਤਮਕ ਬਿਲਡਰ ਸਪਸ਼ਟ ਵਰਣਨ ਤੋਂ ਵਰਕਿੰਗ ਸਕ੍ਰੀਨ, ਬੁਨਿਆਦੀ ਲਾਜਿਕ, ਅਤੇ ਸਧਾਰਨ ਡੇਟਾ ਮਾਡਲ ਤੱਕ ਵਧੀਆ ਹਨ। ਪਰ ਇੱਕ ਪੁਆਇੰਟ ਆਉਂਦੀ ਹੈ ਜਿੱਥੇ "ਇਕ ਉਪਯੋਗੀ ਪ੍ਰੋਟੋਟਾਈਪ" "ਅਸਲ ਉਤਪਾਦ" ਬਣ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉੱਥੇ ਤੁਹਾਨੂੰ ਹੋਰ ਢਾਂਚਾ ਚਾਹੀਦਾ ਹੈ — ਅਤੇ ਕਈ ਵਾਰ ਇਕ ਮਨੁੱਖੀ ਡਿਵੈਲਪਰ।
ਕੁਝ ਖੇਤਰ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹਨ ਕਿ ਜਨਰੇਟ ਕੀਤੀ ਲਾਜਿਕ ਨੂੰ ਬਿਨਾਂ ਧਿਆਨ ਦੇ ਨਹੀਂ ਛੱਡਿਆ ਜਾ ਸਕਦਾ:
ਇੱਕ ਚੰਗਾ ਨਿਯਮ: ਜੇ ਕੋਈ ਗਲਤੀ ਗਾਹਕ ਸੰਪਰਕ ਜਾਂ ਇਕਾਉਂਟਿੰਗ ਸੁਧਾਰ ਦੀ ਲੋੜ ਪੈਦਾ ਕਰੇਗੀ, ਤਾਂ ਉਸਨੂੰ "ਮਨੁੱਖੀ-ਮਾਲਿਕੀ" ਸਮਝੋ, AI ਸਹਾਇਕ ਹੋ ਸਕਦਾ ਹੈ ਪਰ ਫੈਸਲਾ ਨਹੀਂ ਕਰੇ।
ਜਲਦੀ escalate ਕਰੋ (ਅਤੇ ਸਮਾਂ ਬਚਾਓ) ਜਦ ਤੁਸੀਂ ਮਿਲੋ:
ਜੇ ਤੁਸੀਂ ਇੱਕੋ ਹੀ ਪ੍ਰੌਂਪਟ ਨੂੰ ਵਾਰ-ਵਾਰ ਦੁਹਰਾ ਰਹੇ ਹੋ ਤਾਂ ਕਿ "ਉਸਨੂੰ ਵਿਵਹਾਰ ਲਈ ਮਜ਼ਬੂਤ ਬਣਾਇਆ ਜਾਵੇ", ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਡਿਜ਼ਾਇਨ ਜਾਂ ਆਰਕੀਟੈਕਚਰ ਮੁੱਦੇ ਨਾਲ ਜੂਝ ਰਹੇ ਹੋ, ਪ੍ਰੌਂਪਟ ਮੁੱਦਾ ਨਹੀਂ।
ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਡਿਵੈਲਪਰ ਸ਼ਾਮਿਲ ਕਰਦੇ ਹੋ, ਹੇਠਾਂ ਦੇ ਦਸਤਾਵੇਜ਼ ਦਿਓ:
ਇਹ ਹੈਂਡ-ਆਫ ਤੁਹਾਡੇ ਸੰਵਾਦਾਤਮਕ ਤਰੱਕੀ ਨੂੰ ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ ਉਸ ਤਰੀਕੇ ਨਾਲ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜੋ ਇਰਾਦਾ ਨਹੀਂ ਗੁਆਉਂਦਾ।
"ਗੱਲ ਕਰ ਕੇ" ਸੌਫਟਵੇਅਰ ਬਣਾਉਣਾ ਬੇਫਿਕ੍ਰ ਮਹਿਸੂਸ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਜਦੋਂ ਤੁਸੀਂ ਅਸਲ ਡੇਟਾ ਜਾਂ ਅੰਦਰੂਨੀ ਦਸਤਾਵੇਜ਼ ਕਿਸੇ AI ਟੂਲ ਵਿੱਚ ਪੇਸਟ ਕਰਦੇ ਹੋ, ਤੁਸੀਂ ਕਾਨੂੰਨੀ ਅਤੇ ਸੁਰੱਖਿਆ ਪ੍ਰਭਾਵਾਂ ਵਾਲਾ ਫੈਸਲਾ ਲੈਂਦੇ ਹੋ।
ਪ੍ਰੌਂਪਟ ਨੂੰ ਇਨ੍ਹਾਂ ਸੁਲੂਕਾਂ ਵਾਲੇ ਸੁਨੇਹਿਆਂ ਵਾਂਗ ਸਮਝੋ ਜੋ ਸਟੋਰ ਜਾਂ ਸਾਂਝੇ ਹੋ ਸਕਦੇ ਹਨ। ਗਾਹਕ ਰਿਕਾਰਡ, ਕਰਮਚਾਰੀ ਡੇਟਾ, ਸੀਕ੍ਰੇਟ, ਕ੍ਰੈਡੇੰਸ਼ਲ, ਜਾਂ ਕੋਈ ਵੀ ਨਿਯੰਤਰਿਤ ਚੀਜ਼ upload ਨਾ ਕਰੋ।
ਪ੍ਰਯੋਗੀ ਤਰੀਕਾ:
ਜੇ ਤੁਹਾਨੂੰ ਸੁਰੱਖਿਅਤ ਮੌਕ ਡੇਟਾ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਚਾਹੀਦੀ ਹੈ, ਤਾਂ ਮਾਡਲ ਨੂੰ ਆਪਣੇ ਸਕੀਮਾ ਤੋਂ ਮੌਕ ਡੇਟਾ ਬਣਾਉਣ ਨੂੰ ਕਹੋ, ਬਜਾਏ ਪ੍ਰੋਡਕਸ਼ਨ ਨਿਰਯਾਤ ਨੂੰ ਪੇਸਟ ਕਰਨ।
ਹਰ AI ਟੂਲ ਡੇਟਾ ਨੂੰ ਇੱਕੋ ਜ਼ਰਾ ਨਹੀਂ ਸੰਭਾਲਦਾ। ਵਰਤੋਂ ਤੋਂ ਪਹਿਲਾਂ ਪੁਸ਼ਟੀ ਕਰੋ:
ਜਦ ਉਪਲਬਧ ਹੋਵੇ, ਬਿਜ਼ਨੇਸ ਪਲਾਨਾਂ ਤਰਜੀਹ ਦਿਓ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਐਡਮਿਨ ਕੰਟਰੋਲ ਅਤੇ opting-out ਵਿਕਲਪ ਸਪਸ਼ਟ ਹੋਣ।
AI ਪਾਠ ਨੂੰ ਸੰਖੇਪ ਕਰ ਸਕਦਾ ਹੈ ਜਾਂ ਬਦਲ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਤੁਹਾਨੂੰ ਉਹ ਹੱਕ ਨਹੀਂ ਦਿੰਦਾ ਜੋ ਤੁਹਾਡੇ ਕੋਲ ਨਹੀਂ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ ਪੇਸਟ ਕਰਦੇ ਹੋ:
ਜੇ ਤੁਸੀਂ ਕੋਡ "ਆਧਾਰ" 'ਤੇ ਜਨਰੇਟ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਸਰੋਤ ਨੂੰ ਦਰਜ਼ ਕਰੋ ਅਤੇ ਲਾਇਸੈਂਸ ਰੂਲ ਜਾਂਚੋ।
ਅੰਦਰੂਨੀ ਟੂਲਾਂ ਲਈ, ਇੱਕ ਸਧਾਰਾ ਗੇਟ ਸਥਾਪਤ ਕਰੋ: ਇੱਕ ਵਿਅਕਤੀ ਡੇਟਾ ਹੈਂਡਲਿੰਗ, ਅਧਿਕਾਰ, ਅਤੇ ਨਿਰਭਰਤਾ ਦੇਖੇਗਾ ਪਹਿਲਾਂ ਕਿ ਕੁਝ ਵਿਸ਼ਾਲ ਤੌਰ 'ਤੇ ਇੱਕ ਛੋਟੀ ਟੀਮ ਤੋਂ ਬਾਹਰ ਸਾਂਝਾ ਕੀਤਾ ਜਾਵੇ। ਇੱਕ ਛੋਟੀ ਟੈਮਪਲੇਟ ਟੀਮ ਵਿਕੀ ਜਾਂ ਏਕ ਸਫ਼ਾ ਆਮਤੌਰ 'ਤੇ ਸਭ ਤੋਂ ਆਮ ਗਲਤੀਆਂ ਰੋਕਣ ਲਈ ਕਾਫੀ ਹੁੰਦਾ ਹੈ।
ਸ਼ਿਪਿੰਗ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ "ਇੱਕ ਕੁੱਲ-ਕੈੂਲ ਪ੍ਰੋਟੋਟਾਈਪ" ਇੱਕ ਐਸੀ ਚੀਜ਼ ਬਣ ਜਾਂਦੀ ਜਿਸ 'ਤੇ ਲੋਕ ਭਰੋਸਾ ਕਰ ਸਕਦੇ ਹਨ। AI-ਬਣਾਇਆ ਸੌਫਟਵੇਅਰ ਨਾਲ, ਪ੍ਰੌਂਪਟਾਂ ਨੂੰ ਸਦਾ ਸੁਧਾਰਦੇ ਰਹਿਣ ਦਾ ਲੁਚ ਹੋ ਸਕਦਾ ਹੈ — ਇਸ ਲਈ ਸ਼ਿਪਿੰਗ ਨੂੰ ਇੱਕ ਸਪਸ਼ਟ ਮਾਈਲਸਟੋਨ ਮੰਨੋ, ਨਾ ਕਿ ਜ਼ਜ਼ਬਾਤ।
ਇਕ ਐਸਾ ਪਰਿਭਾਸ਼ ਲਿਖੋ ਜੋ ਇੱਕ ਗੈਰ-ਟੈਕਨੀਕਲ ਸਾਥੀ ਵੀ ਜਾਂਚ ਸਕੇ। ਇਸਨੂੰ ਹਲਕਾ ਫੁਲਕਾ acceptance tests ਨਾਲ ਜੋੜੋ।
ਉਦਾਹਰਨ:
ਇਸ ਨਾਲ ਤੁਸੀਂ "ਜ਼ਰੂਰਲੱਗਦਾ ਹੈ ਜਦ ਮੈਂ ਠੀਕ ਤਰੀਕੇ ਨਾਲ ਪੁੱਛਾਂ" ਤੋਂ ਬਚਦੇ ਹੋ।
AI ਟੂਲ ਲਈ ਛੋਟੇ ਪ੍ਰੌਂਪਟ ਸੋਧਾਂ ਨਾਲ ਵਰਤਾਰ ਵਿਵਹਾਰ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹਨ। ਇੱਕ ਛੋਟਾ ਚੇਂਜ ਲੌਗ ਰੱਖੋ:
ਇਸ ਨਾਲ ਸਮੀਖਿਆ ਆਸਾਨ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਖਾਮੋਸ਼ੀ ਨਾਲ ਸਕੋਪ ਕ੍ਰਿਪਟ ਨਾ ਹੋਵੇ — ਖ਼ਾਸ ਕਰਕੇ ਜਦ ਤੁਹਾਨੂੰ ਸੈਪਰ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਾਪਸ ਦੇਖਣਾ ਪਏ।
ਮੂਲ ਸਮੱਸਿਆ ਨਾਲ ਜੁੜੇ 2–3 ਮੈਟਰਿਕ ਚੁਣੋ:
ਜੇ ਤੁਸੀਂ ਇਸਨੂੰ ਮਾਪ ਨਹੀਂ ਸਕਦੇ, ਤਾਂ ਤੁਸੀਂ ਨਹੀਂ ਦੱਸ ਸਕਦੇ ਕਿ AI-ਬਨਾਇਆ ਹੱਲ ਕੁਝ ਬੇਹਤਰ ਕਰ ਰਿਹਾ ਹੈ।
ਇੱਕ-ਹਫ਼ਤਾ ਜਾਂ ਦੋ ਬਾਅਦ, ਵੇਖੋ ਕਿ ਅਸਲ ਵਿੱਚ ਕੀ ਹੋਇਆ: ਯੂਜ਼ਰ ਕਿੱਥੇ ਛੱਡ ਰਹੇ ਹਨ, ਕਿਹੜੀਆਂ ਬੇਨਤੀਆਂ ਨਾਕਾਮ ਹੋਈਆਂ, ਕਿਹੜੇ ਕਦਮ ਅਣਡਿੱਠੇ ਰਹਿ ਗਏ।
ਫਿਰ ਇੱਕ ਵਾਰੀ ਵਿੱਚ ਇੱਕ ਇੱਟ ਨੂੰ ਪ੍ਰਾਇਰਟੀ ਦਿਓ: ਪਹਿਲਾਂ ਸਭ ਤੋਂ ਵੱਡਾ ਦਰਦ-ਬਿੰਦੂ ਠੀਕ ਕਰੋ, ਦੂਸਰੇ ਨੰਬਰ 'ਤੇ ਇੱਕ ਛੋਟੀ ਫੀਚਰ ਸ਼ਾਮਿਲ ਕਰੋ, ਅਤੇ "ਚੰਗਾ-ਹੋਣ ਵਾਲੇ" ਨੂੰ ਬਾਅਦ ਲਈ ਛੱਡੋ। ਇਸ ਤਰ੍ਹਾਂ ਸੰਵਾਦਾਤਮਕ ਬਿਲਡਿੰਗ ਪ੍ਰਾਇਕਟਿਕਲ ਰਹਿੰਦੀ ਹੈ ਨਾ ਕਿ ਇੱਕ ਅਨੰਤ ਪ੍ਰੌਂਪਟ ਪ੍ਰਯੋਗ।
ਸੰਵਾਦਾਤਮਕ ਬਿਲਡਿੰਗ ਨੂੰ ਇੱਕ ਇੱਕ-ਵਾਰੀ ਤਜਰਬੇ ਤੋਂ ਬਚਾਉਣ ਦਾ ਸਬ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਉਹ ਕੁਝ ਮੁੜ-ਰਹਿਣ ਵਾਲੇ ਟੁਕੜੇ ਸਥਿਰ ਕਰ ਲਓ: ਇੱਕ ਪੰਨਾ PRD, ਇੱਕ ਛੋਟਾ ਪ੍ਰੌਂਪ ਲਾਇਬਰੇਰੀ, ਅਤੇ ਹਲਕੇ-ਫੁਲਕੇ ਗਾਰਡਰੇਲ। ਫਿਰ ਤੁਸੀਂ ਇੱਕੋ ਪਲੇਅਬੁੱਕ ਹਰ ਹਫ਼ਤੇ ਚਲਾ ਸਕਦੇ ਹੋ।
ਇਹ ਕਾਪੀ/ਪੇਸਟ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ AI ਟੂਲ ਨੂੰ ਖੋਲ੍ਹਣ ਤੋਂ ਪਹਿਲਾਂ ਭਰੋ:
ਇੱਕ ਸਾਂਝੇ ਨੋਟ ਵਿੱਚ ਪ੍ਰੌਂਪ ਸੰਭਾਲੋ ਜੋ ਤੁਸੀਂ ਪ੍ਰੋਜੈਕਟਾਂ 'ਚ ਵਰਤੋਂਗੇ:
ਹਰ ਪ੍ਰੌਂਪ ਦੇ ਕੋਲ ਚੰਗੇ ਆਉਟਪੁੱਟ ਦੇ ਉਦਾਹਰਨ ਰੱਖੋ ਤਾਂ ਜੋ ਟੀਮਮੈਟਾਂ ਨੂੰ ਪਤਾ ਰਹੇ ਕਿ ਲਕੜੀ ਕਿੰਨੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
ਇਹ ਇੱਕ ਵਾਰ ਲਿਖੋ ਅਤੇ ਦੁਹਰਾਓ:
ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ:
ਬਣਾਉਂਦੇ ਸਮੇਂ:
ਸ਼ਿਪ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ:
ਅਗਲਾ ਪਾਠ: ਹੋਰ ਪ੍ਰਾਇਕਟਿਕ ਗਾਈਡਾਂ ਲਈ /blog ਵੇਖੋ। ਜੇ ਤੁਸੀਂ ਵਿਅਕਤੀਗਤ ਅਤੇ ਟੀਮ ਟੀਅਰਾਂ ਦੀ ਤੁਲਨਾ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ /pricing ਵੇਖੋ — ਅਤੇ ਜੇ ਤੁਸੀਂ ਏਜੰਟ-ਡ੍ਰਾਈਵਨ ਵਰਕਫਲੋ (ਚੈਟ → ਬਿਲਡ → ਡਿਪਲੋਯ → ਐਕਸਪੋਰਟ) ਨੂੰ ਪੂਰਾ ਤੌਰ 'ਤੇ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Koder.ai ਇੱਕ ਵਿਕਲਪ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਆਪਣੇ ਮੌਜੂਦਾ ਟੂਲਚੇਨ ਦੇ ਨਾਲ ਮੁਕਾਬਲਾ ਕਰ ਸਕਦੇ ਹੋ।