ਤੁਹਾਡਾ AI ਕੋਡਿੰਗ ਸੈੱਟਅੱਪ ਇੱਕ Complicated ਟੂਲ ਹੈ। ਤੁਹਾਡਾ Codebase Complex ਹੈ।
ਨਵੇਂ AI ਕੋਡਿੰਗ ਟੂਲ agents ਨੂੰ ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ ਬਣਾਉਣ ਦਾ ਵਾਅਦਾ ਕਰਦੇ ਹਨ। ਤੁਸੀਂ skills, superpowers, ਅਤੇ spec-driven development ਲਈ frameworks ਦੇਖਦੇ ਹੋ। ਇਹ ਟੂਲ ਕੰਮ ਕਰਦੇ ਹਨ। ਉਹ agents ਨੂੰ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਦੀ ਬਜਾਏ ਇੱਕ ਪ੍ਰਕਿਰਿਆ (process) ਦੀ ਪਾਲਣਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ।
ਪਰ ਇੱਕ ਜਾਲ ਹੈ। ਲੋਕ ਸੋਚਦੇ ਹਨ ਕਿ ਇੱਕ ਕੰਮ ਲਈ ਬਿਹਤਰ ਸੈੱਟਅੱਪ ਇੱਕ ਇਕਸਾਰ (coherent) ਸਿਸਟਮ ਬਣਾਉਂਦਾ ਹੈ। ਅਜਿਹਾ ਨਹੀਂ ਹੈ।
ਇਹ ਸਮਝਣ ਲਈ ਕਿ ਕਿਉਂ, Cynefin framework ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਹ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਦੋ ਕਿਸਮਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ: Complicated ਅਤੇ Complex।
Complicated ਸਮੱਸਿਆਵਾਂ ਇਹਨਾਂ ਦਾ ਜਵਾਬ ਜਾਣਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਲੱਭਣ ਲਈ ਵਿਸ਼ਲੇਸ਼ਣ (analysis) ਅਤੇ ਹੁਨਰ (skill) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ। ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਇੱਕ module ਨੂੰ refactor ਕਰਨਾ ਜਾਂ validation function ਲਿਖਣਾ ਸ਼ਾਮਲ ਹੈ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਜਵਾਬ ਲੱਭ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਦੁਹਰਾ ਸਕਦੇ ਹੋ। ਜ਼ਿਆਦਾਤਰ AI ਕੋਡਿੰਗ ਟੂਲ ਇੱਥੇ ਹੀ ਹੁੰਦੇ ਹਨ। ਉਹ ਕੰਮ ਦੀ ਇਕਾਈ (unit of work) 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਦੇ ਹਨ। ਉਹ ਕੰਮਾਂ ਨੂੰ ਦੁਹਰਾਉਣਯੋਗ ਅਤੇ ਪ੍ਰਮਾਣਿਤ (verifiable) ਬਣਾਉਂਦੇ ਹਨ।
Complex ਸਮੱਸਿਆਵਾਂ ਇਹਨਾਂ ਦਾ ਕੋਈ ਅਨੁਮਾਨਿਤ (predictable) ਜਵਾਬ ਨਹੀਂ ਹੁੰਦਾ। ਸਿਸਟਮ ਹਿੱਸਿਆਂ ਦਾ ਇੱਕ ਜਾਲ ਹੁੰਦਾ ਹੈ। ਨਤੀਜੇ ਤੁਹਾਡੇ ਕੰਮ ਕਰਨ ਤੋਂ ਬਾਅਦ ਹੀ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ। ਕੀ ਚਾਲੀ merged ਬਦਲਾਅ ਛੇ ਮਹੀਨਿਆਂ ਵਿੱਚ architecture ਨੂੰ ਤੋੜ ਦੇਣਗੇ? ਕੀ Agent A, Agent B ਦੇ ਉਲਟ ਜਾਵੇਗਾ? ਤੁਸੀਂ ਇੱਕ ਫਾਈਲ ਨੂੰ ਦੇਖ ਕੇ ਇਹ ਜਵਾਬ ਨਹੀਂ ਲੱਭ ਸਕਦੇ। ਇਹ ਇਸ ਗੱਲ ਤੋਂ ਉੱਭਰਦੇ ਹਨ ਕਿ ਹਿੱਸੇ ਆਪਸ ਵਿੱਚ ਕਿਵੇਂ ਗੱਲਬਾਤ (interact) ਕਰਦੇ ਹਨ।
ਗਲਤਫਹਿਮੀ ਉਦੋਂ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ Complicated ਟੂਲਾਂ ਤੋਂ Complex ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਦੇ ਹੋ।
ਇੱਕ ਟੂਲ ਇੱਕ agent ਨੂੰ ਇੱਕ ਸੰਪੂਰਨ (perfect) function ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਪਰ ਜੇਕਰ ਇੱਕ ਕੰਮ userId ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਅਤੇ ਦੂਜਾ user_id ਦੀ, ਤਾਂ ਸਿਸਟਮ ਟੁੱਟ ਜਾਂਦਾ ਹੈ। ਦੋਵੇਂ ਕੰਮ ਅਲੱਗ-ਅਲੱਗ ਤੌਰ 'ਤੇ "ਸਹੀ" ਸਨ। ਅਸਫਲਤਾ ਉਭਰਦੀ (emergent) ਹੈ। ਇਹ ਆਪਸੀ ਗੱਲਬਾਤ (interaction) ਵਿੱਚ ਹੁੰਦੀ ਹੈ, ਇਕਾਈ (unit) ਵਿੱਚ ਨਹੀਂ।
ਇੱਥੋਂ ਤੱਕ ਕਿ ਵਿਸ਼ਾਲ context windows ਵੀ ਇਸਨੂੰ ਹੱਲ ਨਹੀਂ ਕਰ ਸਕਦੀਆਂ। ਇੱਕ ਵੱਡੀ window ਤੁਹਾਨੂੰ ਵਧੇਰੇ ਦੇਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ, ਪਰ ਦੇਖਣਾ ਅਤੇ ਅਨੁਮਾਨ ਲਗਾਉਣਾ (deducing) ਇੱਕੋ ਜਿਹਾ ਨਹੀਂ ਹੈ। ਤੁਸੀਂ ਪੂਰਾ codebase ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਫਿਰ ਵੀ ਨਹੀਂ ਜਾਣ ਸਕਦੇ ਕਿ ਕੀ ਇਹ production load ਦੇ ਅਧੀਨ deadlock ਹੋ ਜਾਵੇਗਾ। ਇਹ ਇੱਕ runtime property ਹੈ।
ਦੋਵਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਣਾ ਹੈ:
- For the Complicated layer: Use skills, specs, ਅਤੇ TDD। ਇਹ agent ਦੇ ਵਿਅਕਤੀਗਤ ਆਉਟਪੁੱਟ ਨੂੰ ਸਖ਼ਤ (rigorous) ਬਣਾਉਂਦੇ ਹਨ।
- For the Complex layer: Use probe-sense-respond। ਤੁਸੀਂ ਅਨੁਮਾਨ ਨਹੀਂ ਲਗਾ ਸਕਦੇ ਕਿ ਕੀ ਟੁੱਟੇਗਾ। ਤੁਹਾਨੂੰ merge, deploy, ਅਤੇ observe ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਜਦੋਂ ਹਿੱਸੇ ਮਿਲਦੇ ਹਨ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ, ਇਸ ਨੂੰ ਮਹਿਸੂਸ ਕਰਨ ਲਈ integration tests ਅਤੇ observability ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਇਸ ਵਾਅਦੇ ਦੇ ਚੱਕਰ ਵਿੱਚ ਨਾ ਆਓ ਕਿ ਇੱਕ ਬਿਹਤਰ spec ਤੁਹਾਡੇ ਸਿਸਟਮ ਨੂੰ ਸਥਿਰ (stable) ਬਣਾ ਦੇਵੇਗਾ। Specs ਇਕਾਈ (unit) ਨੂੰ ਭਰੋਸੇਮੰਦ ਬਣਾਉਂਦੇ ਹਨ। ਉਹ ਸਿਸਟਮ ਨੂੰ ਇਕਸਾਰ (coherent) ਨਹੀਂ ਬਣਾਉਂਦੇ।
ਆਪਣੇ ਤਰੀਕੇ ਨੂੰ domain ਦੇ ਅਨੁਕੂਲ ਰੱਖੋ। ਇਕਾਈ (unit) ਨੂੰ ਸੰਪੂਰਨ ਬਣਾਉਣ ਲਈ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸਿਸਟਮ ਨੂੰ ਸਮਝਣ ਲਈ ਪ੍ਰਯੋਗ (experimentation) ਦੀ ਵਰਤੋਂ ਕਰੋ।
Optional learning community: https://t.me/GyaanSetuAi