ਪਿਛਲੇ ਮਹੀਨੇ, ਇੱਕ AI ਸਹਾਇਕ ਨੇ ਇੱਕ ਪ੍ਰੋਡਕਸ਼ਨ ਪ੍ਰੋਜੈਕਟ ਲਈ ਇੱਕ Python ਸਕ੍ਰਿਪਟ ਤਿਆਰ ਕੀਤੀ। ਆਉਟਪੁੱਟ ਬਿਨਾਂ ਕਿਸੇ ਗਲਤੀ ਦੇ ਚੱਲ ਗਿਆ। ਡੇਟਾ ਵੀ ਸਹੀ ਲੱਗ ਰਿਹਾ ਸੀ। ਪਰ ਇੱਕ ਮੈਨੂਅਲ ਰਿਵਿਊ ਤੋਂ ਪਤਾ ਲੱਗਾ ਕਿ ਡੇਟਾਬੇਸ ਕਾਲਾਂ ਵਿੱਚ ਇੱਕ N+1 ਕੁਐਰੀ ਪੈਟਰਨ (query pattern) ਲੁਕਿਆ ਹੋਇਆ ਸੀ। ਇੱਕ ਛੋਟੇ ਡੇਟਾਸੈੱਟ ਲਈ, ਕੋਡ ਠੀਕ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ। ਜੇ ਇਸ ਨੂੰ ਹਜ਼ਾਰਾਂ ਰਿਕਾਰਡਾਂ ਤੱਕ ਵਧਾਇਆ ਜਾਵੇ, ਤਾਂ ਐਪਲੀਕੇਸ਼ਨ ਪੇਰੈਂਟ ਆਬਜੈਕਟਾਂ ਲਈ ਇੱਕ ਕੁਐਰੀ ਜਾਰੀ ਕਰੇਗੀ, ਅਤੇ ਫਿਰ ਸਬੰਧਤ ਡੇਟਾ ਲਈ ਹਜ਼ਾਰਾਂ ਅਗਲੀਆਂ ਕੁਐਰੀਆਂ ਕਰੇਗੀ। ਇਸ ਦਾ ਨਤੀਜਾ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਇੱਕ ਭਿਆਨਕ ਗਿਰਾਵਟ (performance cliff) ਹੋਵੇਗਾ ਜਿਸ ਨੂੰ ਕੋਈ ਯੂਨਿਟ ਟੈਸਟ ਨਹੀਂ ਫੜ ਸਕੇਗਾ।
ਇਹ ਆਧੁਨਿਕ ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਮੈਂਟ ਦੀ ਅਸਲੀਅਤ ਹੈ। AI ਟੂਲ ਹੁਣ ਕੋਡਿੰਗ, ਡੀਬੱਗਿੰਗ ਅਤੇ ਆਰਕੀਟੈਕਚਰਲ ਸੁਝਾਵਾਂ ਨੂੰ ਉਸ ਰਫਤਾਰ ਨਾਲ ਸੰਭਾਲਦੇ ਹਨ ਜਿਸ ਨਾਲ ਕੋਈ ਇਨਸਾਨ ਮੈਚ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਉਹ ਰਫਤਾਰ ਅਸਲੀ ਹੈ। ਫਿਰ ਵੀ, ਇਹ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਤੁਹਾਡੀ ਨੌਕਰੀ ਦੇ ਰੂਪ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਹੁਣ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਿੰਟੈਕਸ ਟਾਈਪ ਕਰਨ ਲਈ ਪੈਸੇ ਨਹੀਂ ਦਿੱਤੇ ਜਾਂਦੇ। ਤੁਹਾਨੂੰ ਆਡਿਟ ਕਰਨ, ਆਰਕੀਟੈਕਟ ਕਰਨ, ਅਤੇ ਬਿਲਕੁਲ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਅਦਿੱਖ ਜਾਲਾਂ ਨੂੰ ਫੜਨ ਲਈ ਪੈਸੇ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।
"ਤਰਕਸੰਗਤ ਪਰ ਗਲਤ" ਦਾ ਚੁੱਪਚਾ ਖ਼ਤਰਾ
AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਕੋਡ ਅਕਸਰ ਸਹੀ ਲੱਗਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਕੰਪਾਈਲ ਹੁੰਦਾ ਹੈ, ਚੱਲਦਾ ਹੈ, ਅਤੇ ਉਮੀਦ ਕੀਤੇ ਅਨੁਸਾਰ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਤਰਕ (logic) ਉੱਪਰੋਂ ਸਹੀ ਲੱਗਦਾ ਹੈ। ਪਰ ਅੰਦਰੋਂ, ਇਹ ਚੁੱਪਚਾਪ ਟੁੱਟਿਆ ਹੋ ਸਕਦਾ ਹੈ।
ਰੈਗੂਲਰ ਐਕਸਪ੍ਰੈਸ਼ਨ (regular expressions) ਦੀ ਉਦਾਹਰਣ ਲਓ। ਇੱਕ AI ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਪੈਟਰਨ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਅੰਗਰੇਜ਼ੀ ਵਿੱਚ ਈਮੇਲ ਪਤੇ ਜਾਂ ਆਈਡੈਂਟੀਫਾਇਰਾਂ ਨਾਲ ਬਿਲਕੁਲ ਮੇਲ ਖਾਂਦਾ ਹੋਵੇ। ਉਸੇ ਐਕਸਪ੍ਰੈਸ਼ਨ ਨੂੰ ਜਰਮਨ ਉਮਲਾਊਟਸ (umlauts), ਅਰਬੀ ਲਿਪੀ, ਜਾਂ ਯੂਨੀਕੋਡ ਨਾਰਮਲਾਈਜ਼ੇਸ਼ਨ (Unicode normalization) ਦੇ ਕਿਨਾਰਿਆਂ (edge cases) 'ਤੇ ਚਲਾ ਕੇ ਦੇਖੋ, ਅਤੇ ਇਹ ਚੁੱਪਚਾਪ ਫੇਲ ਹੋ ਜਾਵੇਗਾ। ਕੋਡ ਕਿਸੇ ਅਜਿਹੇ ਤਰੀਕੇ ਨਾਲ ਗਲਤ ਨਹੀਂ ਹੈ ਜੋ ਕੋਈ ਐਕਸਪਸ਼ਨ (exception) ਸੁੱਟੇ। ਇਹ ਸਿਰਫ਼ ਅਸਲ ਦੁਨੀਆ ਦੇ ਵੈਧ ਡੇਟਾ ਨੂੰ ਬਾਹਰ ਰੱਖ ਦਿੰਦਾ ਹੈ।
ਡੇਟਾਬੇਸ ਕੁਐਰੀਆਂ ਵਿੱਚ ਵੀ ਅਜਿਹਾ ਹੀ ਜੋਖਮ ਹੁੰਦਾ ਹੈ। ਇੱਕ AI PostgreSQL ਕੁਐਰੀ ਲਿਖ ਸਕਦਾ ਹੈ ਜੋ ਟੈਸਟਿੰਗ ਦੌਰਾਨ ਸਹੀ ਰੋਅ (rows) ਵਾਪਸ ਕਰਦੀ ਹੈ, ਫਿਰ ਵੀ ਤੁਹਾਡੀਆਂ ਟੇਬਲਾਂ ਨੂੰ ਡੈੱਡ ਟਿਪਲਜ਼ (dead tuples) ਨਾਲ ਭਰ ਸਕਦੀ ਹੈ, ਇੰਡੈਕਸ ਦੀ ਵਰਤੋਂ ਨੂੰ ਛੱਡ ਸਕਦੀ ਹੈ, ਜਾਂ ਸੀਕੁਐਂਸ਼ੀਅਲ ਸਕੈਨ (sequential scans) ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੀ ਹੈ ਜੋ ਪ੍ਰੋਡਕਸ਼ਨ ਵਰਕਲੋਡ ਨੂੰ ਬਰਬਾਦ ਕਰ ਦਿੰਦੇ ਹਨ। ਜੋ ਡੈਮੋ ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਜੋ ਅਸਲ ਲੋਡ ਦੇ ਅਧੀਨ ਕੰਮ ਕਰਦਾ ਹੈ, ਉਹ ਦੋ ਵੱਖਰੀਆਂ ਚੀਜ਼ਾਂ ਹਨ। ਮਸ਼ੀਨ ਲੇਟੈਂਸੀ (latency) ਮਹਿਸੂਸ ਨਹੀਂ ਕਰਦੀ। ਇਹ ਕਲਾਉਡ ਬਿੱਲ ਨਹੀਂ ਭਰਦੀ।
ਲਿਖਣ ਤੋਂ ਸਬੂਤ ਕਰਨ (Verifying) ਤੱਕ
ਜ਼ਰੂਰੀ ਤਬਦੀਲੀ "ਮੈਂ ਇਹ ਕਿਵੇਂ ਲਿਖਾਂ?" ਤੋਂ "ਮੈਂ ਇਸਦੀ ਪੁਸ਼ਟੀ (verify) ਕਿਵੇਂ ਕਰਾਂ?" ਵੱਲ ਹੋ ਰਹੀ ਹੈ। ਜਦੋਂ AI ਪਹਿਲਾ ਡਰਾਫਟ ਸੰਭਾਲਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਡਾ ਬੌਧਿਕ ਬੋਝ (cognitive load) ਅੱਗੇ ਵੱਲ ਵਧਣਾ ਚਾਹੀਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਕੋਡ ਨੂੰ ਉਸ ਤਰੀਕੇ ਨਾਲ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਹੈ ਜਿਸ ਤਰੀਕੇ ਨਾਲ ਇੱਕ ਸੁਰੱਖਿਆ ਆਡਿਟਰ (security auditor) ਇਸਨੂੰ ਪੜ੍ਹਦਾ ਹੈ, ਨਾ ਕਿ ਉਸ ਤਰੀਕੇ ਨਾਲ ਜਿਸ ਤਰੀਕੇ ਨਾਲ ਇੱਕ ਥੱਕਿਆ ਹੋਇਆ ਲੇਖਕ ਆਪਣੇ ਕੰਮ ਨੂੰ ਜਲਦੀ ਵਿੱਚ ਪੜ੍ਹਦਾ ਹੈ।
ਇਸ ਲਈ ਇੱਕ ਵੱਖਰੇ ਤਰ੍ਹਾਂ ਦੇ ਅਨੁਸ਼ਾਸਨ ਦੀ ਲੋੜ ਹੈ। ਆਟੋਮੇਸ਼ਨ ਬਾਇਸ (Automation bias) ਅਸਲੀ ਹੈ। ਜਦੋਂ ਕੋਈ ਟੂਲ ਰਵਾਨ, ਸਿੰਟੈਕਟਿਕਲੀ ਪਰਫੈਕਟ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਤਾਂ ਮਨੁੱਖੀ ਦਿਮਾਗ ਸ਼ਾਂਤ ਹੋ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਸਹੀ ਹੋਣ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਲੈਂਦੇ ਹੋ ਕਿਉਂਕਿ ਪੇਸ਼ਕਾਰੀ ਸੁਧਰੀ ਹੋਈ ਹੁੰਦੀ ਹੈ। ਉਸ ਇੱਛਾ ਦਾ ਵਿਰੋਧ ਕਰਨਾ ਹੁਣ ਮੁੱਖ ਹੁਨਰ ਹੈ। ਤੁਹਾਨੂੰ ਮੰਨਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਹਰ ਸੁਝਾਅ ਇੱਕ ਪਰਿਕਲਪਨਾ (hypothesis) ਹੈ ਜਦੋਂ ਤੱਕ ਕਿ ਉਹ ਉਲਟ ਸਾਬਤ ਨਾ ਹੋ ਜਾਵੇ।
ਮਸ਼ੀਨ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨਾ
ਇੱਕ AI ਕੋਡਿੰਗ ਸਹਾਇਕ ਤੋਂ ਉਪਯੋਗੀ ਆਉਟਪੁੱਟ ਪ੍ਰਾਪਤ ਕਰਨਾ ਤੇਜ਼ੀ ਨਾਲ ਟਾਈਪ ਕਰਨ ਬਾਰੇ ਨਹੀਂ ਹੈ। ਇਹ ਮਸ਼ੀਨ ਦੇ ਟ੍ਰੇਨਿੰਗ ਡੇਟਾ ਅਤੇ ਤੁਹਾਡੀ ਖਾਸ ਅਸਲੀਅਤ ਵਿਚਕਾਰਲੀ ਦੂਰੀ ਨੂੰ ਘਟਾਉਣ ਬਾਰੇ ਹੈ। ਤੁਸੀਂ ਕੁਝ ਖਾਸ ਅਭਿਆਸਾਂ ਨਾਲ ਉਸ ਦੂਰੀ ਨੂੰ ਘਟਾ ਸਕਦੇ ਹੋ।
ਆਪਣੇ ਪ੍ਰੋਂਪਟਸ (prompts) ਵਿੱਚ ਸਹੀ ਰਹੋ। ਇੱਥੇ ਅਸਪਸ਼ਟਤਾ ਕਵਿਤਾ ਨਹੀਂ ਬਣਾਉਂਦੀ; ਇਹ ਬੱਗ (bugs) ਪੈਦਾ ਕਰਦੀ ਹੈ। "ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਆਪਟੀਮਾਈਜ਼ ਕਰੋ" ਵਰਗਾ ਪ੍ਰੋਂਪਟ ਆਮ ਸਲਾਹ ਨੂੰ ਸੱਦਾ ਦਿੰਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ, ਲਿਖੋ "ਇਸ Python ਲੂਪ ਨੂੰ ਵਾਰ-ਵਾਰ ਸੇਵ ਕਰਨ ਦੀ ਬਜਾਏ ਇੱਕ ਸਿੰਗਲ ਬਲਕ ਡੇਟਾਬੇਸ ਅੱਪਡੇਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਰੀਫੈਕਟਰ (refactor) ਕਰੋ।" ਸਪੱਸ਼ਟਤਾ ਸੰਭਾਵਨਾਵਾਂ ਦੇ ਦਾਇਰੇ ਨੂੰ ਤੰਗ ਕਰਦੀ ਹੈ।
ਅਸਲੀ ਸੰਦਰਭ (context) ਪ੍ਰਦਾਨ ਕਰੋ। AI ਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਕਿ ਤੁਸੀਂ Kubernetes ਕਲੱਸਟਰ ਦੇ ਅੰਦਰ PostgreSQL 15 'ਤੇ Django 4.2 ਚਲਾ ਰਹੇ ਹੋ ਜਿਸ ਵਿੱਚ 30-ਸਕਿੰਟ ਦਾ ਸਖ਼ਤ ਰਿਕਵੈਸਟ ਟਾਈਮਆਊਟ ਹੈ, ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਦੱਸਦੇ ਨਹੀਂ। ਇਸ ਨੂੰ ਆਪਣੇ ਡਿਪੈਂਡੈਂਸੀ ਵਰਜ਼ਨ (dependency versions), ਆਪਣੀਆਂ ਅੰਦਰੂਨੀ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਅਤੇ ਆਪਣੀਆਂ ਗੈਰ-ਮੰਨਣਯੋਗ ਸੀਮਾਵਾਂ ਬਾਰੇ ਦੱਸੋ। ਸੰਦਰਭ ਸਿਰਫ਼ ਸਜਾਵਟ ਨਹੀਂ ਹੈ; ਇਹ ਗਾਰਡਰੇਲ (guardrails) ਹੈ।
ਆਪਣੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨਾਲ ਜਵਾਬਾਂ ਨੂੰ ਅਧਾਰਤ ਕਰੋ। ਰਿਟ੍ਰੀਵਲ-ਅਗਮੈਂਟਡ ਜਨਰੇਸ਼ਨ (Retrieval-Augmented Generation), ਜਾਂ RAG, ਸਿਰਫ਼ ਚੈਟਬੋਟਾਂ ਲਈ ਇੱਕ ਬਜ਼ਵਰਡ ਨਹੀਂ ਹੈ। ਆਪਣੇ ਸਹਾਇਕ ਨੂੰ ਆਪਣੇ ਅਸਲ API ਸਪੈਸੀਫਿਕੇਸ਼ਨਾਂ, ਆਪਣੇ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲੇ ਰਿਕਾਰਡਾਂ, ਅਤੇ ਆਪਣੇ ਕੋਡਬੇਸ ਪ੍ਰੋਤੋਕੋਲਾਂ ਵੱਲ ਮੋੜੋ। ਜਦੋਂ ਮਾਡਲ ਟ੍ਰੇਨਿੰਗ ਡੇਟਾ ਤੋਂ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਦੀ ਬਜਾਏ ਤੁਹਾਡੇ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਤੱਥ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਆਮ ਸਲਾਹ ਅਤੇ ਵਰਤੋਂਯੋਗ ਕੋਡ ਵਿਚਕਾਰਲਾ ਪਾੜਾ ਬਹੁਤ ਘੱਟ ਜਾਂਦਾ ਹੈ।
ਗੁੰਝਲਦਾਰ ਕੰਮ ਨੂੰ ਵੱਖ-ਵੱਖ ਕਾਰਜਾਂ ਵਿੱਚ ਵੰਡੋ। ਏਜੰਟ ਪੈਟਰਨ ਉਦੋਂ ਸਭ ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦੇ ਹਨ ਜਦੋਂ ਹਰੇਕ ਕਦਮ ਦਾ ਦਾਇਰਾ ਸੀਮਤ ਹੋਵੇ। ਇੱਕੋ ਵਾਰ ਵਿੱਚ ਪੂਰਾ ਮਾਈਕਰੋਸਰਵਿਸ ਰੀਫੈਕਟਰ ਕਰਨ ਲਈ ਨਾ ਕਹੋ। ਪਹਿਲਾਂ ਡੇਟਾ ਸਕੀਮਾ (data schema) ਮੰਗੋ। ਇਸਦੀ ਪੁਸ਼ਟੀ ਕਰੋ। ਫਿਰ ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟ ਮੰਗੋ। ਉਸਦੀ ਪੁਸ਼ਟੀ ਕਰੋ। ਫਿਰ ਸਰਵਿਸ ਲੇਅਰ ਵੱਲ ਵਧੋ।