ਕੁਸ਼ਲਤਾ ਦਾ ਭਰਮ: ਕਿਉਂ AI ਦਾ ਆਖਰੀ ਪੜਾਅ (Last Mile) ਸਭ ਕੁਝ ਮੁੱਲ ਵਜੋਂ ਲੈਂਦਾ ਹੈ

ਤੁਸੀਂ AI ਕੋਡ ਦੇ 80/20 ਨਿਯਮ ਬਾਰੇ ਪੜ੍ਹਦੇ ਹੋ ਅਤੇ ਸਿਰ ਹਿਲਾਉਂਦੇ ਹੋ।

AI ਤੁਹਾਡੇ ਕੋਡ ਦਾ ਪਹਿਲਾ 80% ਕੁਝ ਹੀ ਸਕਿੰਟਾਂ ਵਿੱਚ ਲਿਖ ਦਿੰਦਾ ਹੈ। ਇਹ ਤਰੱਕੀ ਵਾਂਗ ਲੱਗਦਾ ਹੈ। ਇਹ ਰਫ਼ਤਾਰ ਵਾਂਗ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।

ਇਹ ਇੱਕ ਜਾਲ ਹੈ।

ਕੰਮ ਦਾ ਆਖਰੀ 20% ਤੁਹਾਡਾ 80% ਸਮਾਂ ਲੈਂਦਾ ਹੈ। ਇੱਥੇ ਹੀ ਪ੍ਰੋਜੈਕਟ ਖ਼ਤਮ ਹੁੰਦੇ ਹਨ। ਇੱਥੇ ਹੀ ਡਿਵੈਲਪਰ ਆਪਣਾ ਸਬਰ ਗੁਆ ਲੈਂਦੇ ਹਨ।

AI ਸੰਭਾਵਨਾ (probability) 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਅਗਲੇ ਸਭ ਤੋਂ ਸੰਭਵ ਸ਼ਬਦ ਜਾਂ ਕੋਡ ਦੀ ਲਾਈਨ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ। ਇਹ logic ਨੂੰ ਨਹੀਂ ਸਮਝਦਾ। ਇਹ ਤੁਹਾਡੇ ਖਾਸ system architecture ਨੂੰ ਨਹੀਂ ਸਮਝਦਾ। ਇਹ ਇੱਕ "happy path" ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਸਿਰਫ਼ ਸੰਪੂਰਨ ਹਾਲਤਾਂ ਵਿੱਚ ਹੀ ਕੰਮ ਕਰਦਾ ਹੈ।

ਜਦੋਂ ਤੁਸੀਂ "happy path" ਤੋਂ ਅੱਗੇ ਵਧਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਕੰਧ ਨਾਲ ਟਕਰਾਉਂਦੇ ਹੋ।

ਮੈਂ ਇਸਨੂੰ Verification Debt ਕਹਿੰਦਾ ਹਾਂ।

Technical debt ਜਲਦੀ ਵਿੱਚ ਕੀਤੇ ਗਏ ਸੁਧਾਰਾਂ (quick fixes) ਤੋਂ ਆਉਂਦਾ ਹੈ। Verification debt ਸਮਝ ਦੀ ਕਮੀ ਤੋਂ ਆਉਂਦਾ ਹੈ।

ਜਦੋਂ ਤੁਸੀਂ ਖੁਦ ਕੋਡ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਮਾਨਸਿਕ ਨਕਸ਼ਾ ਤਿਆਰ ਕਰਦੇ ਹੋ। ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਹਰ ਲਾਈਨ ਕਿਉਂ ਹੈ। ਜਦੋਂ AI ਇਸਨੂੰ ਲਿਖਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਤਿਆਰ ਉਤਪਾਦ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਬਣਾਇਆ। ਤੁਸੀਂ logic ਦੇ ਮਾਲਕ ਨਹੀਂ ਹੁੰਦੇ। ਤੁਸੀਂ ਸਿਰਫ਼ ਨਤੀਜੇ ਦੇ ਮਾਲਕ ਹੁੰਦੇ ਹੋ।

ਜੇਕਰ ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਨਹੀਂ ਸਮਝਦੇ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ debug ਨਹੀਂ ਕਰ ਸਕਦੇ। ਤੁਸੀਂ ਉਸ ਗਲਤੀ ਨੂੰ ਸੁਧਾਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ ਘੰਟੇ ਬਿਤਾਉਂਦੇ ਹੋ ਜੋ AI ਨੇ ਇੱਕ ਸਕਿੰਟ ਵਿੱਚ ਕੀਤੀ ਸੀ।

ਜਨਰੇਸ਼ਨ ਦੀ ਰਫ਼ਤਾਰ ਮੁਕੰਮਲ ਹੋਣ ਦਾ ਇੱਕ ਭਰਮ ਪੈਦਾ ਕਰਦੀ ਹੈ। ਤੁਹਾਨੂੰ ਲੱਗਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਲਗਭਗ ਪੂਰਾ ਕਰ ਲਿਆ ਹੈ। ਫਿਰ edge cases ਆਉਂਦੇ ਹਨ। Integration ਫੇਲ ਹੋ ਜਾਂਦਾ ਹੈ। ਸੁਰੱਖਿਆ ਕਮੀਆਂ (security flaws) ਸਾਹਮਣੇ ਆਉਂਦੀਆਂ ਹਨ।

ਆਖਰੀ 20% ਸਿਰਫ਼ "finishing touches" ਨਹੀਂ ਹਨ। ਇਹ ਗੁਣਵੱਤਾ (quality) ਦਾ ਕੇਂਦਰ ਹੈ। ਇਹ ਟੈਸਟਿੰਗ, ਡੀਬੱਗਿੰਗ, ਅਤੇ edge-case ਨੂੰ ਸੰਭਾਲਣਾ ਹੈ।

ਤੁਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕਰ ਸਕਦੇ ਹੋ?

AI ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਅੰਤਿਮ ਉਤਪਾਦ ਵਜੋਂ ਦੇਖਣਾ ਬੰਦ ਕਰੋ। ਇਸਨੂੰ ਅਭਰੋਸੇਯੋਗ ਡੇਟਾ ਵਜੋਂ ਮੰਨੋ।

• ਪਹਿਲਾਂ ਟੈਸਟ ਲਿਖੋ। ਟੈਸਟ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਕਦੇ ਵੀ logic ਨਾ ਬਣਾਓ। AI ਦੇ ਬੋਲਣ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਤੈਅ ਕਰੋ ਕਿ ਅਸਫਲਤਾ (failure) ਕਿਹੋ ਜਿਹੀ ਦਿਖੇਗੀ।
• ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੈਲੀਡੇਟ ਕਰੋ। ਗਲਤੀਆਂ ਲੱਭਣ ਲਈ ਪੂਰੇ ਸਿਸਟਮ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਦੀ ਉਡੀਕ ਨਾ ਕਰੋ। ਹਰ ਛੋਟੇ ਬਲਾਕ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਟੈਸਟ ਕਰੋ।
• ਪੈਚਿੰਗ (patching) ਕਰਨ ਦੀ ਬਜਾਏ ਰੱਦ ਕਰ ਦਿਓ। ਜੇਕਰ ਕੋਈ AI ਫੰਕਸ਼ਨ ਟੈਸਟ ਵਿੱਚ ਫੇਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਲਾਈਨ-ਦਰ-ਲਾਈਨ ਠੀਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਾ ਕਰੋ। ਇਸਨੂੰ ਡਿਲੀਟ ਕਰ ਦਿਓ ਅਤੇ ਇੱਕ ਵੱਖਰਾ prompt ਵਰਤ ਕੇ ਦੇਖੋ। AI ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਪੈਚ ਕਰਨਾ ਅਕਸਰ ਹੋਰ ਗਲਤੀਆਂ ਪੈਦਾ ਕਰਦਾ ਹੈ।

80/20 ਨਿਯਮ ਇੱਕ ਚੇਤਾਵਨੀ ਹੈ। AI ਤੁਹਾਡੀ ਰਫ਼ਤਾਰ ਵਧਾਉਂਦਾ ਹੈ, ਪਰ ਇਹ ਪੁਸ਼ਟੀ (verify) ਕਰਨ ਦੀ ਤੁਹਾਡੀ ਜ਼ਿੰਮੇਵਾਰੀ ਵੀ ਵਧਾਉਂਦਾ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਆਪਣਾ ਸਾਰਾ ਸਮਾਂ AI ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਸੁਧਾਰਨ ਵਿੱਚ ਬਿਤਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕੁਸ਼ਲਤਾ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕੀਤੀ ਹੈ। ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਕਿਸਮ ਦੇ ਕੰਮ ਦੀ ਬਜਾਏ ਦੂਜੀ ਕਿਸਮ ਦਾ ਕੰਮ ਕੀਤਾ ਹੈ।

ਆਖਰੀ ਪੜਾਅ (last mile) ਉਹ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਸਾਬਤ ਕਰਦੇ ਹੋ ਕਿ ਕੋਡ ਅਸਲ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਸਾਬਤ ਕਰਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਇੱਕ ਸੰਪੂਰਨ ਦਿਖਣ ਵਾਲੇ ਝੂਠ ਤੋਂ ਧੋਖਾ ਨਹੀਂ ਖਾਧਾ।

Source: https://dev.to/amrree/the-illusion-of-efficiency-why-ais-last-mile-costs-everything-a7g

Optional learning community: https://t.me/GyaanSetuAi