ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਕਹਿੰਦੇ ਹਨ ਕਿ AI ਸੌਫਟਵੇਅਰ ਵਿਕਾਸ ਨੂੰ ਬਹੁਤ ਸਸਤਾ ਕਰ ਦੇਵੇਗਾ। ਉਹ ਕਲਪਨਾ ਕਰਦੇ ਹਨ ਕਿ ਮਾਡਲ ਇੰਜੀਨੀਅਰਾਂ ਦੀ ਜਗ੍ਹਾ ਲੈ ਲੈਣਗੇ ਅਤੇ ਮਿੰਟਾਂ ਵਿੱਚ ਕੰਮ ਖਤਮ ਕਰ ਦੇਣਗੇ। ਇਹ ਕਹਾਣੀ ਸੁਣਨ ਵਿੱਚ ਚੰਗੀ ਲੱਗਦੀ ਹੈ, ਪਰ ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸੱਚ ਨਹੀਂ ਹੈ। ਸੌਫਟਵੇਅਰ ਬਣਾਉਣ ਦੇ ਅਰਥ ਸ਼ਾਸਤਰ ਬਦਲ ਗਏ ਹਨ, ਖਤਮ ਨਹੀਂ ਹੋਏ। ਜਦੋਂ ਪਹਿਲਾ ਕੋਡਿੰਗ ਸਹਾਇਕ (coding assistant) ਆਇਆ, ਤਾਂ ਤਕਨੀਕੀ ਕਰਜ਼ਾ (technical debt) ਖਤਮ ਨਹੀਂ ਹੋਇਆ। ਅਸੀਂ ਸਿਰਫ਼ ਇਸ ਨੂੰ ਅਦਾ ਕਰਨ ਦਾ ਇੱਕ ਨਵਾਂ ਤਰੀਕਾ ਲੱਭ ਲਿਆ ਹੈ।

ਪੁਰਾਣਾ ਬਿੱਲ: ਮੁਲਾਜ਼ਮਾਂ ਦੀ ਗਿਣਤੀ

ਦਹਾਕਿਆਂ ਤੋਂ, ਤਕਨੀਕੀ ਕਰਜ਼ੇ ਨੇ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਦੁਖਦਾਈ ਚੱਕਰ (doom loop) ਨੂੰ ਜਨਮ ਦਿੱਤਾ। ਇੱਕ ਕੋਡਬੇਸ ਕਮਜ਼ੋਰ ਹੋਣ ਲੱਗਦਾ ਸੀ। ਉਹ ਫੀਚਰ ਜੋ ਕਦੇ ਦਿਨਾਂ ਵਿੱਚ ਹੋ ਜਾਂਦੇ ਸਨ, ਹੁਣ ਹਫ਼ਤਿਆਂ ਲੈਣ ਲੱਗ ਪਏ। ਡੈੱਡਲਾਈਨਾਂ ਖਿਸਕਦੀਆਂ ਗਈਆਂ, ਤਾਂ ਲੀਡਰਸ਼ਿਪ ਨੇ ਹੋਰ ਨਵੀਆਂ ਭਰਤੀਆਂ ਕੀਤੀਆਂ। ਵੱਡੀਆਂ ਟੀਮਾਂ ਨੇ ਕੰਮ ਦੀ ਰਫ਼ਤਾਰ ਨੂੰ ਹੋਰ ਵੀ ਹੌਲੀ ਕਰ ਦਿੱਤਾ। ਤਾਲਮੇਲ ਦਾ ਬੋਝ ਵਧ ਗਿਆ, ਸਟੈਂਡ-ਅੱਪ ਮੀਟਿੰਗਾਂ ਵਧ ਗਈਆਂ, ਅਤੇ ਕੌਨਵੇ ਦਾ ਨਿਯਮ (Conway’s Law) ਲਾਗੂ ਹੋ ਗਿਆ: ਸੌਫਟਵੇਅਰ ਉਸ ਲੋਕਾਂ ਦੇ ਗਲਤ ਸੰਚਾਰ ਦਾ ਪ੍ਰਤੀਬਿੰਬ ਬਣਨ ਲੱਗਾ ਜੋ ਇਸਨੂੰ ਬਣਾ ਰਹੇ ਸਨ। ਜ਼ਿਆਦਾ ਬੱਗਸ (bugs) ਨਿਕਲਣ ਲੱਗੇ। ਹਰ ਪੈਚ ਨੇ ਗੁੰਝਲਤਾ ਦੀਆਂ ਨਵੀਆਂ ਪਰਤਾਂ ਜੋੜ ਦਿੱਤੀਆਂ। ਕੰਪਨੀਆਂ ਇਸ ਖਰਾਬੀ ਲਈ ਉਸੇ ਇੱਕ ਤਰੀਕੇ ਨਾਲ ਭੁਗਤਾਨ ਕਰਦੀਆਂ ਸਨ ਜੋ ਉਹ ਜਾਣਦੇ ਸਨ: ਮਨੁੱਖੀ ਤਨਖਾਹਾਂ। ਇਹ ਲਾਗਤ ਸਪੱਸ਼ਟ ਸੀ। ਇਹ ਹਰ ਤਿਮਾਹੀ ਬਜਟ ਸਮੀਖਿਆ ਵਿੱਚ ਸਾਹਮਣੇ ਆਉਂਦੀ ਸੀ।

ਨਵਾਂ ਬਿੱਲ: ਟੋਕਨ ਅਤੇ ਕੰਟੈਕਸਟ

ਜਨਰੇਟਿਵ AI ਨੇ ਇਸ ਚੱਕਰ ਨੂੰ ਤੋੜਿਆ ਨਹੀਂ ਹੈ। ਇਸ ਨੇ ਸਿਰਫ਼ ਅਦਾਇਗੀ ਦੀ ਇੱਕ ਬਦਲਵੇਂ ਯੋਜਨਾ ਪੇਸ਼ ਕੀਤੀ ਹੈ। ਰੁਕਾਵਟਾਂ ਨੂੰ ਦੂਰ ਕਰਨ ਲਈ ਪੰਜ ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ ਰੱਖਣ ਦੀ ਬਜਾਏ, ਇੱਕ ਕੰਪਨੀ ਹੁਣ ਵਧੇਰੇ ਕੰਪਿਊਟ (compute) ਲਈ ਕ੍ਰੈਡਿਟ ਕਾਰਡ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਲੱਛਣ ਵੱਖਰੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ, ਪਰ ਅਸਲ ਬਿਮਾਰੀ ਉਹੀ ਹੈ।

ਜਦੋਂ ਕੋਈ ਮਾਡਲ ਅਸਫਲ ਹੋਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ—ਜਿਵੇਂ ਕਿ ਅੰਦਰੂਨੀ API ਬਾਰੇ ਗਲਤ ਜਾਣਕਾਰੀ (hallucinating) ਦੇਣਾ, ਮਹੱਤਵਪੂਰਨ ਐਜ ਕੇਸਾਂ (edge cases) ਨੂੰ miss ਕਰਨਾ, ਜਾਂ ਅਜਿਹੇ ਟੈਸਟ ਬਣਾਉਣਾ ਜੋ ਗਲਤ ਕਾਰਨਾਂ ਕਰਕੇ ਪਾਸ ਹੋ ਰਹੇ ਹਨ—ਤਾਂ ਅਕਸਰ ਲੋਕ ਉਸ ਨੂੰ ਸੁਧਾਰਨ (refactor) ਦੀ ਬਜਾਏ ਪੈਸਾ ਇਨਫਰੈਂਸ (inference) 'ਤੇ ਖਰਚ ਕਰਦੇ ਹਨ। ਟੀਮਾਂ ਕੰਟੈਕਸਟ-ਵਿੰਡੋ ਅੱਪਗ੍ਰੇਡ ਖਰੀਦਦੀਆਂ ਹਨ, ਮਲਟੀ-ਏਜੰਟ ਰੀਟ੍ਰਾਈ ਲੂਪਸ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਕੰਮ ਦੇ ਬੋਝ ਨੂੰ ਵੱਡੇ ਫਰੰਟੀਅਰ ਮਾਡਲਾਂ 'ਤੇ ਤਬਦੀਲ ਕਰਦੀਆਂ ਹਨ, ਜਾਂ ਉਦੋਂ ਤੱਕ 'regenerate' ਬਟਨ ਦਬਾਉਂਦੀਆਂ ਰਹਿੰਦੀਆਂ ਹਨ ਜਦੋਂ ਤੱਕ ਨਤੀਜਾ ਸਵੀਕਾਰਯੋਗ ਨਾ ਲੱਗੇ। ਇਹ ਤਕਨੀਕਾਂ ਇੱਕ ਜਾਂ ਦੋ ਸਪ੍ਰਿੰਟਾਂ ਲਈ ਕਥਿਤ ਰਫ਼ਤਾਰ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੀਆਂ ਹਨ। Jira ਬੋਰਡ ਹਰਾ ਰਹਿੰਦਾ ਹੈ। ਇਸ ਦੌਰਾਨ, ਅਸਲ ਆਰਕੀਟੈਕਚਰ ਅਛੂਤਾ ਰਹਿੰਦਾ ਹੈ: ਉਹੀ ਉਲਝੀਆਂ ਹੋਈਆਂ ਡਿਪੈਂਡੈਂਸੀਆਂ, ਉਹੀ ਬਦਲਣਯੋਗ ਗਲੋਬਲ ਸਟੇਟ, ਅਤੇ ਉਹੀ ਮੋਨੋਲਿਥ ਜਿਸ ਨੂੰ ਮੌਜੂਦਾ ਟੀਮ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਹੀਂ ਸਮਝਦਾ।

ਗੰਦਾ ਕੋਡ ਟੋਕਨਾਂ ਦੀ ਕੀਮਤ ਕਿਉਂ ਵਧਾਉਂਦਾ ਹੈ

ਲਾਰਜ ਲੈਂਗੂਏਜ ਮਾਡਲ ਸਾਫ਼ ਐਬਸਟਰੈਕਸ਼ਨ (abstractions) ਦੇ ਵਿਰੁੱਧ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਜ਼ਿਆਦਾਤਰ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਰਿਪੋਜ਼ਟਰੀਆਂ ਪੁਰਾਤੱਤਵ ਸਥਾਨਾਂ (archaeological sites) ਵਾਂਗ ਹਨ। ਉਹਨਾਂ ਵਿੱਚ ਸਰਕੂਲਰ ਪੈਕੇਜ ਡਿਪੈਂਡੈਂਸੀਆਂ, ਇਨੀਸ਼ੀਅਲਾਈਜ਼ੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਦਬੇ ਹੋਏ ਗੁਪਤ ਸਾਈਡ ਇਫੈਕਟਸ, ਅਤੇ ਡਾਟਾਬੇਸ ਟ੍ਰਿਗਰਜ਼, ਮਿਡਲਵੇਅਰ ਲੇਅਰਾਂ ਅਤੇ ਫਰੰਟ-ਐਂਡ ਕੰਪੋਨੈਂਟਸ ਵਿੱਚ ਫੈਲੀ ਹੋਈ ਬਿਜ਼ਨਸ ਲੌਜਿਕ ਹੁੰਦੀ ਹੈ। ਅਜਿਹੇ ਮਾਹੌਲ ਵਿੱਚ, ਮਾਡਲ ਆਪਣੀ ਊਰਜਾ ਨਵਾਂ ਲੌਜਿਕ ਲਿਖਣ ਵਿੱਚ ਨਹੀਂ ਲਗਾਉਂਦਾ। ਇਹ ਸਮਝਣ (comprehension) ਵਿੱਚ ਟੋਕਨ ਖਰਚ ਕਰਦਾ ਹੈ।

128,000-ਟੋਕਨ ਕੰਟੈਕਸਟ ਵਿੰਡੋ ਦਾ ਇੱਕ ਵੱਡਾ ਹਿੱਸਾ ਸਿਰਫ਼ ਸਿਸਟਮ ਦੇ ਢਾਂਚੇ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਰੱਖਣ ਵਿੱਚ ਹੀ ਖਤਮ ਹੋ ਸਕਦਾ ਹੈ। ਬਾਕੀ ਬਚਿਆ ਹਿੱਸਾ ਅਸਲ ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਲਈ ਬਚਦਾ ਹੈ। ਇਹ ਇੱਕ ਸਟ੍ਰਕਚਰਲ ਇੰਜੀਨੀਅਰ ਨੂੰ ਹਰ ਗਣਨਾ ਤੋਂ ਪਹਿਲਾਂ ਮੌਜੂਦਾ ਇਮਾਰਤ ਦੇ ਨਕਸ਼ੇ ਯਾਦਦਾਸ਼ਤ ਤੋਂ ਦੁਬਾਰਾ ਬਣਾਉਣ ਲਈ ਮਜਬੂਰ ਕਰਨ ਦੇ ਨਾਲ-ਨਾਲ ਇੱਕ ਨਵਾਂ ਫਲੋਰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ ਕਹਿਣ ਵਰਗਾ ਹੈ। ਨਤੀਜਾ ਸਿਰਫ਼ ਉਪਰਵਰੀ ਹੱਲ ਹੁੰਦੇ ਹਨ। ਮਾਡਲ ਉਸੇ ਗੰਦਗੀ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ ਜੋ ਉਹ ਦੇਖਦਾ ਹੈ ਕਿਉਂਕਿ ਉਸ ਕੋਲ ਪਹਿਲਾਂ ਕਮਰੇ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਅਥਾਰਟੀ ਜਾਂ ਆਰਕੀਟੈਕਚਰਲ ਕੰਟੈਕਸਟ ਨਹੀਂ ਹੁੰਦੀ।

ਤੇਜ਼ ਆਉਟਪੁੱਟ, ਹੌਲੀ ਸ਼ਿਪਿੰਗ

ਰੌਅ ਜਨਰੇਸ਼ਨ ਸਪੀਡ (Raw generation speed) ਦਾ ਮਤਲਬ ਤੇਜ਼ ਸ਼ਿਪਿੰਗ ਸਪੀਡ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਮੋਡਿਊਲਰਿਟੀ ਦੀ ਕਮੀ ਹੈ, ਤਾਂ ਹਰ AI-ਜਨਰੇਟਡ ਬਦਲਾਅ ਲਈ ਵਿਆਪਕ ਮਨੁੱਖੀ ਸਮੀਖਿਆ ਅਤੇ ਰੈਗਰੈਸ਼ਨ ਟੈਸਟਿੰਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ ਮਾਡਲ ਦੁਪਹਿਰ ਵੇਲੇ ਦਸ ਪੁੱਲ ਰਿਕੁਐਸਟਾਂ (pull requests) ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਉਹਨਾਂ ਪੁੱਲ ਰਿਕੁਐਸਟਾਂ ਨੂੰ ਅਜੇ ਵੀ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਐਨਵਾਇਰਨਮੈਂਟਸ, ਸੁਰੱਖਿਆ ਸਕੈਨਰਾਂ, ਕੰਪਲਾਇੰਸ ਚੈੱਕਲਿਸਟਾਂ ਅਤੇ ਪ੍ਰੋਡਕਸ਼ਨ ਕੈਨਰੀਜ਼ (production canaries) ਵਿੱਚੋਂ ਗੁਜ਼ਰਨਾ ਪੈਂਦਾ ਹੈ। ਸਪੱਸ਼ਟ ਮੋਡਿਊਲ ਸੀਮਾਵਾਂ ਤੋਂ ਬਿਨਾਂ, AI ਮਸ਼ੀਨ ਦੀ ਰਫ਼ਤਾਰ ਨਾਲ ਬੱਗਸ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇਹ ਇੱਕ ਸਾਂਝੇ ਯੂਟੀਲਿਟੀ ਨੂੰ ਬਦਲ ਸਕਦਾ ਹੈ, ਤਿੰਨ ਦੂਰ-ਦੂਰ ਦੇ ਕਾਲ ਸਾਈਟਾਂ ਨੂੰ ਮਾਮੂਲੀ ਗਲਤ ਅਸੰਗਤਤਾਵਾਂ ਨਾਲ ਅਪਡੇਟ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਅਜਿਹੀਆਂ ਰੇਸ ਕੰਡੀਸ਼ਨਾਂ (race conditions) ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਮਨੁੱਖ ਸਿਰਫ਼ ਰਾਤ ਦੇ 3 ਵਜੇ ਆਉਣ ਵਾਲੇ ਐਲਰਟ ਦੌਰਾਨ ਹੀ ਫੜ ਸਕਦੇ ਹਨ। ਰੁਕਾਵਟ ਕੀਬੋਰਡ ਤੋਂ ਹਟ ਕੇ ਵੈਲੀਡੇਸ਼ਨ ਪਾਈਪਲਾਈਨ ਵੱਲ ਚਲੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਉਹ ਪਾਈਪਲਾਈਨ ਬਦਲਾਅ ਦੇ ਦਸ ਗੁਣਾ ਵਧੇ ਹੋਏ ਮਾਤਰਾ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਨਹੀਂ ਬਣਾਈ ਗਈ ਸੀ।

ਲੁਕੀ ਹੋਈ ਸੀਮਾ

AI ਤੋਂ ਪਹਿਲਾਂ ਦੇ ਦੌਰ ਵਿੱਚ, ਸਖ਼ਤ ਸੀਮਾ ਤੁਹਾਡਾ ਭਰਤੀ ਬਜਟ ਸੀ। ਉਹ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਸਪ੍ਰੈਡਸ਼ੀਟ 'ਤੇ ਦੇਖਣਾ ਆਸਾਨ ਸੀ। ਹੁਣ ਰੋਕ ਅਜਿਹੇ ਖਰਚਿਆਂ ਵਿੱਚ ਦਬੀ ਹੋਈ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਜ਼ਿਆਦਾਤਰ ਫਾਈਨਾਂਸ ਟੀਮਾਂ ਬਹੁਤ ਘੱਟ ਟਰੈਕ ਕਰਦੀਆਂ ਹਨ: ਇਨਫਰੈਂਸ ਲਾਗਤਾਂ, ਐਮਬੈਡਿੰਗ ਸਟੋਰੇਜ, ਕੰਟੈਕਸਟ-ਵਿੰਡੋ ਵਿਸਥਾਰ, ਅਤੇ ਆਟੋਮੇਟਿਡ-ਟੈਸਟਿੰਗ ਦੀ ਰੁਕਾਵਟ ਜੋ CI ਰਨਰਜ਼ ਨੂੰ ਰੋਕ ਦਿੰਦੀ ਹੈ। ਪ੍ਰੋਡਕਟੀਵਿਟੀ ਡੈਸ਼ਬੋਰਡ ਹਰੇ ਰੰਗ ਵਿੱਚ ਚਮਕਦੇ ਰਹਿੰਦੇ ਹਨ ਜਦੋਂ ਕਿ ਹਰੇਕ ਨਵੇਂ ਫੀਚਰ ਦੀ ਅਸਲ ਲਾਗਤ ਚੁੱਪਚਾਪ ਵਧਦੀ ਜਾਂਦੀ ਹੈ।

Architectural entropy is the real villain here. LLMs scale code production beautifully, but they do not reduce complexity. They do not untangle microservices, eliminate dead code, or collapse inheritance hierarchies. Once a system crosses the threshold where humans struggle to reason about it, AI struggles too. At that inflection point, costs curve upward whether you