OpenAI Codex ਕਿਵੇਂ ਵਰਤਦਾ ਹੈ
Codex ਨੂੰ OpenAI ਦੀਆਂ ਕਈ ਤਕਨੀਕੀ ਟੀਮਾਂ ਜਿਵੇਂ Security, Product Engineering, Frontend, API, Infrastructure, ਅਤੇ Performance Engineering ਵਿੱਚ ਰੋਜ਼ਾਨਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ. ਟੀਮਾਂ ਇਸਦਾ ਇਸਤੇਮਾਲ ਇੰਜੀਨੀਅਰਿੰਗ ਦੇ ਕਈ ਕੰਮ ਤੇਜ਼ ਕਰਨ ਲਈ ਕਰ ਰਹੀਆਂ ਹਨ, ਜਿਵੇਂ ਜਟਿਲ ਸਿਸਟਮ ਸਮਝਣਾ, ਵੱਡੇ codebase ਰੀਫੈਕਟਰ ਕਰਨਾ, ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ship ਕਰਨਾ, ਅਤੇ ਤੰਗ ਸਮਾਂ-ਸੀਮਾਵਾਂ ਹੇਠ incidents ਹੱਲ ਕਰਨਾ.
OpenAI ਇੰਜੀਨੀਅਰਾਂ ਨਾਲ ਇੰਟਰਵਿਊ ਅਤੇ ਅੰਦਰੂਨੀ ਵਰਤੋਂ ਦੇ ਡਾਟਾ ਦੇ ਆਧਾਰ 'ਤੇ, ਅਸੀਂ ਕੁਝ use cases ਅਤੇ best practices ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਹਨ ਜੋ ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਕਿ Codex ਸਾਡੀਆਂ ਟੀਮਾਂ ਨੂੰ ਹੋਰ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਨ, ਕੰਮ ਦੀ ਗੁਣਵੱਤਾ ਸੁਧਾਰਣ ਅਤੇ ਵੱਡੇ ਪੱਧਰ 'ਤੇ complexity ਸੰਭਾਲਣ ਵਿੱਚ ਕਿਵੇਂ ਮਦਦ ਕਰਦਾ ਹੈ.
Codex ਸਾਡੀਆਂ ਟੀਮਾਂ ਨੂੰ onboarding, debugging ਜਾਂ incident ਦੀ ਜਾਂਚ ਦੌਰਾਨ codebase ਦੇ ਅਣਜਾਣ ਹਿੱਸਿਆਂ ਵਿੱਚ ਜਲਦੀ ਸਮਝ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ.
ਉਹ ਅਕਸਰ Codex ਦੀ ਵਰਤੋਂ feature ਦੀ core logic ਲੱਭਣ, services ਜਾਂ modules ਦੇ ਸੰਬੰਧ ਮੈਪ ਕਰਨ, ਅਤੇ ਸਿਸਟਮ ਵਿੱਚ data flow ਟ੍ਰੇਸ ਕਰਨ ਲਈ ਕਰਦੇ ਹਨ. ਇਹ architecture patterns ਜਾਂ documentation ਦੇ ਉਹ ਗੁੰਮ ਹਿੱਸੇ ਵੀ ਸਾਹਮਣੇ ਲਿਆਉਂਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਨਹੀਂ ਤਾਂ ਬਣਾਉਣ ਲਈ ਕਾਫ਼ੀ ਹੱਥੋਂ ਮਿਹਨਤ ਲੱਗਦੀ.
Incident response ਦੌਰਾਨ, Codex ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ components ਵਿਚਾਲੇ interactions ਦਿਖਾ ਕੇ ਜਾਂ failure states ਸਿਸਟਮਾਂ ਵਿੱਚ ਕਿਵੇਂ ਫੈਲਦੀਆਂ ਹਨ ਇਹ ਟ੍ਰੇਸ ਕਰਕੇ ਨਵੇਂ ਖੇਤਰਾਂ ਵਿੱਚ ਜਲਦੀ ਰਫ਼ਤਾਰ ਫੜਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ.
ਸਾਡੀਆਂ ਟੀਮਾਂ ਦੇ ਤਜਰਬੇ
“ਜਦੋਂ ਮੈਂ ਕੋਈ bug ਠੀਕ ਕਰਦਾ ਹਾਂ, ਮੈਂ Ask mode ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ ਇਹ ਵੇਖਣ ਲਈ ਕਿ codebase ਵਿੱਚ ਹੋਰ ਕਿੱਥੇ ਇਹੀ issue ਆ ਸਕਦਾ ਹੈ”
ਇਸ repo ਵਿੱਚ authentication logic ਕਿੱਥੇ ਲਾਗੂ ਕੀਤੀ ਗਈ ਹੈ?
ਸਾਰ ਦਿਓ ਕਿ requests ਇਸ ਸੇਵਾ ਵਿੱਚ entrypoint ਤੋਂ response ਤੱਕ ਕਿਵੇਂ ਵਗਦੀਆਂ ਹਨ.
[insert module name] ਨਾਲ ਕਿਹੜੇ modules interact ਕਰਦੇ ਹਨ ਅਤੇ failures ਕਿਵੇਂ handle ਹੁੰਦੀਆਂ ਹਨ?
Codex ਆਮ ਤੌਰ 'ਤੇ ਉਹ ਬਦਲਾਅ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਕਈ files ਜਾਂ packages ਤੱਕ ਫੈਲੇ ਹੋਣ. ਉਦਾਹਰਨ ਵਜੋਂ, ਜਦੋਂ ਇੰਜੀਨੀਅਰ API ਅਪਡੇਟ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹਨ, ਕਿਸੇ pattern ਦੇ ਲਾਗੂ ਹੋਣ ਦਾ ਤਰੀਕਾ ਬਦਲ ਰਹੇ ਹੁੰਦੇ ਹਨ, ਜਾਂ ਕਿਸੇ ਨਵੀਂ dependency ਵੱਲ ਮਾਈਗ੍ਰੇਟ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹਨ, Codex ਬਦਲਾਅ ਲਗਾਤਾਰ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ.
ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਤਦੋਂ ਲਾਭਕਾਰੀ ਹੈ ਜਦੋਂ ਇੱਕੋ ਅਪਡੇਟ ਦਰਜਨਾਂ files ਵਿੱਚ ਕਰਨੀ ਹੋਵੇ, ਜਾਂ ਜਦੋਂ ਅਪਡੇਟ ਲਈ structure ਅਤੇ dependencies ਦੀ ਅਜਿਹੀ ਸਮਝ ਚਾਹੀਦੀ ਹੋਵੇ ਜੋ regex ਜਾਂ find-and-replace ਨਾਲ ਅਸਾਨੀ ਨਾਲ ਨਾ ਫੜੀ ਜਾ ਸਕੇ.
ਉਹ code cleanup ਲਈ ਵੀ ਇਸਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਨ, ਜਿਵੇਂ ਬਹੁਤ ਵੱਡੇ modules ਨੂੰ ਤੋੜਨਾ, ਪੁਰਾਣੇ patterns ਨੂੰ ਆਧੁਨਿਕ patterns ਨਾਲ ਬਦਲਣਾ, ਜਾਂ code ਨੂੰ ਬਿਹਤਰ testability ਲਈ ਤਿਆਰ ਕਰਨਾ.
ਸਾਡੀਆਂ ਟੀਮਾਂ ਦੇ ਤਜਰਬੇ
“Codex ਨੇ ਹਰ ਪੁਰਾਣੇ getUserById( ) ਨੂੰ ਸਾਡੇ ਨਵੇਂ service pattern ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਅਤੇ PR ਖੋਲ੍ਹ ਦਿੱਤਾ. ਇਸਨੇ ਮਿੰਟਾਂ ਵਿੱਚ ਉਹ ਕਰ ਦਿੱਤਾ ਜਿਸ ਵਿੱਚ ਘੰਟੇ ਲੱਗ ਜਾਣੇ ਸਨ.”
ਇਸ ਫ਼ਾਈਲ ਨੂੰ ਵਿਸ਼ੇ ਅਨੁਸਾਰ ਵੱਖਰੇ ਮੋਡੀਊਲਾਂ ਵਿੱਚ ਵੰਡੋ ਅਤੇ ਹਰ ਇੱਕ ਲਈ tests ਬਣਾਓ.
ਸਾਰੇ callback-based database access ਨੂੰ async/await ਵਿੱਚ ਬਦਲੋ.
Codex ਨੂੰ performance bottlenecks ਪਛਾਣਣ ਅਤੇ ਹੱਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ.
Tuning ਜਾਂ reliability ਯਤਨਾਂ ਦੌਰਾਨ, ਇੰਜੀਨੀਅਰ Codex ਨੂੰ ਹੌਲੀਆਂ ਜਾਂ memory-intensive code paths ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਪ੍ਰੌੰਪਟ ਕਰਦੇ ਹਨ, ਜਿਵੇਂ ਅਕੁਸ਼ਲ loops, ਫ਼ਜ਼ੂਲ operations, ਜਾਂ ਮਹਿੰਗੀਆਂ queries, ਅਤੇ optimized ਵਿਕਲਪ ਸੁਝਾਉਣ ਲਈ, ਜਿਸ ਨਾਲ ਅਕਸਰ efficiency ਅਤੇ reliability ਵਿੱਚ ਅਹਿਮ ਸੁਧਾਰ ਮਿਲਦੇ ਹਨ.
Codex code health ਨੂੰ ਸਮਰਥਨ ਦੇਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਉਹ risky ਜਾਂ deprecated patterns ਪਛਾਣਦਾ ਹੈ ਜੋ ਹਾਲੇ ਵੀ ਸਰਗਰਮ ਵਰਤੋਂ ਵਿੱਚ ਹਨ. ਸਾਡੀਆਂ ਟੀਮਾਂ ਲੰਬੇ ਸਮੇਂ ਦਾ tech debt ਘਟਾਉਣ ਅਤੇ proactively regressions ਰੋਕਣ ਲਈ ਇਸ 'ਤੇ ਭਰੋਸਾ ਕਰਦੀਆਂ ਹਨ.
ਸਾਡੀਆਂ ਟੀਮਾਂ ਦੇ ਤਜਰਬੇ
“ਮੈਂ Codex ਦੀ ਵਰਤੋਂ ਦੁਹਰਾਈਆਂ ਜਾਣ ਵਾਲੀਆਂ ਮਹਿੰਗੀਆਂ DB calls ਲੱਭਣ ਲਈ ਕਰਦਾ ਹਾਂ. ਇਹ hot paths ਨੂੰ ਫਲੈਗ ਕਰਨ ਅਤੇ batched queries ਦਾ draft ਬਣਾਉਣ ਵਿੱਚ ਬਹੁਤ ਵਧੀਆ ਹੈ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਮੈਂ ਬਾਅਦ ਵਿੱਚ tune ਕਰ ਸਕਦਾ ਹਾਂ.”
ਇਸ loop ਨੂੰ memory efficiency ਲਈ optimize ਕਰੋ ਅਤੇ ਸਮਝਾਓ ਕਿ ਤੁਹਾਡਾ version ਤੇਜ਼ ਕਿਉਂ ਹੈ.
ਇਸ request handler ਵਿੱਚ ਦੁਹਰਾਈਆਂ ਜਾਣ ਵਾਲੀਆਂ ਮਹਿੰਗੀਆਂ operations ਲੱਭੋ ਅਤੇ caching ਦੇ ਮੌਕੇ ਸੁਝਾਓ.
ਇਸ function ਵਿੱਚ DB queries ਨੂੰ batch ਕਰਨ ਦਾ ਹੋਰ ਤੇਜ਼ ਤਰੀਕਾ ਸੁਝਾਓ.
Codex ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ tests ਹੋਰ ਤੇਜ਼ੀ ਨਾਲ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ — ਖ਼ਾਸ ਕਰਕੇ ਉੱਥੇ ਜਿੱਥੇ coverage ਘੱਟ ਹੈ ਜਾਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਗੈਰਹਾਜ਼ਰ ਹੈ.
ਜਦੋਂ bug fix ਜਾਂ refactor 'ਤੇ ਕੰਮ ਹੋ ਰਿਹਾ ਹੋਵੇ, ਇੰਜੀਨੀਅਰ ਅਕਸਰ Codex ਨੂੰ ਅਜਿਹੇ tests ਸੁਝਾਉਣ ਲਈ ਕਹਿੰਦੇ ਹਨ ਜੋ edge cases ਜਾਂ ਸੰਭਾਵਿਤ failure paths ਕਵਰ ਕਰਨ. ਨਵੇਂ code ਲਈ, ਇਹ function signature ਅਤੇ ਆਸ-ਪਾਸ ਦੀ logic ਦੇ ਆਧਾਰ 'ਤੇ unit ਜਾਂ integration tests ਬਣਾਉਣ ਸਕਦਾ ਹੈ.
Codex ਖ਼ਾਸ ਤੌਰ 'ਤੇ boundary conditions ਪਛਾਣਣ ਲਈ ਮਦਦਗਾਰ ਹੈ, ਜਿਵੇਂ ਖਾਲੀ inputs, max length, ਜਾਂ ਅਜਿਹੀਆਂ ਅਣਆਮ ਪਰ ਵੈਧ states, ਜੋ ਅਕਸਰ ਸ਼ੁਰੂਆਤੀ tests ਵਿੱਚ ਰਹਿ ਜਾਂਦੀਆਂ ਹਨ.
ਸਾਡੀਆਂ ਟੀਮਾਂ ਦੇ ਤਜਰਬੇ
“ਮੈਂ Codex ਨੂੰ ਰਾਤੋਂ-ਰਾਤ ਘੱਟ-ਕਵਰੇਜ ਵਾਲੇ modules ਵੱਲ ਦਿਖਾ ਦਿੰਦਾ ਹਾਂ ਅਤੇ ਸਵੇਰੇ ਚਲਣਯੋਗ unit-test PRs ਨਾਲ ਜਾਗਦਾ ਹਾਂ.”
ਇਸ function ਲਈ unit tests ਲਿਖੋ, edge cases ਅਤੇ failure paths ਸਮੇਤ.
ਇਸ sorting utility ਲਈ ਇੱਕ property-based test ਬਣਾਓ.
null inputs ਅਤੇ invalid states ਨਾਲ ਜੁੜੇ missing scenarios ਕਵਰ ਕਰਨ ਲਈ ਇਸ test file ਨੂੰ ਵਧਾਓ.
Codex development cycle ਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਅੰਤ ਦੋਵੇਂ ਨੂੰ ਤੇਜ਼ ਕਰਕੇ ਟੀਮਾਂ ਨੂੰ ਹੋਰ ਚੁਸਤ ਬਣਾਉਂਦਾ ਹੈ.
ਨਵੀਂ feature ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਦੇ ਸਮੇਂ, ਇੰਜੀਨੀਅਰ ਇਸਦੀ ਵਰਤੋਂ boilerplate scaffold ਕਰਨ ਲਈ ਕਰਦੇ ਹਨ — folders, modules ਅਤੇ API stubs ਤਿਆਰ ਕਰਕੇ ਉਹ runnable code ਜਲਦੀ ਖੜ੍ਹਾ ਕਰ ਲੈਂਦੇ ਹਨ ਬਿਨਾਂ ਹਰ ਹਿੱਸੇ ਨੂੰ ਹੱਥੋਂ ਜੋੜੇ.
ਜਿਵੇਂ ਪ੍ਰੋਜੈਕਟ release ਦੇ ਨੇੜੇ ਪਹੁੰਚਦੇ ਹਨ, Codex ਛੋਟੇ ਪਰ ਜ਼ਰੂਰੀ ਕੰਮ ਸੰਭਾਲ ਕੇ ਤੰਗ deadlines ਪੂਰੀਆਂ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ bugs triage ਕਰਨਾ, last-mile implementation gaps ਭਰਨਾ, ਅਤੇ rollout scripts, telemetry hooks ਜਾਂ config files ਬਣਾਉਣਾ.
ਇਹ product feedback ਨੂੰ starter code ਵਿੱਚ ਬਦਲਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ. ਇੰਜੀਨੀਅਰ ਅਕਸਰ user request ਜਾਂ spec ਪੇਸਟ ਕਰਦੇ ਹਨ ਅਤੇ Codex ਤੋਂ ਇੱਕ rough draft ਬਣਵਾਉਂਦੇ ਹਨ ਜਿਸ ਵੱਲ ਉਹ ਬਾਅਦ ਵਿੱਚ ਵਾਪਸ ਆ ਕੇ ਸੁਧਾਰ ਕਰ ਸਕਣ.
“ਮੈਂ ਸਾਰਾ ਦਿਨ ਮੀਟਿੰਗਾਂ ਵਿੱਚ ਸੀ ਅਤੇ ਫਿਰ ਵੀ 4 PRs ਮਰਜ ਕਰ ਦਿੱਤੀਆਂ ਕਿਉਂਕਿ Codex ਬੈਕਗ੍ਰਾਊਂਡ ਵਿੱਚ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ.”
POST /events ਲਈ basic validation ਅਤੇ logging ਨਾਲ ਇੱਕ ਨਵਾਂ API route scaffold ਕਰੋ.
ਨਵੇਂ onboarding flow ਦੀ success/failure ਟ੍ਰੈਕ ਕਰਨ ਲਈ, ਇਸ template ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ telemetry hook ਬਣਾਓ [insert example of your telemetry code].
ਇਸ spec ਦੇ ਆਧਾਰ 'ਤੇ ਇੱਕ stub implementation ਬਣਾਓ: [insert spec or product feedback].
Codex ਸਾਡੇ ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ ਤਦੋਂ ਉਤਪਾਦਕ ਰਹਿਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਜਦੋਂ ਉਨ੍ਹਾਂ ਦੇ ਸਮਾਂ-ਸਾਰਣੀਆਂ ਖੰਡਿਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਰੁਕਾਵਟਾਂ ਨਾਲ ਭਰੀਆਂ ਹੁੰਦੀਆਂ ਹਨ.
ਇਸਦਾ ਇਸਤੇਮਾਲ ਅਧੂਰਾ ਕੰਮ ਕੈਪਚਰ ਕਰਨ, notes ਨੂੰ ਕੰਮ ਕਰਦੇ prototypes ਵਿੱਚ ਬਦਲਣ, ਜਾਂ exploratory tasks ਵੱਖ ਚਲਾਉਣ ਲਈ ਹੁੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਦੁਬਾਰਾ ਦੇਖਿਆ ਜਾ ਸਕੇ. ਇਸ ਨਾਲ ਕੰਮ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ ਬਿਨਾਂ ਸੰਦਰਭ ਗੁਆਏ, ਖ਼ਾਸ ਕਰਕੇ ਜਦੋਂ ਉਹ on call ਹੁੰਦੇ ਹਨ ਜਾਂ ਬਹੁਤ ਮੀਟਿੰਗਾਂ ਹੁੰਦੀਆਂ ਹਨ.
“ਜੇ ਮੈਨੂੰ ਕੋਈ drive-by fix ਦਿੱਸ ਜਾਵੇ, ਤਾਂ ਮੈਂ branches ਬਦਲਣ ਦੀ ਬਜਾਏ Codex task ਚਲਾ ਦਿੰਦਾ ਹਾਂ ਅਤੇ ਫ਼ੁਰਸਤ ਮਿਲਣ 'ਤੇ ਉਸਦੀ PR ਵੇਖਦਾ ਹਾਂ.”
Codex ਖੁੱਲ੍ਹੇ-ended ਕੰਮਾਂ ਲਈ ਵੀ ਲਾਭਕਾਰੀ ਹੈ, ਜਿਵੇਂ ਵਿਕਲਪੀ ਹੱਲ ਲੱਭਣਾ ਜਾਂ design decisions ਦੀ ਪੁਸ਼ਟੀ ਕਰਨਾ. ਤੁਸੀਂ ਕਿਸੇ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਲਈ ਪ੍ਰੌੰਪਟ ਕਰ ਸਕਦੇ ਹੋ, ਅਣਜਾਣ patterns ਖੋਜ ਸਕਦੇ ਹੋ, ਜਾਂ assumptions ਨੂੰ pressure-test ਕਰ ਸਕਦੇ ਹੋ. ਇਸ ਨਾਲ tradeoffs ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ, design ਵਿਕਲਪ ਵਧਦੇ ਹਨ, ਅਤੇ implementation choices ਹੋਰ ਤਿੱਖੀਆਂ ਹੁੰਦੀਆਂ ਹਨ.
ਇਹ ਸੰਬੰਧਿਤ bugs ਪਛਾਣਣ ਲਈ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ. ਕਿਸੇ ਜਾਣੇ-ਪਛਾਣੇ issue ਜਾਂ deprecated method ਦੇ ਆਧਾਰ 'ਤੇ, Codex code ਵਿੱਚ ਹੋਰ ਜਗ੍ਹਾ ਸਮਾਨ patterns ਪਛਾਣ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ regressions ਫੜਣਾ ਜਾਂ cleanup ਕੰਮ ਪੂਰਾ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ.
“Codex ਮੈਨੂੰ cold-start ਸਮੱਸਿਆ ਹੱਲ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ — ਮੈਂ ਇੱਕ spec ਅਤੇ docs ਪੇਸਟ ਕਰਦਾ ਹਾਂ ਅਤੇ ਇਹ code scaffold ਕਰ ਦਿੰਦਾ ਹੈ ਜਾਂ ਦਿਖਾਂਦਾ ਹੈ ਕਿ ਮੈਂ ਕੀ ਭੁੱਲ ਗਿਆ.”
ਜੇ ਸਿਸਟਮ request/response ਦੀ ਥਾਂ event-driven ਹੁੰਦਾ ਤਾਂ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ?
ਉਹ ਸਾਰੇ modules ਲੱਭੋ ਜੋ ਸਾਡੇ query builder ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਬਜਾਏ ਹੱਥੋਂ SQL strings ਬਣਾਉਂਦੇ ਹਨ.
ਇਸਨੂੰ ਹੋਰ functional style ਵਿੱਚ ਦੁਬਾਰਾ ਲਿਖੋ, mutation ਅਤੇ side effects ਤੋਂ ਬਚੋ.
Codex ਸਭ ਤੋਂ ਵਧੀਆ ਤਦੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਇਸਨੂੰ ਬਣਤਰ, ਸੰਦਰਭ ਅਤੇ iterate ਕਰਨ ਲਈ ਥਾਂ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ. ਇੱਥੇ ਕੁਝ ਅਜਿਹੀਆਂ ਆਦਤਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ OpenAI ਦੀਆਂ ਟੀਮਾਂ ਰੋਜ਼ਾਨਾ ਕੰਮ ਵਿੱਚ ਇਸ ਤੋਂ ਲਗਾਤਾਰ ਮੁੱਲ ਲੈਣ ਲਈ ਵਿਕਸਿਤ ਕਰ ਰਹੀਆਂ ਹਨ.
ਵੱਡੇ ਬਦਲਾਅ ਲਈ, Ask mode ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Codex ਤੋਂ implementation plan ਮੰਗ ਕੇ ਸ਼ੁਰੂ ਕਰੋ, ਜੋ ਫਿਰ Code Mode 'ਤੇ ਜਾਣ ਵੇਲੇ follow-up prompts ਲਈ input ਬਣ ਜਾਂਦਾ ਹੈ. ਇਹ ਦੋ-ਕਦਮੀ flow Codex ਨੂੰ grounded ਰੱਖਦਾ ਹੈ ਅਤੇ ਇਸਦੇ output ਵਿੱਚ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ. Codex ਉਹਨਾਂ well-scoped tasks ਨਾਲ ਸਭ ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਹਾਨੂੰ ਜਾਂ ਕਿਸੇ teammate ਨੂੰ ਪੂਰਾ ਕਰਨ ਵਿੱਚ ਲਗਭਗ ਇੱਕ ਘੰਟਾ ਲੱਗੇ, ਜਾਂ ਜਿਨ੍ਹਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੁਝ ਸੌ ਲਾਈਨਾਂ ਦਾ code ਚਾਹੀਦਾ ਹੋਵੇ. ਜਿਵੇਂ ਮਾਡਲ ਸੁਧਰਦੇ ਜਾਣਗੇ, ਉਮੀਦ ਕਰੋ ਕਿ ਇਹ ਜਿਹੜੇ tasks ਸੰਭਾਲ ਸਕਦਾ ਹੈ ਉਹਨਾਂ ਦਾ ਆਕਾਰ ਵੀ ਵਧੇਗਾ.
Startup script, environment variables, ਅਤੇ internet access ਸੈੱਟ ਕਰਨ ਨਾਲ Codex ਦੀ error rate ਮਹੱਤਵਪੂਰਣ ਢੰਗ ਨਾਲ ਘਟਦੀ ਹੈ. ਜਦੋਂ ਤੁਸੀਂ tasks ਚਲਾਉਂਦੇ ਹੋ, build errors ਵੇਖੋ ਜਿਨ੍ਹਾਂ ਨੂੰ Codex ਦੇ environment configuration ਵਿੱਚ ਠੀਕ ਕੀਤਾ ਜਾ ਸਕੇ. ਇਸ ਲਈ ਕੁਝ iterations ਲੱਗ ਸਕਦੀਆਂ ਹਨ, ਪਰ ਲੰਬੇ ਸਮੇਂ ਵਿੱਚ ਇਹ ਮਹੱਤਵਪੂਰਣ efficiency gains ਦਿੰਦਾ ਹੈ.
ਜਦੋਂ prompts ਇਸ ਗੱਲ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਤੁਸੀਂ PR ਜਾਂ issue ਵਿੱਚ ਬਦਲਾਅ ਕਿਵੇਂ ਵਰਣਨ ਕਰਦੇ ਹੋ, Codex ਹੋਰ ਵਧੀਆ ਜਵਾਬ ਦਿੰਦਾ ਹੈ. ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਲੋੜ ਪੈਣ 'ਤੇ file paths, component names, diffs, ਅਤੇ doc snippets ਸ਼ਾਮਲ ਕਰਨੇ. “ਇਸਨੂੰ ਉਹੀ ਤਰੀਕੇ ਨਾਲ implement ਕਰੋ ਜਿਵੇਂ [module X] ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ” ਵਰਗੇ patterns ਨਾਲ ਪ੍ਰੌੰਪਟ ਕਰਨ ਨਾਲ ਨਤੀਜੇ ਸੁਧਰਦੇ ਹਨ.
ਸਾਈਡ ਵਾਲੇ ਵਿਚਾਰਾਂ, ਅਧੂਰੇ ਕੰਮ ਜਾਂ ਛੋਟੇ-ਮੋਟੇ fixes ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਲਈ tasks ਚਲਾ ਦਿਓ. ਇੱਕੋ ਵਾਰ ਵਿੱਚ ਪੂਰੀ PR ਬਣਾਉਣ ਦਾ ਕੋਈ ਦਬਾਅ ਨਹੀਂ. Codex ਇੱਕ staging area ਵਜੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਸ ਵੱਲ ਤੁਸੀਂ ਦੁਬਾਰਾ ਵਾਪਸ ਆ ਸਕਦੇ ਹੋ ਜਦੋਂ ਤੁਹਾਡਾ ਧਿਆਨ ਮੁੜ ਕੇਂਦਰਿਤ ਹੋਵੇ.
Prompts ਵਿੱਚ ਤੁਹਾਡੇ repo ਵਿੱਚ Codex ਨੂੰ ਹੋਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਵਿੱਚ ਮਦਦ ਦੇਣ ਲਈ ਇੱਕ AGENTS.md ਫ਼ਾਈਲ ਬਣਾਈ ਰੱਖੋ. ਇਹ ਫ਼ਾਈਲਾਂ ਆਮ ਤੌਰ 'ਤੇ naming conventions, business logic, ਜਾਣੀਆਂ quirks, ਜਾਂ dependencies ਸ਼ਾਮਲ ਕਰਦੀਆਂ ਹਨ ਜੋ Codex ਸਿਰਫ਼ code ਤੋਂ ਨਹੀਂ ਸਮਝ ਸਕਦਾ. Docs ਵਿੱਚ ਆਪਣੀ AGENTS.md ਫ਼ਾਈਲ ਨੂੰ ਬਣਤਰ ਦੇਣ ਬਾਰੇ ਹੋਰ ਜਾਣੋ.
Best-of-N ਵਿਸ਼ੇਸ਼ਤਾ ਤੁਹਾਨੂੰ ਇੱਕੋ task ਲਈ ਇਕੱਠੇ ਕਈ responses ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਜਲਦੀ ਨਾਲ ਕਈ ਹੱਲ ਖੋਜ ਸਕੋ ਅਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਚੁਣ ਸਕੋ. ਹੋਰ ਜਟਿਲ tasks ਲਈ, ਤੁਸੀਂ ਕਈ iterations ਵੇਖ ਸਕਦੇ ਹੋ ਅਤੇ ਵੱਖ-ਵੱਖ responses ਦੇ ਹਿੱਸੇ ਜੋੜ ਕੇ ਹੋਰ ਮਜ਼ਬੂਤ ਨਤੀਜਾ ਲੈ ਸਕਦੇ ਹੋ.
Codex ਹਾਲੇ ਵੀ research preview ਵਿੱਚ ਹੈ, ਪਰ ਇਹ ਪਹਿਲਾਂ ਹੀ ਇਸ ਗੱਲ 'ਤੇ ਅਸਲ ਪ੍ਰਭਾਵ ਪਾ ਰਿਹਾ ਹੈ ਕਿ ਅਸੀਂ ਕਿਵੇਂ ਬਣਾਉਂਦੇ ਹਾਂ, ਸਾਨੂੰ ਹੋਰ ਤੇਜ਼ੀ ਨਾਲ ਅੱਗੇ ਵਧਣ, ਹੋਰ ਵਧੀਆ code ਲਿਖਣ, ਅਤੇ ਉਹ ਕੰਮ ਹੱਥ ਵਿੱਚ ਲੈਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਨਹੀਂ ਤਾਂ ਸ਼ਾਇਦ ਕਦੇ ਤਰਜੀਹ ਨਾ ਮਿਲਦੀ.
ਅਸੀਂ ਅੱਗੇ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਲੈ ਕੇ ਉਤਸ਼ਾਹਿਤ ਹਾਂ — ਜਿਵੇਂ ਸਾਡੇ ਮਾਡਲ ਹੋਰ ਵਧੀਆ ਹੁੰਦੇ ਜਾਣਗੇ ਅਤੇ Codex ਸਾਡੇ workflows ਵਿੱਚ ਹੋਰ ਡੂੰਘਾਈ ਨਾਲ ਇਕਰੂਪ ਹੋਵੇਗਾ, ਅਸੀਂ ਇਸ ਨਾਲ software develop ਕਰਨ ਦੇ ਹੋਰ ਵੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਰੀਕੇ ਖੋਲ੍ਹਣ ਦੀ ਉਡੀਕ ਕਰ ਰਹੇ ਹਾਂ. ਅਸੀਂ ਰਸਤੇ ਵਿੱਚ ਜੋ ਸਿੱਖਾਂਗੇ, ਉਹ ਸਾਂਝਾ ਕਰਦੇ ਰਹਾਂਗੇ.
