ਫੀਚਰ, ਕੈਪੇਬਿਲਟੀ, ਜਾਂ ਨੇਟਿਵ: ਟੀਮਾਂ AI ਨੂੰ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀਆਂ ਹਨ

ਸਾਫਟਵੇਅਰ ਟੀਮਾਂ AI ਨੂੰ ਤਿੰਨ ਤਰੀਕਿਆਂ ਨਾਲ ਦੇਖਦੀਆਂ ਹਨ। ਇੰਜੀਨੀਅਰ ਮਾਰਕੀਟਿੰਗ ਟੀਮਾਂ ਨਾਲੋਂ ਇਸ ਅੰਤਰ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਪਛਾਣ ਲੈਂਦੇ ਹਨ।

ਤਿੰਨ ਕਿਸਮਾਂ ਇਹ ਹਨ:

  • AI Feature: ਤੁਸੀਂ ਇੱਕ ਵਰਕਫਲੋ (workflow) ਵਿੱਚ ਇੱਕ ਬਟਨ ਜੋੜਦੇ ਹੋ ਜੋ ਪਹਿਲਾਂ ਵੀ ਸਹੀ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ। ਇਹ ਵਾਧੂ (additive) ਹੁੰਦਾ ਹੈ। ਇਹ ਮੁੱਖ ਲੌਜਿਕ (core logic) ਨੂੰ ਨਹੀਂ ਬਦਲਦਾ।
  • AI Capability: ਤੁਸੀਂ ਕਈ ਉਤਪਾਦਾਂ ਵਿੱਚ AI ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ। ਨਿਵੇਸ਼ ਜ਼ਿਆਦਾ ਹੁੰਦਾ ਹੈ, ਪਰ ਮੂਲ ਆਰਕੀਟੈਕਚਰ (base architecture) AI ਤੋਂ ਪਹਿਲਾਂ ਦਾ ਹੁੰਦਾ ਹੈ।
  • AI Native: ਆਰਕੀਟੈਕਚਰ ਇਹ ਮੰਨ ਕੇ ਚੱਲਦਾ ਹੈ ਕਿ AI ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਮੌਜੂਦ ਹੈ। ਸਿਸਟਮ ਇਸ ਤੋਂ ਬਿਨਾਂ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦਾ।

ਇਹ ਅੰਤਰ ਭਰੋਸੇ ਕਾਰਨ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਜ਼ਿਆਦਾਤਰ ਕੰਪਨੀਆਂ 'ਕੈਪੇਬਿਲਟੀ' (capability) ਪੱਧਰ 'ਤੇ ਹਨ। ਉਹ ਮੌਜੂਦਾ ਮਾਡਲ ਵਿੱਚ ਬੁੱਧੀ (intelligence) ਜੋੜਦੇ ਹਨ। AI-native ਕੰਪਨੀਆਂ ਬੁੱਧੀ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਮਾਡਲ ਬਣਾਉਂਦੀਆਂ ਹਨ।

ਤੁਸੀਂ ਇੱਕ ਸਵਾਲ ਨਾਲ AI-native ਟੂਲਸ ਦੀ ਪਰਖ ਕਰ ਸਕਦੇ ਹੋ: ਟੂਲ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਕੀ ਤਿਆਰ ਕਰਦਾ ਹੈ?

ਕੀ ਇਹ ਕੋਡ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਸਿਸਟਮ ਦੀ ਲੋੜ (system requirement), ਡਾਟਾਬੇਸ ਸਕੀਮਾ (database schema), ਜਾਂ API ਕੰਟਰੈਕਟ ਤਿਆਰ ਕਰਦਾ ਹੈ? ਜਾਂ ਕੀ ਇਹ ਪਹਿਲਾਂ ਕੋਡ ਜਨਰੇਟ ਕਰਦਾ ਹੈ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਢਾਂਚਾ (structure) ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ?

ਅਸਲੀ AI-native ਸਿਸਟਮ ਜਨਰੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਡਿਜ਼ਾਈਨ ਕਰਦੇ ਹਨ। ਇਹ ਆਉਟਪੁੱਟ (output) ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਇੱਕ ਢਾਂਚਾਗਤ ਤਰੀਕਾ ਬਣਾਉਂਦਾ ਹੈ।

ਇਹ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਡਿਵੈਲਪਰਾਂ ਦਾ ਭਰੋਸਾ ਘਟ ਰਿਹਾ ਹੈ।

ਡਾਟਾ ਇੱਕ ਅਜੀਬ ਰੁਝਾਨ ਦਿਖਾਉਂਦਾ ਹੈ:

  • 2023 ਵਿੱਚ, 70% ਡਿਵੈਲਪਰਾਂ ਨੇ AI ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਜਿਸ ਵਿੱਚ ਭਰੋਸੇ ਦਾ ਪੱਧਰ 40% ਸੀ।
  • 2025 ਤੱਕ, ਵਰਤੋਂ ਵਧ ਕੇ 84% ਹੋ ਗਈ, ਪਰ ਭਰੋਸਾ ਘਟ ਕੇ 29% ਰਹਿ ਗਿਆ।

ਵਰਤੋਂ ਵਧੀ ਹੈ, ਪਰ ਵਿਸ਼ਵਾਸ ਘਟ ਗਿਆ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ, ਕਿਸੇ ਟੂਲ ਦੀ ਵੱਧ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਤੁਹਾਡਾ ਉਸ 'ਤੇ ਭਰੋਸਾ ਵਧਦਾ ਹੈ। AI ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਉਲਟ ਹੋ ਰਿਹਾ ਹੈ। ਇੰਜੀਨੀਅਰ ਇਸ ਦੀ ਜਿੰਨੀ ਜ਼ਿਆਦਾ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਉਨਾ ਹੀ ਜ਼ਿਆਦਾ ਪਤਾ ਲੱਗਦਾ ਹੈ ਕਿ ਇਹ ਪ੍ਰੋਡਕਸ਼ਨ (production) ਵਿੱਚ ਕਿੱਥੇ ਫੇਲ੍ਹ ਹੁੰਦਾ ਹੈ।

ਫੀਚਰਸ ਵਿੱਚ ਗਲਤੀਆਂ ਫੜਨ ਲਈ ਆਰਕੀਟੈਕਚਰ ਦੀ ਕਮੀ ਹੁੰਦੀ ਹੈ। ਉਹ ਅਜਿਹਾ ਆਉਟਪੁੱਟ ਦਿੰਦੇ ਹਨ ਜੋ ਸੁਣਨ ਵਿੱਚ ਸਹੀ ਲੱਗਦਾ ਹੈ ਪਰ ਉਸ ਵਿੱਚ ਢਾਂਚਾਗਤ ਸਬੂਤ (structural proof) ਦੀ ਕਮੀ ਹੁੰਦੀ ਹੈ।

AI-native ਸਿਸਟਮ ਲੂਪ ਵਿੱਚ ਇੱਕ ਸਪੈਕ (spec) ਜਾਂ ਡਿਪੈਂਡੈਂਸੀ ਗ੍ਰਾਫ (dependency graph) ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ। ਸਿਸਟਮ ਇੱਕ ਯੋਜਨਾ ਦੇ ਅਨੁਸਾਰ AI ਆਉਟਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਇਸ ਲਈ ਆਉਟਪੁੱਟ 'ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕਰਦਾ ਕਿਉਂਕਿ ਇਹ ਸੁਣਨ ਵਿੱਚ ਸੰਭਵ ਲੱਗਦਾ ਹੈ।

ਇਹ ਪੁੱਛਣਾ ਬੰਦ ਕਰੋ ਕਿ ਕੀ ਕਿਸੇ ਟੂਲ ਵਿੱਚ AI ਹੈ। ਹੁਣ ਹਰ ਚੀਜ਼ ਵਿੱਚ AI ਹੈ।

ਕ੍ਰਮ (sequencing) ਬਾਰੇ ਪੁੱਛੋ। ਕੀ ਟੂਲ ਪਹਿਲਾਂ ਢਾਂਚਾ ਬਣਾਉਂਦਾ ਹੈ ਜਾਂ ਕੋਡ?

ਜਵਾਬ ਤੁਹਾਨੂੰ ਦੱਸੇਗਾ ਕਿ ਜਦੋਂ ਜੋਖਮ (stakes) ਜ਼ਿਆਦਾ ਹੋਣਗੇ ਤਾਂ ਕੀ ਉਹ ਟੂਲ ਉਪਯੋਗੀ ਰਹੇਗਾ।

ਸਰੋਤ: https://dev.to/8080_ai/feature-capability-or-native-how-software-teams-define-ai-4k0h