ਜਿਹੜੇ ਡਿਵੈਲਪਰਾਂ ਨੇ GitHub Copilot, ChatGPT, ਜਾਂ Cursor ਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕੀਤੀ ਹੈ, ਉਹ ਅਕਸਰ ਇੱਕੋ ਜਿਹੇ ਸ਼ੁਰੂਆਤੀ ਉਤਸ਼ਾਹ (honeymoon phase) ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ। ਜਿਹੜੇ ਕੰਮ ਪਹਿਲਾਂ ਦੋ ਘੰਟੇ ਲੈਂਦੇ ਸਨ, ਉਹ ਹੁਣ ਵੀਹ ਮਿੰਟਾਂ ਵਿੱਚ ਹੋ ਜਾਂਦੇ ਹਨ। ਇੱਕ 'tab' ਕੀਅ ਨਾਲ ਬੁਨਿਆਦੀ ਕੋਡ (boilerplate) ਗਾਇਬ ਹੋ ਜਾਂਦਾ ਹੈ। ਪਰ ਜਲਦੀ ਹੀ, ਫੋਰਮਾਂ ਅਤੇ Slack ਚੈਨਲਾਂ ਵਿੱਚ ਇੱਕ ਸ਼ਾਂਤ ਸ਼ਿਕਾਇਤ ਉੱਭਰਨ ਲੱਗਦੀ ਹੈ: ਥਕਾਵਟ। ਟੂਲ ਕੋਡ ਲਿਖਦਾ ਹੈ, ਪਰ ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕੁਝ ਅਜਿਹਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਨਿਢਾਲ ਕਰ ਦਿੰਦਾ ਹੈ। ਸਮੱਸਿਆ ਕੋਡ ਦੀ ਨਹੀਂ ਹੈ। ਸਮੱਸਿਆ ਉਸ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਸਮਝਣ ਦੀ ਹੈ।
ਉਹ ਰੁਕਾਵਟ ਜਿਸ ਲਈ ਕੋਈ ਤਿਆਰੀ ਨਹੀਂ ਸੀ ਕੀਤੀ
ਦਹਾਕਿਆਂ ਤੋਂ, ਸਾਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ ਮੁੱਖ ਰੁਕਾਵਟ ਟਾਈਪਿੰਗ ਦੀ ਰਫ਼ਤਾਰ ਸੀ। ਤੁਸੀਂ ਕਿੰਨੀ ਵੀ ਤੇਜ਼ੀ ਨਾਲ ਕਿਉਂ ਨਾ ਸੋਚੋ, ਤੁਹਾਡੀਆਂ ਉਂਗਲਾਂ ਅਤੇ ਤੁਹਾਡੇ ਸਿੰਟੈਕਸ (syntax) ਦਾ ਗਿਆਨ ਇੱਕ ਸੀਮਾ ਤੈਅ ਕਰਦਾ ਸੀ। AI ਸਹਾਇਕਾਂ ਨੇ ਉਸ ਸੀਮਾ ਨੂੰ ਤਬਾਹ ਕਰ ਦਿੱਤਾ ਹੈ। ਉਹ ਤੁਹਾਡੇ ਪਹਿਲੇ ਬਲਾਕ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਕਈ ਫਾਈਲਾਂ ਵਿੱਚ ਸੈਂਕੜੇ ਲਾਈਨਾਂ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਰਫ਼ਤਾਰ ਸੁਣਨ ਵਿੱਚ ਤਾਂ ਆਜ਼ਾਦੀ ਵਰਗੀ ਲੱਗਦੀ ਹੈ, ਪਰ ਇਹ ਇੱਕ ਅਣਪਛਾਤੀ ਰੁਕਾਵਟ ਪੈਦਾ ਕਰਦੀ ਹੈ। ਅਚਾਨਕ, ਪਾਈਪਲਾਈਨ ਦਾ ਸਭ ਤੋਂ ਹੌਲੀ ਹਿੱਸਾ ਤੁਹਾਡੀ ਸਕ੍ਰੀਨ 'ਤੇ ਦਿਖਾਈ ਦੇ ਰਹੀ ਚੀਜ਼ ਨੂੰ ਪੜ੍ਹਨ, ਸਮਝਣ ਅਤੇ ਪੁਸ਼ਟੀ ਕਰਨ ਦੀ ਯੋਗਤਾ ਬਣ ਜਾਂਦੀ ਹੈ। ਤੁਸੀਂ ਆਪਣੇ ਹੀ ਪ੍ਰੋਜੈਕਟ ਦੇ ਫੁੱਲ-ਟਾਈਮ ਕੋਡ ਰਿਵਿਊਅਰ ਬਣ ਗਏ ਹੋ, ਸਿਵਾਏ ਇਸ ਦੇ ਕਿ ਲੇਖਕ ਇੱਕ ਅਜਿਹਾ ਐਲਗੋਰਿਦਮ ਹੈ ਜੋ ਕਦੇ ਸੌਂਦਾ ਨਹੀਂ ਅਤੇ ਕਦੇ ਥੱਕਦਾ ਨਹੀਂ।
ਮਿਹਨਤ ਦਾ ਇਹ ਬਦਲਾਅ ਕੋਡਿੰਗ ਸੈਸ਼ਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਕੁਝ ਨਵਾਂ ਬਣਾਉਣ ਅਤੇ ਹਲਕੀ ਜਿਹੀ ਜਾਂਚ ਕਰਨ ਦੇ ਵਿਚਕਾਰ ਬਦਲਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਲੰਬੇ ਸਮੇਂ ਲਈ ਸਿਰਫ਼ ਵੈਲੀਡੇਸ਼ਨ (validation) ਮੋਡ ਵਿੱਚ ਫਸ ਜਾਂਦੇ ਹੋ। ਅਤੇ ਵੈਲੀਡੇਸ਼ਨ ਸਿਰਫ਼ ਪੜ੍ਹਨਾ ਨਹੀਂ ਹੈ। ਇਹ ਇੱਕ ਸਰਗਰਮ, ਸ਼ੱਕ ਨਾਲ ਭਰੀ ਹੋਈ ਵਿਸ਼ਲੇਸ਼ਣ ਪ੍ਰਕਿਰਿਆ ਹੈ। ਹਰ ਵੇਰੀਏਬਲ ਨਾਮ, ਹਰ ਬਾਊਂਡਰੀ ਕੰਡੀਸ਼ਨ, ਅਤੇ ਹਰ ਇੰਪੋਰਟ ਸਟੇਟਮੈਂਟ ਨੂੰ ਇੱਕ ਮਾਨਸਿਕ ਫਿਲਟਰ ਤੋਂ ਲੰਘਣਾ ਪੈਂਦਾ ਹੈ ਕਿਉਂਕਿ AI ਦੀ ਇਸ ਵਿੱਚ ਕੋਈ ਨਿੱਜੀ ਜ਼ਿੰਮੇਵਾਰੀ ਨਹੀਂ ਹੈ। ਜਦੋਂ ਪ੍ਰੋਡਕਸ਼ਨ ਜੌਬ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਰਾਤ ਦੇ 3 ਵਜੇ ਕੋਈ ਜਗਾਉਣ ਨਹੀਂ ਆਵੇਗਾ।
ਤੁਹਾਡਾ ਦਿਮਾਗ ਕਿਉਂ ਹਾਰ ਮੰਨ ਲੈਂਦਾ ਹੈ
ਇਹ ਥਕਾਵਟ ਆਲਸ ਨਹੀਂ ਹੈ। ਇਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਆਉਂਦੇ ਡੇਟਾ ਅਤੇ ਮਨੁੱਖੀ ਸਮਰੱਥਾ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਅਟੱਲ ਟਕਰਾਅ ਹੈ।
ਵੌਲਯੂਮ ਓਵਰਲੋਡ (Volume overload)। ਇੱਕ ਆਮ AI ਸੁਝਾਅ ਵਿੱਚ ਇੱਕ ਪੂਰਾ React ਕੰਪੋਨੈਂਟ, ਉਸਦਾ ਸਟਾਈਲਿੰਗ ਲੌਜਿਕ, ਯੂਟੀਲਿਟੀ ਫੰਕਸ਼ਨ, ਅਤੇ ਯੂਨਿਟ ਟੈਸਟ, ਸਭ ਇੱਕੋ ਵਾਰ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ। ਤੁਹਾਡੀ ਵਰਕਿੰਗ ਮੈਮੋਰੀ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ ਇੱਕ ਸੀਮਾ ਤੱਕ ਹੀ ਜਾਣਕਾਰੀ ਰੱਖ ਸਕਦੀ ਹੈ। ਜਦੋਂ ਸਕ੍ਰੀਨ ਦਰਜਨਾਂ ਨਵੀਆਂ ਲਾਈਨਾਂ ਨਾਲ ਭਰ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਡੇ ਦਿਮਾਗ ਨੂੰ ਜਾਂ ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਅਬਸਟਰੈਕਟ ਪੈਟਰਨਾਂ ਵਿੱਚ ਸੰਕੁਚਿਤ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਸਕੈਨ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਦੋਵੇਂ ਤਰੀਕੇ ਧਿਆਨ ਖਤਮ ਕਰਦੇ ਹਨ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਈ ਬਲਾਕਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮਾਨਸਿਕ ਥਕਾਵਟ ਮਹਿਸੂਸ ਹੋਣ ਲੱਗਦੀ ਹੈ। ਤੁਸੀਂ ਪੜ੍ਹ ਤਾਂ ਰਹੇ ਹੋ, ਪਰ ਤੁਸੀਂ ਹੁਣ ਸੱਚਮੁੱਚ ਸਮਝ ਨਹੀਂ ਰਹੇ।
ਭਰੋਸੇ ਦੀ ਕਮੀ (The trust gap)। AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਕੋਡ ਅਧਿਕਾਰਤ ਲੱਗਦਾ ਹੈ। ਇੰਡੈਂਟੇਸ਼ਨ (Indentation) ਬਿਲਕੁਲ ਸਹੀ ਹੁੰਦੀ ਹੈ। ਵੇਰੀਏਬਲ ਦੇ ਨਾਮ ਤਰਕਸੰਗਤ ਹੁੰਦੇ ਹਨ। ਕਮੈਂਟਸ ਵੀ ਸਹੀ ਥਾਵਾਂ 'ਤੇ ਹੁੰਦੇ ਹਨ। ਪਰ ਅਧਿਕਾਰਤ ਹੋਣ ਦਾ ਮਤਲਬ ਸਹੀ ਹੋਣਾ ਨਹੀਂ ਹੈ। ਕੋਡ ਕਿਸੇ ਪੁਰਾਣੇ (deprecated) API ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ, null ਇਨਪੁੱਟ ਨਾਲ ਜੁੜੇ ਕਿਸੇ ਮਾਮਲੇ ਨੂੰ ਛੱਡ ਸਕਦਾ ਹੈ, ਜਾਂ ਇੱਕ ਬਾਰੀਕ SQL ਇੰਜੈਕਸ਼ਨ ਵੈਕਟਰ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ। ਕਿਉਂਕਿ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਅਜਿਹਾ ਹੋ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਸੀਂ ਇਸ ਨੂੰ ਜਲਦੀ-ਜਲਦੀ ਨਹੀਂ ਪੜ੍ਹ ਸਕਦੇ। ਤੁਹਾਨੂੰ ਹਰ ਰਿਟਰਨ ਸਟੇਟਮੈਂਟ ਅਤੇ ਹਰ ਲੌਜਿਕ ਬ੍ਰਾਂਚ ਦੀ ਸੁਰੱਖਿਆ ਆਡਿਟ ਵਾਂਗ ਬੜੀ ਸਾਵਧਾਨੀ ਨਾਲ ਜਾਂਚ ਕਰਨੀ ਪੈਂਦੀ ਹੈ। ਘੰਟਿਆਂ ਤੱਕ ਬਣਾਈ ਰੱਖੀ ਗਈ ਇਹ ਸਖ਼ਤ ਜਾਂਚ ਮਾਨਸਿਕ ਤੌਰ 'ਤੇ ਬਹੁਤ ਖ਼ਪਤ ਵਾਲੀ ਹੁੰਦੀ ਹੈ। ਇਹ ਉਹੀ ਕਾਰਨ ਹੈ ਕਿ ਹਵਾਈ ਅੱਡੇ 'ਤੇ ਸੁਰੱਖਿਆ ਸਕਰੀਨਰ ਛੋਟੀਆਂ ਸ਼ਿਫਟਾਂ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹਨ: ਲਗਾਤਾਰ ਸੁਚੇਤ ਰਹਿਣ ਦੀ ਸਮਰੱਥਾ ਜਲਦੀ ਘਟ ਜਾਂਦੀ ਹੈ।
ਵਰਕਫਲੋਅ ਦਾ ਮੇਲ ਨਾ ਖਾਣਾ (Workflow mismatch)। ਜ਼ਿਆਦਾਤਰ ਡਿਵੈਲਪਮੈਂਟ ਮਾਹੌਲ ਅਤੇ ਟੀਮ ਪ੍ਰਕਿਰਿਆਵਾਂ ਅਜੇ ਵੀ ਮਨੁੱਖੀ 'ਲਿਖਣ-ਫਿਰ-ਟੈਸਟ ਕਰਨ' ਦੀ ਲੈਅ 'ਤੇ ਚੱਲਦੀਆਂ ਹਨ। ਕੋਡਬੇਸ ਮਨੁੱਖੀ ਰਫ਼ਤਾਰ ਨਾਲ ਵਧਦਾ ਹੈ, ਅਤੇ ਕੋਡ ਰਿਵਿਊ ਨਿਰਧਾਰਤ ਸਮੇਂ 'ਤੇ ਹੁੰਦੇ ਹਨ। ਜਦੋਂ AI ਨੂੰ ਇਸ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਪ੍ਰਵਾਹ ਟੁੱਟ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਵੀਹ ਲਾਈਨਾਂ ਬਣਾਉਂਦੇ ਹੋ, ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਰੁਕਦੇ ਹੋ, ਸੁਧਾਰ ਲਈ ਕਹਿੰਦੇ ਹੋ, ਫਿਰ ਤੋਂ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹੋ, ਅਗਲੇ ਫੰਕਸ਼ਨ 'ਤੇ ਜਾਂਦੇ ਹੋ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਪੂਰੇ ਆਰਕੀਟੈਕਚਰ ਦਾ ਸਬੰਧ ਗੁਆ ਲੈਂਦੇ ਹੋ। ਰਚਨਾਤਮਕ ਉਤਪਾਦਨ ਅਤੇ ਸ਼ੱਕੀ ਵੈਲੀਡੇਸ਼ਨ ਦੇ ਵਿਚਕਾਰ ਲਗਾਤਾਰ ਬਦਲਣਾ ਰੁਕਾਵਟ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਤੁਹਾਡਾ IDE ਲੇਖਕਾਂ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ, ਨਾ ਕਿ ਲਗਾਤਾਰ ਡੈੱਡਲਾਈਨ ਦੇ ਅਧੀਨ ਕੰਮ ਕਰਨ ਵਾਲੇ ਸੰਪਾਦਕਾਂ (editors) ਲਈ।
ਥਕਾਵਟ ਦਾ ਚੱਕਰ (The Exhaustion Loop)
ਇਹ ਕਾਰਕ ਇੱਕ ਅਜਿਹੇ ਚੱਕਰ ਨੂੰ ਜਨਮ ਦਿੰਦੇ ਹਨ ਜੋ ਦਿਨ ਦੇ ਵਧਦੇ ਹੀ ਹੋਰ ਵਿਗੜਦਾ ਜਾਂਦਾ ਹੈ।
ਸਹਾਇਕ (assistant) ਸਕਿੰਟਾਂ ਵਿੱਚ ਇੱਕ ਫੀਚਰ ਨੂੰ ਲਾਗੂ ਕਰ ਦਿੰਦਾ ਹੈ। ਫਿਰ ਤੁਸੀਂ ਇੰਪੋਰਟਸ ਨੂੰ ਲੱਭਣ, ਟਾਈਪ ਅਨੁਕੂਲਤਾ (type compatibility) ਦੀ ਜਾਂਚ ਕਰਨ, ਅਤੇ ਐਜ ਕੇਸਾਂ (edge cases) ਦੇ ਮਾਨਸਿਕ ਸਿਮੂਲੇਸ਼ਨ ਚਲਾਉਣ ਵਿੱਚ ਪੰਦਰਾਂ ਮਿੰਟ ਖਰਚ ਕਰਦੇ ਹੋ। ਤੀਜੇ ਜਾਂ ਚੌਥੇ ਦੌਰ ਤੱਕ, ਤੁਹਾਡਾ ਧਿਆਨ ਘਟਣ ਲੱਗਦਾ ਹੈ। ਤੁਸੀਂ ਅਜਿਹੇ ਟੁਕੜੇ ਸਵੀਕਾਰ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੇ ਹੋ ਜੋ "ਕਾਫ਼ੀ ਹੱਦ ਤੱਕ ਸਹੀ ਲੱਗਦੇ ਹਨ।" ਗਲਤੀਆਂ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਦੀ ਭਰਪਾਈ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਆਪਣੀ ਰਫ਼ਤਾਰ ਘਟਾ ਦਿੰਦੇ ਹੋ, ਜੋ ਉਸ ਰਫ਼ਤਾਰ ਨੂੰ ਖਤਮ ਕਰ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤੀ ਸੀ। ਤੁਸੀਂ ਦਿਨ ਦੇ ਅੰਤ ਵਿੱਚ ਆਮ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਕੋਡ ਤਾਂ ਲਿਖ ਲੈਂਦੇ ਹੋ, ਪਰ ਉਸ ਵਿੱਚ
Then there is skill atrophy. The muscle of translating intent into syntax weakens when you stop doing it. You might still architect systems well, but the granular fluency — knowing why a certain loop structure feels off, or recalling how a specific library behaves under load — fades when an autocomplete layer handles the details. Over time, you risk becoming a passive curator rather than an active engineer.
The most immediate danger, however, is sloppy deployment. Under pressure to maintain velocity, and exhausted by hours of reading machine output, developers sometimes deploy code they have not fully validated.