హార్నెస్ ఇంజినీరింగ్: ఏజెంట్-ఫస్ట్ ప్రపంచంలో Codexను వినియోగించడం
ర్యాన్ లోపోపోలో, టెక్నికల్ స్టాఫ్ సభ్యుడి ద్వారా
గత ఐదు నెలలుగా, మా బృందం ఒక ప్రయోగాన్ని నిర్వహిస్తోంది: 0 లైన్ల మాన్యువల్గా వ్రాసిన కోడ్తో సాఫ్ట్వేర్ ఉత్పత్తి అంతర్గత బీటాను నిర్మించడం మరియు షిప్పింగ్ చేయడం
ఈ ఉత్పత్తికి అంతర్గత రోజువారీ యూజర్లు మరియు బాహ్య ఆల్ఫా టెస్టర్లు ఉన్నారు. ఇది షిప్ అవుతుంది, డిప్లాయ్ అవుతుంది, విఫలమవుతుంది మరియు తిరిగి సరిదిద్దబడుతుంది. దీనిలో భిన్నమైన విషయం ఏమిటంటే, కోడ్ ప్రతి పంక్తి—అప్లికేషన్ లాజిక్, పరీక్షలు, CI కాన్ఫిగరేషన్, డాక్యుమెంటేషన్, ఆబ్జర్వబిలిటీ, మరియు అంతర్గత టూలింగ్—ఇలా ప్రతి లైన్ కూడా Codex ద్వారా రాయబడింది. మేం అంచనా వేసిన దానిని బట్టి, చేతితో కోడ్ రాయడానికి పట్టే సమయంతో పోలిస్తే, దీన్ని మేం సుమారు పదవంతు సమయంతో నిర్మించాం.
మనుషులు దిశానిర్దేశం చేస్తారు. ఏజెంట్లు అమలు చేస్తాయి.
మేం ఇంజనీరింగ్ వేగాన్ని అనేక రెట్లు పెంచడానికి అవసరమైనదాన్ని నిర్మించేందుకు ఉద్దేశపూర్వకంగా ఈ పరిమితిని ఎంచుకున్నాం. మేం చివరికి మిలియన్ లైన్ల కోడ్గా మారిన దానిని షిప్ చేయడానికి మాకు కొన్ని వారాల సమయం మాత్రమే ఉంది. అలా చేయడానికి, ఒక సాఫ్ట్వేర్ ఇంజినీరింగ్ బృందం ప్రధాన పని ఇకపై కోడ్ రాయడం కాకుండా, వాతావరణాలను రూపకల్పన చేయడం, ఉద్దేశాన్ని నిర్దేశించడం, మరియు Codex ఏజెంట్లు విశ్వసనీయంగా పని చేయడానికి అనుమతించే ఫీడ్బ్యాక్ లూప్లను నిర్మించడం వంటి మార్పులను మనం అర్థం చేసుకోవాలి.
ఈ పోస్ట్ ఏజెంట్ల బృందంతో కలిసి పూర్తిగా కొత్త ఉత్పత్తిని నిర్మించడం ద్వారా మేం ఏమి నేర్చుకున్నాం—ఏవి విఫలమయ్యాయి, ఏవి మెరుగుపడ్డాయి, మరియు మానవ సమయం మరియు దృష్టి అనే మా ఒకే కొరతగల వనరును ఎలా గరిష్టంగా ఉపయోగించుకోవాలనే అంశాల గురించి ఈ పోస్ట్ వివరిస్తుంది.
ఖాళీ రిపోజిటరీకి మొదటి కమిట్ 2025 ఆగస్టు చివరిలో జరిగింది.
ప్రారంభ స్కాఫోల్డ్—రిపోజిటరీ నిర్మాణం, CI కాన్ఫిగరేషన్, ఫార్మెటిం్ నియమాలు, ప్యాకేజ్ మేనేజర్ సెటప్, అప్లికేషన్ ఫ్రేమ్వర్క్—GPT‑5ని ఉపయోగించి Codex CLI ద్వారా, కొన్ని ప్రస్తుత టెంప్లెట్ల మార్గదర్శకత్వంలో రూపొందించబడింది. ఏజెంట్లు రిపోజిటరీలో ఎలా పని చేయాలని సూచించే ప్రారంభ AGENTS.md ఫైల్ కూడా Codex ద్వారానే రాయబడింది.
సిస్టమ్ను స్థిరంగా ఉంచడానికి ముందుగా మనుషులు రాసిన కోడ్ ఏదీ లేదు. ఆరంభం నుంచే, రిపోజిటరీని ఏజెంట్ ఆకృతీకరించింది.
ఐదు నెలల తర్వాత, రిపోజిటరీలో అప్లికేషన్ లాజిక్, మౌలిక సదుపాయాలు, సాధనాలు, డాక్యుమెంటేషన్, మరియు అంతర్గత డెవలపర్ ఉపకరణాల అంతటా సుమారు ఒక మిలియన్ లైన్ల కోడ్ ఉంటుంది. ఆ కాలంలో, కేవలం ముగ్గురు ఇంజనీర్లు Codexను నడిపిస్తూ, సుమారు 1,500 pull requests ఓపెన్ చేసి మెర్జ్ చేశారు. ఇది ప్రతి ఇంజినీర్కు రోజుకు సగటున 3.5 PRs థ్రూపుట్గా అనువదించబడుతుంది, ఆశ్చర్యకరంగా టీమ్ ఇప్పుడు ఏడు ఇంజినీర్లకు పెరిగినప్పటికీ థ్రూపుట్ పెరిగింది. మరిముఖ్యంగా, ఇది కేవలం అవుట్పుట్ కోసం అవుట్పుట్ కాదు: ఈ ఉత్పత్తిని వందలాది అంతర్గత యూజర్లు ఉపయోగించారు, రోజువారీ అంతర్గత శక్తివంతమైన యూజర్లు కూడా దీనిలో ఉన్నారు.
అభివృద్ధి ప్రక్రియ అంతటా, మానవులు ఎప్పుడూ నేరుగా ఏ కోడ్కు సహకరించలేదు. ఇది టీమ్ కోసం ఒక ప్రధాన ఫిలాసఫీగా మారింది: మాన్యువల్గా రాసిన కోడ్ లేదు.
హ్యాండ్స్-ఆన్ మానవ కోడింగ్ లేకపోవడం సిస్టమ్లు, స్కాఫోల్డింగ్, మరియు లీవరేజ్పై దృష్టి సారించిన భిన్నమైన ఇంజనీరింగ్ పని విధానాన్ని పరిచయం చేసింది.
ముందస్తు పురోగతి మేం ఊహించిన దానికంటే నెమ్మదిగా సాగింది, Codex సామర్థ్యం లేనందున కాదు, కానీ పర్యావరణం సరిగ్గా నిర్దేశించబడకపోవడం వల్ల మాత్రమే. ఏజెంట్కు సాధనాలు, అబ్స్ట్రాక్షన్స్, ఉన్నత స్థాయి లక్ష్యాల వైపు పురోగతి సాధించడానికి అవసరమైన అంతర్గత నిర్మాణం లేవు. మా ఇంజనీరింగ్ బృందం ప్రధాన పని ఏజెంట్లకు ఉపయోగకరమైన పనులు చేసేలా మార్చడమే అయింది.
ప్రయోగంలో, దీని అర్థం డెప్త్-ఫస్ట్గా పని చేయడం: పెద్ద లక్ష్యాలను చిన్న నిర్మాణ బ్లాక్లుగా (డిజైన్, కోడ్, సమీక్ష, పరీక్ష, మొదలైనవి) విభజించడం, ఆ బ్లాక్లను నిర్మించేందుకు ఏజెంట్ను ప్రాంప్ట్ చేయడం, మరింత క్లిష్టమైన పనులను అన్లాక్ చేయడానికి వాటిని ఉపయోగించడం. ఏదైనా విఫలమైనప్పుడు, పరిష్కారం దాదాపు ఎప్పుడూ “ఇంకా కష్టపడండి” అనేది కాదు. Codex చేత పని చేయించడమే పురోగతి సాధించే ఏకైక మార్గం కావడంతో, మానవ ఇంజినీర్లు ఎల్లప్పుడూ ఆ పనిలోకి ప్రవేశించి ఇలా ప్రశ్నించుకునేవారు: “ఏ సామర్థ్యం లోపిస్తోంది, మరియు దాన్ని ఏజెంట్కు అర్థమయ్యేలా, అమలు చేయదగినదిగా ఎలా మార్చాలి?”
మనుషులు సిస్టమ్తో దాదాపు పూర్తిగా ప్రాంప్ట్ల ద్వారా ఇంటరాక్ట్ అవుతారు: ఒక ఇంజనీర్ ఒక పనిని వివరిస్తాడు, ఏజెంట్ను రన్ చేస్తాడు, అది పుల్ రిక్వెస్ట్ తెరవడానికి అనుమతిస్తుంది. ఒక PR ను పూర్తిచేయడానికి, మేం Codex ను తన స్వంత మార్పులను లోకల్గా సమీక్షించమని, లోకల్ మరియు క్లౌడ్లో అదనపు నిర్దిష్ట ఏజెంట్ సమీక్షలను అభ్యర్థించమని, ఏదైనా మనిషి లేదా ఏజెంట్ ఇచ్చిన ఫీడ్బ్యాక్కు స్పందించమని, మరియు అన్ని ఏజెంట్ సమీక్షకులు సంతృప్తి చెందే వరకు లూప్లో పునరావృతం చేయమని సూచిస్తాము (ఇది రాల్ఫ్ విగ్గమ్ లూప్(కొత్త విండోలో తెరుచుకుంటుంది) గా పిలవబడుతుంది). Codex మన ప్రామాణిక డెవలప్మెంట్ టూల్స్ (gh, లోకల్ స్క్రిప్ట్స్, మరియు రిపోజిటరీ-ఎంబెడెడ్ స్కిల్స్) ను నేరుగా ఉపయోగించి, CLIలోకి మనుషులు కాపీ చేసి పేస్ట్ చేయకుండా కాంటెక్ట్స్ను సేకరిస్తుంది.
మానవులు pull requestలను సమీక్షించవచ్చు, అయితే అది తప్పనిసరి కాదు. కాలక్రమేణా, మేం దాదాపు అన్ని సమీక్షా ప్రయత్నాలను ఏజెంట్-టు-ఏజెంట్గా నిర్వహించబడేలా మళ్లించాం.
కోడ్ థ్రూపుట్ పెరిగినప్పుడు, మాకు ఎదురైన సమస్య మానవ QA సామర్థ్యంగా మారింది. మానవ సమయం మరియు దృష్టి స్థిరమైన పరిమితిగా ఉండటం, మేం Codexకు అప్లికేషన్ UI, లాగ్లు, మరియు యాప్ మెట్రిక్స్ వంటి వాటిని నేరుగా చదవగలిగేలా చేయడం ద్వారా ఏజెంట్కు మరిన్ని సామర్థ్యాలను జోడించడానికి మేం పనిచేశాం.
ఉదాహరణకు, మేం git వర్క్ట్రీ ప్రకారం యాప్ను బూటబుల్గా చేశాం, తద్వారా Codex ప్రతి మార్పుకు ఒక ఇన్స్టాన్స్ను ప్రారంభించి డ్రైవ్ చేయగలదు. మేం Chrome డెవ్ టూల్స్ ప్రోటోకాల్ను ఏజెంట్ రన్టైమ్లో కూడా అనుసంధానించి, DOM స్నాప్షాట్లు, స్క్రీన్షాట్లు, నావిగేషన్తో పని చేయడానికి నైపుణ్యాలను సృష్టించాం. ఇది Codex కు బగ్లను పునరుత్పత్తి చేయడం, ఫిక్స్లను ధృవీకరించడం, UI ప్రవర్తన గురించి నేరుగా తర్కించడం సాధ్యమయ్యేలా చేసింది.
మేం పరిశీలన సాధనాల కోసం కూడా అదే చేశాం. లాగ్లు, మెట్రిక్స్, ట్రేస్లు ఏదైనా నిర్దిష్ట వర్క్ట్రీ కోసం తాత్కాలికంగా ఉండే లోకల్ ఆబ్జర్వబిలిటీ స్టాక్ ద్వారా Codexకు అందించబడతాయి. Codex ఆ యాప్ పూర్తిగా ఐసొలేటెడ్ వెర్షన్పై పనిచేస్తుంది—దాని లాగ్లు మరియు మెట్రిక్స్తో సహా, ఆ టాస్క్ పూర్తైన వెంటనే అవి తొలగించబడతాయి. ఏజెంట్లు LogQL తో లాగ్లను మరియు PromQL తో మెట్రిక్స్ను ప్రశ్నించవచ్చు. ఈ సందర్భం అందుబాటులో ఉండటంతో, “సర్వీస్ స్టార్టప్ 800ms లోపు పూర్తయ్యేలా చూసుకోండి” లేదా “ఈ నాలుగు కీలకమైన వినియోగదారు ప్రయాణాలలో ఏ వ్యవధి రెండు సెకన్లకు మించకూడదు” వంటి ప్రాంప్ట్లను ట్రాక్ చేయదగినవిగా మారుస్తాయి.
మేం తరచుగా ఒకే టాస్క్పై ఒకే Codex రన్లు ఆరు గంటలకు పైగా పనిచేయడాన్ని చూస్తుంటాం (తరచుగా మనుషులు నిద్రపోతున్నప్పుడు).
పెద్ద మరియు సంక్లిష్ట పనులను సమర్థవంతంగా చేయడంలో ఏజెంట్లకు కాంటెక్ట్స్ నిర్వహణ ఒక ప్రధాన సవాలు. మేము నేర్చుకున్న తొలి పాఠాలలో ఒకటి సరళమైనది: Codex కు 1,000 పేజీల సూచనల మాన్యువల్ కాకుండా మ్యాప్ ఇవ్వండి.
మేం “ఒక పెద్ద AGENTS.md(కొత్త విండోలో తెరుచుకుంటుంది)” ను ప్రయత్నించాం విధానం. ఇది ఊహించదగిన మార్గాల్లో విఫలమైంది:
- సందర్భం అరుదైన వనరు. ఒక భారీ సూచన ఫైల్ టాస్క్, కోడ్, మరియు సంబంధిత డాక్యుమెంట్లను నేర్పిస్తుంది—దాంతో ఏజెంట్ ముఖ్యమైన పరిమితులను కోల్పోతుంది లేదా తప్పు వాటి కోసం ఆప్టిమైజ్ చేయడం ప్రారంభిస్తుంది.
- అతి ఎక్కువ మార్గదర్శనం మార్గదర్శనం కాకుండా మారుతుంది. అన్నీ “ముఖ్యం” అనుకుంటే, ఏదీ ముఖ్యం కాదు. ఏజెంట్లు ఉద్దేశపూర్వకంగా నావిగేట్ చేయకుండా స్థానికంగా ప్యాటర్న్-మ్యాచింగ్ చేయడం పైనే ఆధారపడతాయి.
- ఇది వెంటనే కుళ్లిపోతుంది. ఒక మోనోలిథికల్ మాన్యువల్ పాత నియమాల సమాధిగా మారిపోతుంది. ఏజెంట్లు ఇంకా ఏది నిజమో చెప్పలేదు, మనుషులు దాన్ని నిర్వహించడం ఆపేస్తారు, మరియు ఆ ఫైల్ నిశ్శబ్దంగా ఆకర్షణీయమైన విఘాతంగా మారుతుంది.
- దాన్ని ధృవీకరించడం కష్టం. ఒకే బ్లాబ్ యాంత్రిక తనిఖీలకు (కవరేజ్, తాజాదనం, యాజమాన్యత, క్రాస్-లింక్స్కు) అనుకూలంగా ఉండదు, అందువల్ల డ్రిఫ్ట్ అనివార్యం.
కాబట్టి AGENTS.md ను ఎన్సైక్లోపీడియాగా కాకుండా, విషయ సూచికగా పరిగణిస్తాం.
రిపోజిటరీ నాలెడ్జ్ బేస్ ఒక నిర్మిత docs/ డైరెక్టరీలో ఉంటుంది, దాన్ని సిస్టమ్ ఆఫ్ రికార్డ్గా భావిస్తారు. ఒక చిన్న AGENTS.md (సుమారు 100 లైన్లు) సందర్భంలోకి ఇంజెక్ట్ చేయబడుతుంది మరియు ఇది ప్రధానంగా ఒక మ్యాప్లా పనిచేస్తూ, ఇతర చోట్ల ఉన్న లోతైన సమాచారానికి ఆధారాలను అందిస్తుంది.
డిజైన్ డాక్యుమెంటేషన్ జాబితా చేయబడింది మరియు సూచిక చేయబడింది, వీటిలో ధృవీకరణ స్థితి మరియు ఏజెంట్-ఫస్ట్ ఆపరేటింగ్ సూత్రాలను నిర్వచించే ప్రధాన నమ్మకాల సమితి ఉన్నాయి. ఆర్కిటెక్చర్ డాక్యుమెంటేషన్(కొత్త విండోలో తెరుచుకుంటుంది) డొమైన్లు మరియు ప్యాకేజ్ లేయరింగ్ ఎగువ స్థాయి మ్యాప్ను అందిస్తుంది. క్వాలిటీ డాక్యుమెంట్ ప్రతి ఉత్పత్తి డొమైన్ మరియు నిర్మాణాత్మక లేయర్ను గ్రేడ్ చేస్తుంది, కాలక్రమేణా లోపాలను గమనిస్తుంది.
ప్లాన్లను ఫస్ట్-క్లాస్ కళాఖండాలుగా పరిగణిస్తారు. చిన్న మార్పుల కోసం తాత్కాలిక తేలికపాటి ప్లాన్లను ఉపయోగిస్తారు, అయితే సంక్లిష్టమైన పని పురోగతి మరియు నిర్ణయ లాగ్లతో కూడిన ఎగ్జిక్యూషన్ ప్రణాళికల్లో(కొత్త విండోలో తెరుచుకుంటుంది) సంగ్రహించబడుతుంది, ఇవి రిపోజిటరీలో చెక్ చేయబడతాయి. యాక్టివ్ ప్లాన్లు, పూర్తయిన ప్లాన్లు, మరియు తెలిసిన సాంకేతిక లోపాలు అన్నీ వెర్షన్ చేయబడి ఒకేచోట ఉంచబడతాయి, తద్వారా ఏజెంట్లు బాహ్య సందర్భంపై ఆధారపడకుండా పనిచేయగలరు.
ఇది ప్రోగ్రెసివ్ డిస్క్లోజర్ను ప్రారంభిస్తుంది: ఏజెంట్లు చిన్న, స్థిరమైన ప్రవేశ బిందువుతో ప్రారంభించి, ముందుగానే ముంచెత్తడానికి బదులుగా, తరువాత ఎక్కడ చూడాలని నేర్పుతాయి.
మేం దీన్ని యాంత్రికంగా అమలు చేస్తున్నాం. ప్రత్యేకమైన లింటర్స్ మరియు CI జాబ్స్ నాలెడ్జ్ బేస్ అప్ టు డేట్, క్రాస్-లింక్ చేయబడిందో మరియు సరైన నిర్మాణంలో ఉందో లేదో ధృవీకరిస్తాయి. నిరంతరం పనిచేసే ఒక "డాక్-గార్డెనింగ్" ఏజెంట్, అసలైన కోడ్ ప్రవర్తనను ప్రతిబింబించని పాత లేదా నిరుపయోగమైన డాక్యుమెంటేషన్ను స్కాన్ చేస్తుంది, వాటిని సరిదిద్దడానికి pull requests ఓపెన్ చేస్తుంది.
కోడ్బేస్ అభివృద్ధి చెందుతున్న కొద్దీ, డిజైన్ నిర్ణయాల కోసం Codex ఫ్రేమ్వర్క్ కూడా అభివృద్ధి చెందాల్సి వచ్చింది.
రిపోజిటరీ పూర్తిగా ఏజెంట్-ద్వారా రూపొందించడం, ఇది మొదట Codex legibility కోసం ఆప్టిమైజ్ చేయబడింది. కొత్త ఇంజనీరింగ్ నియామకాల కోసం జట్లు తమ కోడ్ యొక్క నావిగేషన్ను మెరుగుపరచడం లక్ష్యంగా పెట్టుకున్నట్లుగానే, మా మానవ ఇంజనీర్ల లక్ష్యం ఏజెంట్ పూర్తి వ్యాపార డొమైన్ గురించి నేరుగా రిపోజిటరీ నుండే తర్కించుకునేలా చేయడం.
ఏజెంట్ దృష్టికోణం నుండి చూస్తే, అది రన్ అవుతున్నప్పుడు కాంటెక్ట్స్లో యాక్సెస్ చేయలేనిది ఏదైనా అసలు ఉండదు. Google Docs, చాట్ థ్రెడ్లు, లేదా వ్యక్తుల మనస్సుల్లో ఉన్న జ్ఞానం సిస్టమ్కు లభ్యం కాదు. రిపోజిటరీ-లోకల్, వెర్షన్ చేసిన ఆర్టిఫాక్ట్లు (ఉదా., కోడ్, మార్క్డౌన్, స్కీమాలు, ఎగ్జిక్యూటబుల్ ప్లాన్లు) మాత్రమే ఇది చూడగలదు.
కాలక్రమేణా రెపోలో మరింత ఎక్కువ సందర్భాన్ని చేర్చాల్సిన అవసరం ఉందని మేం తెలుసుకున్నాం. ఆ Slack చర్చ, అది టీమ్ను ఒక ఆర్కిటెక్చరల్ ప్యాటర్న్పై ఏకాభిప్రాయానికి తీసుకువచ్చిందా? ఏజెంట్కు అది కనుగొనలేనిదైతే, మూడు నెలల తర్వాత చేరే కొత్త ఉద్యోగికి అది తెలియని విధంగానే అది చదవలేనిదిగా ఉంటుంది.
Codex కు మరింత సందర్భం ఇవ్వడం అంటే, ఏజెంట్ దానిని తాత్కాలిక సూచనలతో ముంచెత్తకుండా, దానిపై తర్కించగలిగేలా సరైన సమాచారాన్ని నిర్వహించడం మరియు బహిర్గతం చేయడం. మీరు కొత్త టీమ్మేట్ను ఉత్పత్తి సూత్రాలు, ఇంజినీరింగ్ నిబంధనలు, మరియు టీమ్ కల్చర్ (ఎమోజీ ప్రాధాన్యతలు కూడా) గురించి పరిచయం చేసే విధంగానే, ఏజెంట్కు ఈ సమాచారాన్ని ఇవ్వడం మెరుగైన అనుసరణ అవుట్పుట్కు దారితీస్తుంది.
ఈ ఫ్రేమింగ్ అనేక పరస్పర విరుద్ధాలను స్పష్టం చేసింది. మేం రిపోలో పూర్తిగా అంతర్గతీకరించగలిగే మరియు దాని గురించి తార్కికంగా ఆలోచించగలిగే ఆధారాలు మరియు సారాంశాలకు ప్రాధాన్యత ఇచ్చాం. “బోరింగ్” గా తరచుగా వర్ణించే టెక్నాలజీలు, కంపోజబిలిటీ, API స్థిరత్వం, మరియు శిక్షణ సెట్లో ప్రాతినిధ్యం కారణంగా, ఏజెంట్లు మోడల్ చేయడానికి సులభంగా ఉంటాయి. కొన్ని సందర్భాల్లో, పబ్లిక్ లైబ్రరీల నుండి వచ్చే స్పష్టత లేని అప్స్ట్రీమ్ ప్రవర్తనను పరిష్కరించడానికి కంటే, ఏజెంట్తో ఫంక్షనాలిటీ కొన్ని ఉపసెట్లను మళ్లీ అమలు చేయించడం చౌకగా ఉండేది. ఉదాహరణకు, సాధారణ p-limit-శైలి ప్యాకేజీని లాగడానికి బదులుగా, మేము మా స్వంత మ్యాప్-విత్-కరెన్సీ హెల్పర్ను అమలు చేశాం: ఇది మా ఓపెన్ టెలిమెట్రీ ఇన్స్ట్రుమెంటేషన్తో పటిష్టంగా అనుసంధానించబడింది, 100% పరీక్ష కవరేజీ ఉంది, మా రన్టైమ్ ఆశించే విధంగానే ప్రవర్తిస్తుంది.
వ్యవస్థలోని ఎక్కువ భాగాలను ఏజెంట్ నేరుగా తనిఖీ చేసే, ధృవీకరించే మరియు సవరించే రూపంలోకి తీసుకురావడం వల్ల పని సామర్థ్యం పెరుగుతుంది—ఇది కేవలం Codex కోసం మాత్రమే కాకుండా, ఇతర ఏజెంట్ల కోసం కూడా (ఉదాహరణకు... Aardvark) కోడ్బేస్పై కూడా పని చేస్తున్నాయి.
డాక్యుమెంటేషన్ మాత్రమే పూర్తిగా ఏజెంట్-సృష్టించిన కోడ్బేస్ను పొందికగా ఉంచదు. మైక్రోమేనేజింగ్ అమలులను కాకుండా, మార్పులేని వాటిని అమలు చేయడం ద్వారా, మేం ఏజెంట్లను పునాదిని దెబ్బతీయకుండా వేగంగా రవాణా చేయడానికి అనుమతిస్తాం. ఉదాహరణకు, మేం Codexను సరిహద్దు వద్ద డేటా ఆకృతులను పార్స్ చేయమని(కొత్త విండోలో తెరుచుకుంటుంది) కోరుతున్నాం, కానీ అది ఎలా జరుగుతుందో మేం నిర్దిష్టంగా చెప్పము (మోడల్కు Zod నచ్చినట్లు కనిపిస్తోంది, అయితే మేం ఆ నిర్దిష్ట లైబ్రరీని పేర్కొనలేదు).
ఏజెంట్లు కఠినమైన పరిమితులు మరియు ముందుగా ఊహించగల నిర్మాణం(కొత్త విండోలో తెరుచుకుంటుంది) ఉన్న వాతావరణాల్లో అత్యంత ప్రభావవంతంగా ఉంటాయి, అందువల్ల మేం అప్లికేషన్ను కఠినమైన ఆర్కిటెక్చరల్ మోడల్ ఆధారంగా నిర్మించాం. ప్రతి వ్యాపార డొమైన్ను స్థిరమైన లేయర్ల సమూహంగా విభజిస్తారు, కఠినంగా ధ్రువీకరించిన ఆధారిత దిశలతో మరియు అనుమతించబడిన ఎడ్జ్ల పరిమిత సమూహంతో. ఈ పరిమితులను కస్టమ్ లింటర్లు (Codex-సృష్టించినవి, ఖచ్చితంగా!) మరియు నిర్మాణ పరీక్షల ద్వారా యాంత్రికంగా అమలు చేస్తారు.
క్రింద ఉన్న డయాగ్రామ్ ఈ నియమాన్ని చూపిస్తుంది: ప్రతి వ్యాపార డొమైన్లో (ఉదా. యాప్ సెట్టింగ్స్), కోడ్ ఒక స్థిరమైన లేయర్ల సమూహం ద్వారా మాత్రమే “ఫార్వర్డ్” గా ఆధారపడగలదు (టైప్స్ → కాన్ఫిగ్ → రిపో → సర్వీస్ → రన్టైమ్ → UI). క్రాస్-కట్టింగ్ అంశాలు (ఆత్, కనెక్టర్లు, టెలిమెట్రీ, ఫీచర్ ఫ్లాగ్స్) ఒకే స్పష్టమైన ఇంటర్ఫేస్ ద్వారా ప్రవేశిస్తాయి: ప్రొవైడర్లు. మరేదైనా అనుమతించదు మరియు యాంత్రికంగా అమలు చేయబడుతుంది.
ఇది మీరు సాధారణంగా వందలాది మంది ఇంజనీర్లు ఉన్న తర్వాత వాయిదా వేసే ఆర్కిటెక్చర్ రకం. కోడింగ్ ఏజెంట్లతో, ఇది ప్రారంభ దశలో అవసరం: పరిమితులు వేగాన్ని క్షీణత లేకుండా, ఆర్కిటెక్చరల్ డ్రిఫ్ట్ లేకుండా సాధించడానికి సహాయపడతాయి.
ఆచరణలో, మేం ఈ నియమాలను కస్టమ్ లింటర్లు మరియు నిర్మాణ పరీక్షలతో పాటు "రుచి మార్పులేని" చిన్న సెట్తో అమలు చేస్తాం. ఉదాహరణకు, మేం కస్టమ్ లింట్స్తో నిర్మిత లాగింగ్, స్కీమాలు మరియు రకాల కోసం నామకరణ నియమాలు, ఫైల్ పరిమాణ పరిమితులు, ప్లాట్ఫారం-నిర్దిష్ట విశ్వసనీయత అవసరాలను స్థిరంగా అమలు చేస్తాం. లింట్స్ అనేవి కస్టమ్గా ఉన్నందున, మేం ఏజెంట్ కాంటెక్స్ట్లో రీమిడియేషన్ సూచనలను చేర్చడానికి ఎరర్ సందేశాలను రాస్తాం.
హ్యూమన్-ఫస్ట్ వర్క్ఫ్లోలో, ఈ నియమాలు పాండిత్యంగా లేదా పరిమితంగా అనిపించవచ్చు. ఏజెంట్లతో, అవి మల్టిప్లైయర్లు మారతాయి: ఒకసారి ఎన్కోడ్ తర్వాత, అవి ఒకేసారి ప్రతిచోటా వర్తిస్తాయి.
అదే సమయంలో, పరిమితులు ఎక్కడ ముఖ్యం మరియు ఎక్కడ ముఖ్యం కాదనేది మేం స్పష్టంగా చెబుతాం. ఇది ఒక పెద్ద ఇంజనీరింగ్ ప్లాట్ఫారం సంస్థను నడిపించడాన్ని పోలి ఉంటుంది: సరిహద్దులను కేంద్రంగా అమలు చేయడం, స్థానికంగా స్వయంప్రతిపత్తిని అనుమతించడం. మీరుసరిహద్దులు, సరైనత, మరియు పునరుత్పాద్యత గురించి చాలా శ్రద్ధ వహిస్తారు. ఆ పరిమితుల్లో, పరిష్కారాలను ఎలా వ్యక్తీకరించాలనే విషయంలో టీమ్లు లేదా ఏజెంట్లు గణనీయమైన స్వేచ్ఛను పొందుతారు.
ఫలితంగా వచ్చిన కోడ్ ఎల్లప్పుడూ మానవ శైలి అభిరుచులకు సరిపోలకపోవచ్చు, కానీ అది సరే. ఫలితం సరైనదిగా, నిర్వహించదగినదిగా, మరియు భవిష్యత్తులో ఏజెంట్ రన్లకు సులభంగా చదవదగినదిగా ఉన్నంతవరకు, అది ప్రమాణాన్ని చేరుకుంటుంది.
మానవ అభిరుచిని సిస్టమ్లోకి నిరంతరం తిరిగి పంపుతారు. రివ్యూ వ్యాఖ్యలు, రీఫ్యాక్టరింగ్ pull requestలు, మరియు యూజర్-ఫేసింగ్ బగ్లు డాక్యుమెంటేషన్ అప్డేట్లుగా లేదా టూలింగ్లో నేరుగా ఎన్కోడ్ చేయబడతాయి. డాక్యుమెంటేషన్ తక్కువగా ఉన్నప్పుడు, మేం ఆ నియమాన్ని కోడ్లోకి ప్రమోట్ చేస్తాం
Codex థ్రూపుట్ పెరిగినప్పుడు, అనేక సాంప్రదాయ ఇంజినీరింగ్ ప్రమాణాలు ప్రతికూలంగా మారాయి.
రిపోజిటరీ తక్కువ బ్లాకింగ్ మెర్జ్ గేట్లతో పనిచేస్తుంది. pull requestలు స్వల్పకాలికమైనవి. టెస్ట్ ఫ్లేక్స్ను నిరవధికంగా పురోగతిని అడ్డుకోవడం కంటే, తరచుగా ఫాలో-అప్ రన్లతో పరిష్కరిస్తారు. ఏజెంట్ థ్రూపుట్ మానవ దృష్టిని మించిపోయే వ్యవస్థలో, సవరణలు చౌకగా ఉంటాయి, కానీ వేచి ఉండటం ఖరీదైనది.
తక్కువ-థ్రూపుట్ పర్యావరణంలో ఇది బాధ్యతారహితంగా ఉంటుంది. ఇక్కడ, ఇది తరచుగా సరైన మార్పిడి.
Codex ఏజెంట్లు కోడ్బేస్ను రూపొందించారని మేం చెప్పినప్పుడు, కోడ్బేస్లోని ప్రతిదాన్ని మేం ఉద్దేశిస్తున్నాం.
ఏజెంట్లు ఉత్పత్తి చేస్తారు:
- ఉత్పత్తి కోడ్ మరియు పరీక్షలు
- CI కాన్ఫిగరేషన్ మరియు రిలీజ్ టూలింగ్
- అంతర్గత డెవలపర్ సాధనాలు
- డాక్యుమెంటేషన్ మరియు డిజైన్ చరిత్ర
- మూల్యాంకన హార్నెస్లు
- వ్యాఖ్యలు మరియు ప్రతిస్పందనలు సమీక్షించండి
- రిపోజిటరీని స్వయంగా నిర్వహించే స్క్రిప్ట్లు
- ఉత్పత్తి డాష్బోర్డ్ నిర్వచన ఫైల్స్
మనుషులు ఎప్పుడూ లూప్లో ఉంటారు, కానీ మేం అలవాటు పడినదానికంటే వేరే స్థాయిలో అబ్స్ట్రాక్షన్లో పని చేస్తారు. మేం పనికి ప్రాధాన్యత ఇస్తాము, వినియోగదారుల అభిప్రాయాలను అంగీకార ప్రమాణాలుగా మార్చి, ఫలితాలను నిర్ధారిస్తాము. ఏజెంట్ ఇబ్బంది పడినప్పుడు, మేం దాన్ని ఒక సంకేతంగా పరిగణిస్తాం: ఏమి లోపించిందో—టూల్స్, గార్డ్రెయిల్స్, డాక్యుమెంటేషన్—గుర్తించి, దాన్ని రిపోజిటరీలోకి తిరిగి ఫీడ్ చేస్తాంము, ఎల్లప్పుడూ Codex స్వయంగా పరిష్కారం రాయడానికి.
ఏజెంట్లు మా ప్రామాణిక అభివృద్ధి సాధనాలను నేరుగా ఉపయోగిస్తారు. వారు సమీక్ష అభిప్రాయాన్ని లాగుతారు, ఇన్లైన్లో ప్రతిస్పందిస్తారు, అప్డేట్లను పుష్ చేస్తారు మరియు తరచుగా వారి స్వంత పుల్ అభ్యర్థనలను స్క్వాష్ చేసి విలీనం చేస్తారు.
డెవలప్మెంట్ లూప్లోని మరిన్ని భాగాలు నేరుగా సిస్టమ్లో ఎన్కోడ్ చేసిన కొద్దీ—టెస్టింగ్, వాలిడేషన్, సమీక్ష, అభిప్రాయ నిర్వహణ, మరియు పునరుద్ధరణ—రిపోజిటరీ ఇటీవల ఒక ముఖ్యమైన మైలురాయిని దాటింది, అక్కడ Codex ఎండ్-టు-ఎండ్గా ఒక కొత్త ఫీచర్ను అమలు చేయగలదు.
ఒకే ప్రాంప్ట్తో, ఏజెంట్ ఇప్పుడు వీటిని చేయగలదు:
- ప్రస్తుత కోడ్బేస్ స్థితిని ధృవీకరించడం
- నివేదించిన బగ్ను తిరిగి సృష్టించండి
- వైఫల్యాన్ని చూపించే వీడియోను రికార్డ్ చేయండి
- ఒక ఫిక్స్ను ఇంప్లిమెంట్ చేయండి
- అప్లికేషన్ను డ్రైవ్ చేయడం ద్వారా పరిష్కారాన్ని ధృవీకరించండి
- పరిష్కారాన్ని చూపించే రెండవ వీడియోను రికార్డ్ చేయండి
- pull request ఓపెన్ చేయండి
- ఏజెంట్ మరియు మానవుల ఫీడ్బ్యాక్కు స్పందించండి.
- బిల్డ్ వైఫల్యాలను గుర్తించి పరిష్కరించండి
- తీర్పు అవసరమైనప్పుడు మాత్రమే మానువులకు పంపండి
- మార్పును విలీనం చేయండి
ఈ ప్రవర్తన పూర్తిగా ఈ రిపోజిటరీ యొక్క నిర్దిష్ట నిర్మాణం మరియు టూలింగ్ మీద ఆధారపడి ఉంటుంది; కాబట్టి, తగిన పెట్టుబడి లేదా కృషి లేకుండా ఇది అన్నింటికీ వర్తిస్తుందని భావించలేము—కనీసం, ప్రస్తుతానికైతే లేదు.
ఏజెంట్ పూర్తి స్వయంప్రతిపత్తి కూడా కొత్త సమస్యలను పరిచయం చేస్తుంది. Codex ఇప్పటికే రిపోజిటరీలో ఉన్న ప్యాటర్న్లను, అవి అసమానమైనవైనా లేదా సబ్ఆప్టిమల్ అయినవైనా, పునరావృతం చేస్తుంది. కాలక్రమేణా, ఇది తప్పనిసరిగా మార్పుకు దారితీస్తుంది.
మొదటగా, మానవులు దీనిని మానవీయంగా పరిష్కరించారు. మా టీమ్ ప్రతి శుక్రవారం (వారంలో 20%) “AI స్లాప్”ను శుభ్రం చేయడంలో గడిపేది. ఆశ్చర్యం లేదు, ఆ పద్ధతి ఆశించిన స్థాయిలో విస్తరించలేదు
దాని బదులుగా, మేము “గోల్డెన్ ప్రిన్సిపల్స్” అని పిలిచే మార్గదర్శక సూత్రాలను నేరుగా రిపోజిటరీలో ఎన్కోడ్ చేయడం ప్రారంభించి, పునరావృతమయ్యే క్లీన్అప్ ప్రాసెస్ను రూపొందించాము. ఈ ప్రిన్సిపల్స్ అనేవి స్పష్టమైన అభిప్రాయంతో రూపొందించిన, మెకానికల్ రూల్స్, ఇవి భవిష్యత్తులో జరిగే ఏజెంట్ రన్స్ కోసం కోడ్బేస్ను చదవడానికి సులభంగా మరియు కన్సిస్టెంట్గా ఉంచుతాయి. ఉదాహరణకు: (1) ఇన్వేరియంట్స్ను సెంట్రలైజ్డ్గా ఉంచేందుకు హ్యాండ్-రోల్డ్ హెల్పర్స్ కంటే షేర్డ్ యుటిలిటీ ప్యాకేజెస్ను మేము ప్రాధాన్యంగా తీసుకుంటాము, మరియు (2) మేము డేటాను “YOLO-style” లో ప్రోబ్ చేయము—బౌండరీస్ను వాలిడేట్ చేస్తాము లేదా టైప్డ్ SDKsపై ఆధారపడుతాము, తద్వారా ఏజెంట్ ఊహించిన షేప్స్పై అనుకోకుండా బిల్డ్ చేయకుండా ఉంటుంది. నిర్దిష్ట క్రమంలో, డివియేషన్స్ను స్కాన్ చేయడానికి, క్వాలిటీ గ్రేడ్స్ను అప్డేట్ చేయడానికి మరియు టార్గెట్ చేసిన రీఫ్యాక్టరింగ్ పుల్ రిక్వెస్ట్స్ను ఓపెన్ చేయడానికి బ్యాక్గ్రౌండ్ Codex టాస్క్స్ సమాహారం ఉంటుంది. వీటిలో చాలా వాటిని ఒక నిమిషం లోపే రివ్యూ చేసి ఆటోమర్జ్ చేయవచ్చు.
ఇది చెత్త సేకరణలా పనిచేస్తుంది. టెక్నికల్ డెట్ అధిక వడ్డీతో కూడిన రుణం వంటిది: దానిని చక్రవడ్డీలా పెరగనిచ్చి తర్వాత ఒకేసారి ఇబ్బంది పడటం కంటే, నిరంతరం చిన్న మొత్తాల్లో తీర్చివేయడం ఎల్లప్పుడూ మంచిది. మానవ అభిరుచి ఒకసారి స్వీకరించబడుతుంది, ఆపై ప్రతి కోడ్ పంక్తిపై నిరంతరం అమలు చేస్తారు. ఇది కూడా కోడ్బేస్లో చెడు నమూనాలు రోజులు లేదా వారాల పాటు వ్యాపించకుండా, వాటిని రోజువారీగా గుర్తించి పరిష్కరించడానికి మాకు సహాయపడుతుంది.
ఈ వ్యూహం ఇప్పటివరకు OpenAI లో అంతర్గత ప్రారంభం మరియు స్వీకరణ వరకు బాగా పనిచేసింది. నిజమైన వినియోగదారుల కోసం నిజమైన ఉత్పత్తిని నిర్మించడం మా పెట్టుబడులను వాస్తవికతలో స్థిరపరచడంలో సహాయపడింది మరియు దీర్ఘకాలిక నిర్వహణ సామర్థ్యానికి మమ్మల్ని మార్గనిర్దేశం చేసింది.
పూర్తిస్థాయిలో ఏజెంట్లే రూపొందించిన వ్యవస్థలో, నిర్మాణ సామరస్యం సంవత్సరాలు గడిచేకొద్దీ ఎలా పరిణామం చెందుతుందనేది మాకు ఇంకా తెలియదు. మానవ తీర్పు ఎక్కడ అత్యధిక ప్రభావాన్ని ఇస్తుందో, అలాగే ఆ తీర్పును ఎలా ఎన్కోడ్ చేయాలి తద్వారా అది సమ్మేళితంగా పెరుగుతుందో మేం ఇంకా నేర్చుకుంటున్నాం. మోడల్స్ కాలక్రమేణా మరింత సామర్థ్యవంతంగా మారుతున్నప్పుడు, ఈ సిస్టమ్ ఎలా అభివృద్ధి చెందుతుందో మాకు ఇంకా తెలియదు.
స్పష్టంగా తెలిసిన విషయం ఏమిటంటే: సాఫ్ట్వేర్ను నిర్మించడం ఇప్పటికీ క్రమశిక్షణను కోరుతుంది, అయితే ఆ క్రమశిక్షణ కోడ్లో కంటే స్కాఫోల్డింగ్లోనే ఎక్కువగా కనిపిస్తుంది. కోడ్బేస్ను సమగ్రంగా ఉంచే సాధనాలు, అబ్స్ట్రాక్షన్లు, మరియు ఫీడ్బ్యాక్ లూప్లు మరింత ముఖ్యమవుతున్నాయి.
మా అత్యంత క్లిష్టమైన సవాళ్లు ఇప్పుడు పర్యావరణాలు, ఫీడ్బ్యాక్ లూప్లు మరియు నియంత్రణ వ్యవస్థలను రూపొందించడంపై కేంద్రీకృతమై ఉన్నాయి, ఇవి ఏజెంట్లు మా లక్ష్యాన్ని సాధించడంలో సహాయపడతాయి: సంక్లిష్టమైన, విశ్వసనీయ సాఫ్ట్వేర్ను స్కేల్లో నిర్మించడం మరియు నిర్వహించడం.
Codex వంటి ఏజెంట్లు సాఫ్ట్వేర్ లైఫ్సైకిల్లో పెద్ద భాగాలను చేపట్టేకొద్దీ, ఈ ప్రశ్నలు మరింత ముఖ్యమవుతాయి. కొన్ని ప్రారంభ పాఠాలను పంచుకోవడం ద్వారా మీ శ్రమను ఎక్కడ పెట్టుబడి పెట్టాలో ఆలోచించడానికి మేం మీకు సహాయపడతామని ఆశిస్తున్నాం, తద్వారా మీరు నేరుగా విషయాలను నిర్మించవచ్చు.
