start	end	text
0	3680	Hi everyone and a very warm welcome to this course on Codex.
4140	8000	Really excited to have you here today and hope to learn a lot of things together.
8360	11160	We will learn how to use Codex for enterprise development.
12040	17400	We will see how it works as a coding assistant and its many functions in different situations.
18880	20880	Codex is a tool made by OpenAI.
21900	24500	You might know their famous tool called ChatGPT.
24500	31940	OpenAI is the main company behind ChatGPT and they handle all the AI generation and work.
33080	35340	First, I will show you the OpenAI website.
36500	40500	On their website, they say their research will lead to artificial general intelligence,
41180	43360	which is a system that can solve human problems.
44300	50100	In the products section, you can see tools like ChatGPT, Codex, Atlas and Prism.
50100	60040	ChatGPT is a very large tool that includes images, deep research and GPTs, codecs, multiple applications and libraries.
61140	64000	If we talk about apps, we have multiple apps connection.
64900	71800	You can connect it with popular apps like Adobe, Airtable, Booking.com, Canva, Spotify and more.
72780	75600	Now let us look at OpenAI Codex.
76600	79480	Codex is an AI software engineering agent.
80100	85100	It helps developers write, understand, change, test and ship code easily.
85100	89100	It is not just a simple chatbot that only answers questions.
89100	94100	It works directly with your project files and helps with the whole repository structure
94100	99100	and can make the changes, run commands and assists with development cycles.
99100	103100	It gives developers real engineering results.
103100	108100	Codex is also inside ChatGPT, so you can use it directly.
108100	112100	There is a specific app for Codex, and you can download it for Windows.
113100	122100	We will see how Codex makes real engineering work faster, from planning and building the features, to fixing and releases and cross-checking.
123100	128100	There is also a command line interface, or CLI, on GitHub for Codex.
129100	135100	CLI means Command Line Interface. It is a text-based interface used to talk to software and computers.
135100	141340	Instead of clicking buttons with a mouse on visual icons, you type text commands and the
141340	146740	text-based user interface used to interact with the software, operating system and on
146740	151560	your keyboard instead of using a mouse to click on visual items and press enter to make
151560	152560	them work.
152560	155980	We will learn how to use this CLI.
155980	161480	Codex helps what a developer wants to do and turns it into engineering output.
161480	167380	You can describe a bug or a new feature, test environment, documentation, task, in natural
167380	169500	language.
169500	174860	Codex can analyse the database identifying files, proposed changes and generate limitation
174860	176420	steps.
176420	183100	This makes it useful not only for the writer but also for navigating unfamiliar systemd.
183100	185560	Here we have codex discussion.
185560	191460	In this course we will talk about daily development, prompting, making agents and using codex to
191460	197460	for a long time. We will cover all of these important topics together.
198580	204460	So, moving on, the next critical discussion is primarily related to exactly
204460	210220	how we are going to securely install codecs on our machine. First, well before
210220	214580	actually installing it anywhere else, we will practically use the standard
214580	219420	command-line interface to get things started. But right before that specific
219420	224800	step, we can smoothly download the dedicated version specifically meant for Windows operating
224800	231860	systems. Now, I already have the necessary Codex installer fully ready to go here. I
231860	237840	simply open up the main system downloads folder right now. Then, I firmly run the executable
237840	243800	installer directly as a system administrator. The core software immediately starts to install
243800	250520	itself smoothly. Simultaneously, the Microsoft Store seamlessly begins its essential download
250520	257360	process. Finally, when the entire download completely finishes, Codex will successfully
257360	263580	run. Interestingly, we can certainly also manage to install it safely across multiple
263580	269380	different computer systems. As we smoothly scroll further down the main page, you will
269380	274720	clearly see three distinct setup options presented. The very first one is the
274720	280440	standard standalone app. If we really want to use a code editor we can install it
280440	286000	directly within our preferred IDE. Fortunately we already have Visual Studio
286000	292780	code fully set up. Right inside VS Code a highly helpful AI is fully available. It
292780	299260	is completely automated and we can easily use various models right here. To
299260	305540	To successfully add this to our daily workflow, we simply need to install it in VS Code.
305540	310820	We securely click Allow in VS Code and Codex will seamlessly open.
310820	316980	Essentially, it is OpenAI's powerful coding agent that constantly works with you.
316980	324900	It is fully included in ChatGPT+, Pro, Business, Education and Enterprise plans.
324900	331900	First and foremost we absolutely must carefully check our specific ChatGPT subscription plan.
331900	336580	I will officially open up the ChatGPT interface right now.
336580	342300	As you can clearly see, we currently have the Plus version fully activated.
342300	347500	Looking closely in the dedicated upgrade plan section, you clearly see our active billing
347500	348940	plan.
348940	352340	It is indeed the standard Plus plan.
352340	358460	This essentially means all our ongoing coding work is completely safe and secure.
358460	361400	Codex is fully available to use today.
361400	366380	The strictly required language model is situated right here.
366380	372500	Moving back into VS Code, we will effectively start the complete software installation.
372500	376180	It securely installs just like a standard web extension.
376180	380840	First, we smoothly pair it directly with Codex.
380840	387620	We basically add Codex as a dedicated side panel within VS Code to seamlessly chat, intuitively
387620	391460	edit and carefully check all our changes.
391460	397620	Then, we can confidently use Codex directly in the cloud, sending massive jobs straight
397620	399300	to it.
399300	404740	Moving gracefully to the very next step, we simply need to safely sign in using our primary
404740	407940	ChatGPT account credentials.
407940	413320	Once fully authenticated, our main application will automatically install directly into the
413320	414320	workspace.
414320	420800	Now, the third available setup option is to actually install this directly inside our
420800	423000	system terminal.
423000	429900	For this specific method, just look closely at the Keep going in the terminal prompt section.
429900	434320	We carefully copy this exact command string to our clipboard.
434320	441360	Following that, we explicitly open up the system command prompt, making sure to run it strictly as an administrator.
442320	445600	The Windows PowerShell interface naturally opens up.
446660	453820	Within PowerShell itself, we formally install the OpenAI Codex tool utilizing the NPM Package Manager.
454680	459360	Naturally, it will definitely take a little bit of time to fully install properly.
459360	464860	The underlying system will sequentially gather necessary data in a much better way.
464860	469360	Codex is actively installing and we have our app ready.
469360	472360	Now we go to settings.
472360	477360	We purposefully open the main application settings directly from the main dashboard.
480603	484583	settings menu there are actually many different customisable options
484583	490183	available. I specifically navigate over to the appearance tab in order to make
490183	495803	some visual interface changes. First, I completely change the overall display
495803	502843	theme to a comfortable dark mode. Next, I noticeably increase the base system UI
502843	508783	size for better visibility. We then carefully choose our preferred font
508783	514643	style and slightly adjust the visual contrast. Initially, I confidently write
514643	522163	in 32 for the primary font size, however upon seeing it, 32 is admittedly just a bit too
522163	530443	big for my screen. So I quickly change it down to exactly 24. Honestly, 24 is a genuinely
530443	537643	comfortable size for long coding sessions. For the dedicated code font, we firmly use
537643	546183	size 20. Moving on, we strategically turn off the reduce motion option. We ensure we
546183	552923	use standard pointer cursors and gently lower the screen contrast. Everything is working
552923	560103	well. Honestly, the overall reading experience is just so much better right now. Before we
560103	565883	made those crucial visual tweaks, the default text font was incredibly small and honestly
565883	571523	hard to read. We absolutely had to step in and make the font significantly bigger for
571523	579203	basic clarity. I truly believe that 24 and 20 are excellent, highly optimized sizes for
579203	582483	our daily coding tasks.
582483	588063	Now if we quickly navigate over to the General Configuration Settings menu, we can clearly
588063	594403	see multiple distinct operational modes available to choose from. I promise that I will carefully
594403	599603	explain all of these specific working modes in much greater detail a little bit later on.
600603	604763	Right now, all our required system packages are successfully installed.
605503	610163	The powerful OpenAI codex itself is completely installed.
611103	615223	Now, we just essentially need to forcefully run it one more time.
616183	619843	I smoothly tab back over to the chat GPT window.
619843	623723	I explicitly type out and clearly ask.
624443	626623	I have basically run this command in the terminal.
627343	629043	What do I do next to start it?
630163	635903	We will now officially start the require process right here within our local system terminal.
636763	640303	The entire background installation procedure is completely finished.
641123	646743	It successfully managed to add two vital software packages in just about 36 seconds total.
646743	653743	The software carefully checks the current NPM installation status alongside the available AI models.
653743	658743	First and foremost, we must verify the active codex version.
658743	663743	I simply type NPM codex directly into the prompt.
663743	670743	The resulting codex CLI version currently shows up as 0.139.0.
670743	675743	Next, we actively run codex so we can finally start to code.
675743	682903	to code. We type codex right into the system environment. A brand new security message
682903	689663	suddenly appears on the screen. It clearly asks, do you currently trust the exact contents
689663	696203	of this specific directory? Working directly with untrusted contents definitely carries
696203	703063	inherent security risks or potential prompt injections. Trusting that directory directly
703063	706663	allows for reading local configuration settings.
706663	710903	I confidently click yes and smoothly continue.
710903	714583	After successfully getting that required yes confirmation,
714583	719223	we now finally have our direct working option ready to go.
719223	724303	We have the full power of the OpenAI codex at our fingertips.
724303	730143	Our specifically selected AI model is currently GPT 5.5.
730143	735823	Our active working directory is listed safely as System32.
735823	740943	We can comfortably make direct code changes right here in this space.
740943	745103	If I quickly send over a very simple introductory message,
745103	749103	it impressively replies back almost automatically.
749103	751023	I simply write out,
751023	756783	can you explicitly help me in generating some basic HTML code?
756783	760183	It quickly gives a remarkably short, concise response.
761183	763883	It plainly says, yes, absolutely.
764843	770723	Just tell me exactly what you want the final HTML page to do, or what you want it to look like.
771843	775143	Paste any existing code snippets you might already have.
775143	782803	If you happen to start entirely from scratch, I can easily create a simple HTML framework for you.
783843	785383	Our coding journey begins.
785383	788383	I press Ctrl C to pause.
789243	790343	It shows the response.
791403	795823	The interface clearly displays our complete token usage statistics right on the screen.
796743	802563	The grand total comes out to exactly 7,939 tokens used.
803743	808983	The initial input strictly accounted for 7,881 tokens.
809663	814683	Meanwhile, the generated output was a remarkably short 58 tokens.
815383	821383	To seamlessly continue this exact same chat session, we carefully copy the provided resume
821383	822383	command.
822383	827383	I smoothly paste that specific command right back in here.
827383	831883	Instantly, the previous conversation thread beautifully continues right where we left
831883	832883	off.
832883	838943	If I suddenly decide that I want to completely change the underlying AI model, we currently
838943	842823	have three distinct options available.
842823	849043	Next is GPT 5.5, which is essentially the frontier model specifically built for complex
849043	851683	coding tasks.
851683	859543	Next is GPT 5.4, the strongest overall model strictly meant for everyday standard coding.
859543	866243	Finally, we have the incredibly lightweight GPT 5.4 mini.
866243	870863	We also have very handy slash commands completely ready to use.
870863	875143	we will clearly show exactly how to effectively use them moving forward.
875143	878823	Let's use slash commands.
878823	884483	When I proactively type out a forward slash, Codex immediately shows a complete, highly
884483	888023	detailed working menu of commands.
888023	893403	First and foremost, we can fully configure how Codex strictly operates.
893403	896983	We have the primary model selection option available.
896983	901563	We also have the specific fast option explicitly listed.
901563	908963	We have the IDE integration, to easily include currently open files and broader context.
908963	914683	We actively have detail permissions to precisely choose exactly what codecs can or cannot do
914683	916823	safely.
916823	923143	We have dedicated key maps specifically designed for setting custom keyboard shortcuts.
923143	928183	We have Vim mode strictly intended for our main code composer.
928183	932423	We logically have the Sandbox Add to Directory feature ready.
932423	937163	Finally, we have the Experimental Feature section.
937163	943823	I intentionally select the very first configuration option to explore the available models.
943823	949263	I ultimately choose the GPT 5.4 Mini variant.
949263	953483	Now we selectively choose the preferred reasoning level.
953483	957423	We specifically select low reasoning instead of the standard medium.
958702	962802	We can carefully view current IDE sessions and files.
962802	966462	Next, we review permissions.
966462	971162	There are several highly specific model permissions carefully listed here.
971162	977082	The Read Only setting strictly means that Codex can only safely read active files located
977082	980002	within the current workspace environment.
980002	985342	It absolutely requires your direct manual approval before it can ever attempt to edit
985342	989822	files or directly access the live internet.
989822	995262	The Ask for Approval setting actually serves as the standard default mode, where Codex
995262	1001562	can seamlessly run, read or even edit files inside the current workspace and fully read
1001562	1008562	the active command prompt. Still, explicit manual approval is completely required to
1008562	1015622	permanently edit files or access the internet. Approved for me intelligently only asks for
1015622	1022782	explicit permission when it encounters potentially unsafe system actions. Full access simply
1022782	1028862	means Codex can freely edit files far outside the designated workspace and easily access
1028862	1035962	the internet without ever asking for prior approval. Exercise extreme caution and ask
1035962	1044242	vital questions when using this. I explicitly choose the Approve for me setting. Our updated
1044242	1051342	permissions are cleanly applied. I press Enter and transition to the Keymap configuration.
1051342	1058282	In Keymap we have our transcript, external editor, clear terminal and more options.
1058282	1064122	We practically have multiple distinct configuration options readily available right here, alongside
1064122	1068562	some incredibly useful direct operational options.
1068562	1073962	What we can actually do here is utilise the basic left and right keyboard arrow keys to
1073962	1077122	smoothly navigate and group items.
1077122	1084082	We firmly use the Enter key whenever we strictly need to modify or edit an existing shortcut.
1084082	1090282	We smartly use the star symbol strictly for creating completely custom shortcuts, the
1090282	1096142	dash symbol to quickly unbind an active key, and the Escape key to easily close out the
1096142	1098402	menu entirely.
1098402	1104122	I simply press Escape right now to smoothly go back to the previous screen.
1104122	1109082	Right after successfully configuring our system permissions, we logically have our custom key
1109082	1112362	maps fully sorted out.
1112362	1116942	Next up, we carefully review our active system approvals.
1116942	1122042	You can transparently see absolutely all the recent system changes we manually made right
1122042	1123862	here.
1123862	1128422	We actually changed our primary AI model twice today.
1128422	1132582	We closely reviewed the IDE context settings.
1132582	1137522	We officially updated our security permissions to Approve for me.
1137522	1140882	Finally, I press Control-C.
1140882	1146302	Executing that specific command officially closes out the active chat session entirely.
1146302	1152722	It is crucial to note that this specific underlying configuration genuinely remains the exact same
1152722	1156902	across every single linked application environment.
1156902	1162262	Thankfully, the powerful Codex tool is readily available right here too.
1162262	1166422	We can practically do so many different amazing things with it.
1166422	1172182	If we smartly decide to switch over to the exclusive pre-release software version, absolutely
1172182	1177082	all the newest experimental features become instantly available.
1177082	1183342	I am going to intentionally open up a brand new dedicated project folder officially named
1183342	1186342	Metabrains for our work.
1186342	1193342	We carefully select this exact folder directory and smoothly open up our fresh chat interface.
1193342	1198242	I explicitly confirm that I fully trust the verified authors operating in this specific
1198242	1200202	environment.
1200202	1203902	I smoothly close this secondary pop-up window.
1203902	1210762	I promptly open up a brand new code file appropriately named index.html.
1210762	1216102	You can distinctly see the familiar codex logo right inside this document.
1216102	1222362	We can now finally start to actively write out our core underlying code snippets.
1222362	1228742	The generated Codex AI response will seamlessly appear right here on the interface.
1228742	1234782	We will be able to clearly see our active IDE connection, the linked source repository,
1234782	1241802	the comprehensive onboarding bug log and of course, our preferred dark mode visual theme.
1241802	1247582	We will consistently get highly accurate direct responses moving forward.
1247582	1253362	Now we need to take a very close look at our overall system usage metrics.
1253362	1258082	I purposefully navigate back over to the main settings page.
1258082	1263982	The exact same user account is actively being used uniformly everywhere.
1263982	1269022	We can easily modify our deeper codec software settings right here.
1269022	1276662	You clearly see broad configurations, custom personalisation, advanced MCP servers, webhook
1276662	1281762	integrations, system usage and active billing.
1281762	1287422	We absolutely need to check these panels timely and consistently to perfectly know exactly
1287422	1291542	how we are efficiently carrying all these things forward.
1291542	1294602	We can chat and utilise commands.
1294602	1297102	We can switch models and connect apps.
1297102	1301882	Inside the primary settings menu, we prominently have the visual appearance and core system
1301882	1305022	configuration tabs right at the top.
1305022	1310982	We absolutely also have detail personalization settings, custom keyboard shortcuts, active
1310982	1314922	usage limits and standard billing information.
1314922	1322202	The general designated application usage limit strictly caps out at exactly 5 hours.
1322202	1325842	we happily have a massive 99% of that time left available.
1326782	1331862	The broader weekly limit currently shows 100% completely left over.
1332982	1336762	We have successfully expanded our overall codex usage capabilities
1336762	1341342	alongside the powerful GPT 5.5 deep thinking mode.
1342482	1345882	We can effortlessly purchase an additional credit balance whenever needed.
1347242	1349702	Supported system integrations proudly include
1349702	1351502	seamless browser connections,
1351502	1356502	broad computer use permissions and robust MCP servers.
1356502	1363502	The core coding section beautifully includes active webhooks, secure remote connections,
1363502	1369502	complete Git source control, safe isolated environments and managed work trees.
1369502	1374502	Our foundational setup phase is now entirely complete.
1374502	1380502	The highly anticipated direct usage strictly begins right now.
1381502	1389542	We will now efficiently set up highly secure cloud-based development environments right here in this specific module.
1390502	1395802	You probably remember that we previously ran our Codex agent directly here on the local machine.
1397082	1402242	Absolutely all of our core operational functions were safely contained directly inside it.
1402242	1408802	Now, however, we will purposefully run our advanced cloud-based development environment
1408802	1412902	securely integrated directly within our main codec setup.
1414002	1418702	First things first, I will quickly navigate back over to the main settings panel
1418702	1422542	and intentionally make the system font slightly smaller for better viewing.
1423662	1426802	We gracefully go over to the visual appearance tab
1426802	1432302	and actively change the primary tech size down from 24 to precisely 20.
1433242	1437462	Now, the overall tech size is just so much better and more manageable.
1438854	1444434	I will clearly explain to you generally what these advanced cloud-based development environments actually are.
1445254	1449414	We will deeply understand this entire concept right here today.
1449414	1458054	You absolutely should know right up front that this is essentially a pre-configured, entirely remotely hosted software workspace.
1459094	1464954	It actively contains your preferred IDE alongside all your necessary background tools.
1466214	1473894	Modern developers can effortlessly code, rigorously test and smoothly deploy complex software straight from the web browser.
1473894	1481334	The acronym CDE specifically stands for Cloud Development Environment.
1482814	1486834	It effectively solves that highly frustrating, age-old problem
1486834	1493154	when a specific piece of code miraculously only works on one specific person's local computer.
1494574	1498954	Brand new software engineers can easily start actively coding in mere minutes.
1500074	1501934	This is our dedicated cloud system.
1501934	1508114	Now, let's take a moment to talk about Codex itself.
1508114	1514254	Codex fundamentally has some massive, undeniably big advantages here.
1514254	1521214	Codex genuinely works absolute best when it can safely access the entire full code repository.
1521214	1524974	It impressively also has powerful built-in deployment tools.
1524974	1530974	A cloud environment safely lets Codex seamlessly talk directly to remote code repositories.
1530974	1537974	It can reliably run terminal commands, execute unit tests and thoroughly check projects.
1537974	1541974	It safely makes automated code changes.
1541974	1546974	The biggest overall benefit is undeniable, absolute consistency.
1546974	1550974	In significantly older traditional local development environments,
1550974	1555974	various developers constantly use completely different underlying operating systems
1555974	1558974	and vastly different local machine settings.
1558974	1565974	settings. This inherently creates the infamous, frustrating, well, it perfectly works on my
1565974	1572134	machine problem. Modern, streamlined cloud environments completely remove these highly
1572134	1579094	annoying problems entirely. Absolutely everything that we actively do right here, for example,
1579094	1585914	the previously pinned chat log specifically about making a functional calculator application,
1585914	1592334	all our deep technical discussions are safely stored permanently in this robust cloud system.
1593494	1599374	We can effortlessly and rapidly review our collective past work right here at any given time.
1600534	1605394	Other incredibly massive benefits strictly include nearly instant team onboarding,
1606014	1612334	highly consistent underlying tool setups, absolute hardware independence and reliable
1612334	1614274	long-term session persistence.
1614274	1621474	Now, moving forward, we will thoughtfully choose a specific cloud development platform to use.
1621474	1625874	I will happily show you some excellent real-world examples shortly.
1627134	1631894	First and foremost, we will take a very close look at GitHub Codespaces today.
1633014	1637894	It is a remarkably secure, highly robust cloud development environment used by many.
1637894	1644914	If we genuinely do not want to use this specific one, we can alternatively utilise Gitpod.
1645874	1649914	We actually use the Gitpod platform quite a lot in our daily workflows.
1650994	1655934	It is a fantastic, strictly on-demand, highly scalable development environment.
1656934	1664994	For massively big enterprise companies, we consistently have the AWS Cloud9 infrastructure safely available.
1667894	1670894	for our larger, more complex coding tasks.
1670894	1677894	It is basically a fully complete cloud-based integration development environment from Amazon.
1677894	1683894	It is truly a complete, fully featured IDE right in your browser.
1683894	1691894	We can effortlessly write, smoothly run and quickly fix our complex code directly inside it.
1691894	1695894	These are a few older, very solid examples.
1695894	1704634	Now, I will explicitly search the web to see if Codex itself is officially classified as a cloud-based development environment.
1705434	1707934	It confidently says, yes.
1709294	1716094	Codex, created by OpenAI, is officially a cloud-based AI software engineering agent.
1716094	1729814	It remarkably handles incredibly complex programming tasks, consistently fixes highly stubborn software bugs, and smoothly proposes absolutely all the necessary fundamental work changes for your review.
1730754	1742974	This essentially means that the powerful tool we are actively utilising right now acts almost exactly like a completely standalone, fully robust cloud-based development environment in itself.
1742974	1749354	I strongly suggest that we consistently use this incredible tool to intentionally make
1749354	1754074	a highly secure, deeply isolated remote workspace.
1754074	1759114	There are honestly quite a lot of highly technical back-end things actively running here.
1759114	1763494	I will quickly hop back and change the UI font size once again, because it simply does
1763494	1766814	not look visually right on this display.
1766814	1770974	I will purposefully make it just a little bit bigger, strictly for the sake of our video
1770974	1778454	course clarity. Now we simply go straight back into our main codex application. Everything
1778454	1783834	visually looks exceptionally good now. We have our advanced reasoning engine and other
1783834	1790534	vital backend things running. We will take a complete comprehensive look at this next.
1790534	1795674	This perfectly shows how we put things into a complete cloud-based setup.
1795674	1804134	Now, moving smoothly forward, our very next crucial task is to securely connect our remote
1804134	1806974	GitHub repositories directly.
1806974	1811714	We absolutely need to establish a solid link to our GitHub account directly within the
1811714	1814514	main codec system.
1814514	1820034	Inside our primary GitHub platform, a tremendous amount of distinct configurable options are
1820034	1822674	always readily available.
1822674	1827174	You can clearly see the active status regarding the connection with GitHub right here on the
1827174	1829174	interface.
1829174	1834794	If I cautiously go over to the main settings panel, specifically looking closely in the
1834794	1841154	Connections option area, there is currently absolutely no active connection established.
1841154	1846574	The standard SSH and secure Git credential options similarly show that there are simply
1846574	1849234	no active connections present.
1849234	1855554	Furthermore, down in the Remote Servers and Local Browser tab, there is similarly no connection.
1856554	1862274	In the Computer Use section, we can alternatively use the Google Chrome browser extension.
1863494	1869914	So, our primary GitHub repository profile is clearly not effectively connected to the system just yet.
1870734	1874114	I will intentionally just type out the specific query.
1874674	1878034	Is GitHub firmly connected to Codex right now?
1878034	1882494	to quickly see if we actually get a reassuring green verification tick.
1883394	1888134	This built-in diagnostic tool will thoroughly check the back-end systems
1888134	1892894	and explicitly tell us if our GitHub account is successfully connected or not.
1894294	1898114	Simultaneously, I will efficiently search for the precise phrasing
1898114	1902654	GitHub and official codex integration securely online.
1902654	1910714	This highly powerful system connection can miraculously be added directly without any significant friction.
1911834	1916314	It prominently includes highly advanced automated pull request code reviews,
1916974	1922894	a dedicated co-pilot AI coding agent and deeply integrated GitHub workflow actions.
1924017	1930297	We will comprehensively discuss absolutely all of these incredible back-end setup options in extreme detail.
1930917	1936437	The diagnostic system now clearly shows that the official GitHub integration plugin
1936437	1941117	is indeed fully available directly within the primary codex plugin section.
1941497	1945357	But, unfortunately, this specific local workspace folder
1945357	1949097	is actually not initialised as a valid Git repository right now.
1949757	1953477	A brand new Git tracking folder is quickly being created in the background.
1954637	1959097	Now, if we explicitly click the prominent plus button on the user interface,
1959097	1964017	we can clearly see the GitHub icon safely listed in the available plugins directory.
1964017	1973297	But we critically want to verify exactly which specific user account is currently connected directly to our active GitHub plugin extension.
1974017	1981177	We currently cannot seem to find our primary GitHub profile, so we will manually initiate a deep search for it.
1981937	1987837	When we effectively run the search, the official GitHub authentication app finally appears.
1987837	1996817	The application safely requests broad permission to actively access repositories, track software issues and manage pull requests.
1997297	2000377	But we have simply not fully connected it just yet.
2001197	2004997	So we will proceed to log securely into our main GitHub account.
2005977	2010957	This is our dedicated primary account explicitly named metabrains-del.
2011557	2016457	It undeniably has many repositories and we have done a lot of work here.
2016457	2023117	We will now meticulously connect this specific GitHub account directly to our active Codex
2023117	2025517	system workspace.
2025517	2030457	When I confidently click the connect button, it explicitly asks for final permission to
2030457	2033877	securely connect to GitHub servers.
2033877	2039897	It safely allows the underlying ChatGPT engine to carefully read our previous chats and stored
2039897	2045877	memories to consistently give significantly better, context-aware answers.
2045877	2050657	It clearly states that your deep personal privacy permissions are heavily respected,
2050657	2053677	and you are always completely in control.
2053677	2059057	It does warn that external connectors may possibly introduce some slight security risk.
2059057	2063477	I will boldly open up our Direct GitHub Developer Dashboard.
2063477	2068657	You can visually see that the secure GitHub app authorisation connection is actively starting
2068657	2070557	in the background.
2070557	2076277	Absolutely all our ongoing critical development work is safely housed right here.
2076277	2080737	We will press firmly to continue onward to GitHub so we can comfortably go straight to
2080737	2083237	our main profile account.
2083237	2087337	It will naturally take a little bit of processing time to fully connect.
2087337	2089717	A basic connection will form.
2089717	2091757	You can see it is connected.
2091757	2093237	I open plugins again.
2093237	2098237	Now you will actively see that our dedicated GitHub plugin is finally working precisely
2098237	2099237	as intended.
2099237	2103897	It smoothly works specifically because it is successfully connected to the backend.
2104777	2112057	If it is ever mysteriously not connected, we can easily check our credentials again to see if we can actively reconnect it.
2112717	2119097	We currently have our active user login, but unfortunately, adding the specific external link just failed.
2120197	2122357	Why exactly did it suddenly fail here?
2123137	2128037	We must remember that this is our specific ChatGPT Plus tier account.
2128037	2133617	You absolutely must remember this vital detail because it impacts our permissions.
2134557	2139937	Now we will purposefully open up the completely alternative ChatGPT account instead.
2140717	2147777	We will securely bring our dedicated Michael DuPont user account right here into the active workspace to try again.
2148717	2154017	Our premium ChatGPT plus subscription tier is fully available right here.
2154017	2159517	Now we will carefully attempt to securely connect the integration system once again.
2159517	2164917	It will systematically connect our main chat GPT interface to the repository.
2164917	2174217	If we ever eventually want to completely remove it for security reasons, we can easily uninstall it and quickly reinstall it from scratch later again.
2174217	2180417	We obviously also have the standard option to immediately disconnect the authorization any time.
2180417	2186657	We will gracefully proceed straight directly over to the main GitHub authorisation portal.
2187857	2193137	Now it will successfully build the required connection directly in our correct targeted application.
2194457	2198597	It strictly demands highly secure multi-factor user authentication.
2199877	2204177	We will comfortably utilise the standard Authenticator mobile app to handle this.
2204677	2210317	The mobile Authenticator app will swiftly finish processing our deep security verification.
2210417	2217417	Now you can clearly see that our primary GitHub profile is finally directly connected perfectly.
2217417	2222417	I will quickly pivot back over to our main codex interface.
2222417	2228417	You can clearly see that our secure software link is now fully established and solidly connected.
2228417	2233417	If we carefully look directly at our active system plugins list right now,
2233417	2239417	absolutely all our relevant GitHub integration tasks have delightfully started showing up directly in there.
2239417	2245417	We will smoothly navigate back over to our main chat terminal interface.
2245417	2253417	You can very clearly see our dedicated GitHub functionality is directly added and fully available right there.
2253417	2261417	We will quickly go back over to the plugins tab and our GitHub features will be permanently included in the active workflow loop.
2261417	2266417	It will effortlessly come directly into our daily software development work.
2266417	2272817	Ultimately, we have incredibly successfully added our robust Codex AI tool to perfectly
2272817	2278657	sync with our remote GitHub code repositories.
2278657	2284137	Moving logically to the very next crucial step, we will thoroughly talk about the highly
2284137	2288857	specific agents.md configuration file.
2288857	2294517	This incredibly important file is primarily used for organising massively big software
2294517	2299797	development projects. We specifically utilise it whenever we happen to have
2299797	2305617	many complex automated tasks or a full highly detailed business use case to
2305617	2311017	carefully look at. I will intentionally open it up right here on the screen so
2311017	2315137	you can clearly see exactly where these vital agent configuration files
2315137	2321517	naturally come from and exactly where to easily find them. It will reliably give
2321517	2325937	us the system response directly and accurately.
2325937	2332717	The dedicated agents.md file immensely helps us to deeply inspect and standardise our overall
2332717	2335237	project architecture.
2335237	2340017	You can clearly see it actively looking deep inside our raw project files.
2340017	2346837	Here, it explicitly states that the active workspace is entirely empty right now.
2346837	2351477	There is absolutely no agents.md file found.
2351477	2357357	It checked the temporary scratch space and verified there is no file.
2357357	2363677	To successfully create one from scratch, we absolutely must make a brand new, correctly
2363677	2366977	formatted Agents.md file.
2366977	2372977	I will manually go ahead and create a brand new foundational file right here for you.
2372977	2379117	This incredibly efficient way, we can consistently see absolutely all the necessary high level
2379117	2384717	production details firmly embedded safely within this specific file.
2384717	2391017	First, the core Structured Agents file is quickly drafted out.
2391017	2396897	Right after that initial phase, we can comfortably make far more highly nuanced text changes
2396897	2398437	to this preliminary draft.
2399778	2405158	In this specific advanced technical setup, we usually really need to carefully check
2405158	2411638	if our highly specific basic operational rules or distinct business use cases are actually
2411638	2413918	working properly.
2413918	2418698	successfully and directly created an excellent base foundational agent file
2418698	2425258	right here for us. If we carefully review the generated file we can clearly see
2425258	2430738	its intended core purpose. Besides the purpose there is a clear project
2430738	2437698	overview. We also see a working agreement, a layout and editing rules. We can
2437698	2442118	actively cross-check all of these fundamental operational rules precisely
2442118	2447878	here in the document. I will also make sure to explicitly tell you exactly where
2447878	2453698	this specialized configuration file is typically used. We consistently use the
2453698	2458738	specialized agents.md file to effectively establish strict working
2458738	2464998	boundaries and core rules for literally any AI agent operating in the workspace.
2464998	2470198	There are basically no other bizarre tasks or unrelated work explicitly meant
2470198	2477458	for it. Sometimes, unfortunately, we literally have to go deep down into our underlying operating
2477458	2484958	system just to manually set up the complex agents.md file perfectly. This tedious manual
2484958	2490958	process admittedly takes quite a lot of valuable development time. We essentially have to carefully
2490958	2497138	look at so many different distinct things, like our strict project requirements, core team work
2497138	2504418	ethics and several other highly detailed technical options. We absolutely need to fully know how to
2504418	2510318	properly handle these nuanced things. But for massively big projects, we only deliberately
2510318	2518178	include our basic setup requirements here. Moving right along, next we will deeply discuss exactly
2518178	2524178	how to effectively use this incredibly vital agents.md file in standard practice.
2524178	2534358	Deeply understanding this specific core concept is an undeniably very important foundational part of the entire development process
2534358	2543358	We absolutely need to fully know exactly how to actively create the underlying file directly from absolute scratch
2544478	2550738	Now we purposefully transition and move seamlessly right over to the very next important part
2550738	2562558	We will fundamentally learn exactly how to appropriately handle highly complex things and deeply understand them right after actively creating the foundational file.
2563498	2568898	This is fundamentally a highly special, deeply vital system instruction file.
2569898	2577618	It consistently provides invaluable deep guidance and much needed environmental context directly for our automated work.
2577618	2585158	It can absolutely also be used incredibly effectively, exactly like a traditional readme developer file.
2586298	2592158	You might vividly remember that standard software developers constantly use structured readme files.
2592978	2595998	In the exact same way, we can use this file.
2595998	2610438	I have created a basic agents.md file, but incredibly, we can undoubtedly also meticulously make a highly reusable foundational agents.md configuration template right here in the workspace.
2611158	2619078	We can comfortably and securely include absolutely all of our strict foundational base development requirements firmly inside it.
2619658	2625298	This proactive step will flawlessly kickstart our broader automation work immediately.
2625998	2632238	I will gladly proceed to show you an excellent, highly structured example right now.
2632238	2637998	I will purposely open up Microsoft Word or a standard blank doc text document.
2637998	2642698	I am deliberately using a blank doc right now, strictly so we can comfortably start
2642698	2646118	a fresh, entirely new, empty document.
2646118	2652318	Here, you can very clearly see exactly what critical structural things are highly recommended
2652318	2653878	and available.
2653878	2659538	First, we logically have the high-level project overview section.
2659538	2664878	This clearly tells us exactly what core deliverables we strictly need in the project.
2664878	2672158	Next, we definitely have the strict team coding standards that we must absolutely follow.
2672158	2678758	After that, we discuss repository structures, testing requirements, security rules and large-scale
2678758	2680858	systems.
2680858	2686138	We will practically use a fully functional, highly complete, overarching working system
2686138	2687138	here.
2687138	2693858	Our strictly prohibited, highly restricted system areas will absolutely also be meticulously
2693858	2697898	explicitly listed right here for immense safety.
2697898	2704858	Then, our highly nuanced, deeply specific primary AI operational instructions will be
2704858	2707798	thoroughly included next.
2707798	2713198	Right after all the comprehensive AI baseline instructions, we will seamlessly have all
2713198	2718758	our broader, full-feature architectural options carefully documented.
2718758	2724078	This is essentially exactly what we traditionally call a comprehensive, well-structured readme
2724078	2726978	file in standard development.
2726978	2732958	It practically has all our complete, strict baseline instructions deeply hard-coded and
2732958	2736118	built directly right into it.
2736118	2741758	After this section is successfully completed, the very next essential technical thing dynamically
2741758	2747258	available is dealing with our sensitive back-end environment variables.
2747258	2753298	We will deeply see precisely how we can effectively, securely manage these highly critical system
2753298	2755718	environment variables.
2755718	2763898	Now, our next incredibly critical technical discussion is primarily about handling robust
2763898	2771578	backend environment variables. These are essentially highly dynamic, configurable key values operating
2771578	2777418	in the background. We can actively store them either directly or indirectly deep within
2777418	2783538	our underlying operating system infrastructure. We can comfortably and securely utilise them
2783538	2791138	later for absolutely all of our other automated complex coding tasks. Usually, we deeply involve
2791138	2798318	our complete, highly systematic overall workflow process directly here to explicitly see exactly
2798318	2804118	how a full, robust software system is successfully constructed.
2804118	2809498	These are highly dynamic back-end key values that are stored strictly and directly inside
2809498	2815618	the native operating system, kept entirely safely outside of our vulnerable, raw source
2815618	2822858	code files. They heavily detect and dictate precisely how the running process fundamentally
2822858	2829918	behaves. This brilliant system effortlessly allows developers to incredibly safely store
2829918	2837258	highly sensitive security credentials. What exactly are sensitive credentials? It is highly
2837258	2844818	vital to see this clearly. If we fail to understand this, our work suffers. Sometimes developers
2844818	2850258	are understandably incredibly afraid that their highly sensitive personal or corporate
2850258	2856438	information will eventually accidentally leak to the dangerous public internet.
2856438	2859838	Why exactly does this enormous fear exist?
2859838	2865818	Basically, because our complete interconnected development environment inherently has some
2865818	2868938	deeply guarded secrets.
2868938	2874698	These highly confidential items definitely include things like private API keys, secure
2874698	2878658	admin account usernames and highly encrypted user passwords.
2879801	2883581	We absolutely have to carefully look closely at them and protect them.
2884661	2891441	Now we officially pivot to selectively talk about the massive, overarching enterprise operational level.
2891441	2897181	What exactly inherently happens operating at the massive enterprise scale level?
2898061	2903661	Let us quickly intentionally open up a brand new, fresh, isolated chat window.
2904661	2910061	At the highest enterprise level, actively managing profound structural secrets properly
2910061	2916001	is absolutely critical for safely protecting tremendously sensitive proprietary information.
2917241	2920841	Secrets routinely may include remote cloud access keys,
2920841	2927841	massive database passwords, complex encryption keys, vital third-party API credentials,
2928641	2931161	and various access authentication tokens.
2932521	2936001	Handling environment variables securely with codecs is important.
2936481	2944061	These specific, crucial security items are undeniably very important to actively manage appropriately right here.
2944061	2951061	Usually, wildly different distinct deployment environments inherently fundamentally require
2951061	2954281	completely different sets of unique configuration values.
2955501	2959801	We can intelligently deploy and actively utilise them safely over there.
2961201	2968321	Let me clearly tell you, whenever I actively try to perform a direct system search for standard environment variables,
2968321	2975521	you immediately see our primary system environment variables are visibly available precisely right here.
2976521	2985541	You will undeniably see that absolutely all of our current environment variables are entirely accessible and available literally right now.
2986821	2991301	Sometimes it happens to merely be the static number of active system processors.
2992681	2996481	Sometimes it is a highly confidential external API key.
2996481	3002821	We can smoothly dive deep directly right into the back-end system variables menu,
3003701	3006661	carefully enter the specific custom variable name
3006661	3012241	and its corresponding strict value directly and permanently safely store it.
3013561	3019461	So, the next time we run a use case, all variables are automatically set perfectly.
3020601	3025961	How exactly is this properly handled inside a secure underlying database architecture?
3026481	3033241	As you can visibly observe precisely here, located deep inside the primary configuration
3033241	3041081	interface, we purposely actively include a dedicated corporate company database link.
3041081	3047561	If there happens to clearly be a specific network port required, we firmly include it.
3047561	3053241	If there explicitly is an overarching master application configuration requirement, we
3053241	3060241	we safely add the core app environment variable alongside the specific designated app port.
3060241	3068701	Secure, highly confidential API credentials will absolutely come directly right here.
3068701	3075821	For one clear example, if we genuinely want to safely utilise an external OpenAI API authentication
3075821	3080261	key, we securely do it precisely here.
3080261	3085881	We can undoubtedly also clearly see secure encrypted payment gateway keys stored right
3085881	3086881	here.
3086881	3093401	Then, there are massive authentication backend settings designed purely to store multiple
3093401	3096081	dynamic secrets.
3096081	3103341	These environment variables brilliantly enable large organisations to safely manage app configurations.
3103341	3107601	It prevents leaking sensitive information.
3107601	3114481	handles keys safely too without hard coding. I will definitively also sincerely tell you
3114481	3119821	that strict environment variables frankly may not initially actively seem incredibly
3119821	3124761	very important right now when we merely successfully create basic simple software,
3125641	3130701	absolutely like a fundamental basic calculator or standard normal terminal tools.
3130701	3137601	however the exact moment when we actively rigorously try to fundamentally change our
3137601	3143981	massive software architecture or alter major things safely on a significantly much larger
3143981	3151041	incredibly massive corporate scale literally many distinct individual things wildly realistically
3151041	3158021	start changing aggressively side by side simultaneously we immediately rapidly actively
3158021	3164241	see literally multiple deep cascading fundamental code structural changes happening.
3165141	3172461	Now, moving confidently right forward seamlessly, we will deeply, actively, rigorously, explicitly
3172461	3179141	discuss all of these major systematic fundamental software changes and deeply integrated highly
3179141	3181581	complex AI functions directly later.
3182081	3185041	We will explore this in the next sections perfectly.
3188021	3196021	Authentication and access configuration is a critical part of using OpenAI codecs in an enterprise development environment.
3197021	3203021	Authentication verifies the identity of the user or system attempting to use codecs,
3203021	3209021	while access configuration defines what that user or system is allowed to do.
3209021	3222801	Together, these controls ensure that only authorised developers, teams and automation tools can interact with repositories, environments, APIs and sensitive project resources.
3223781	3235781	In enterprise software development, Codex usually works with cloud-based development environments, GitHub repositories, CI-cd pipelines and internal tools.
3235781	3247041	Because these systems may contain confidential source code, credentials, customer data and deployment configurations, access must be carefully managed.
3248441	3257061	A weak authentication setup can expose the organisation to unauthorised code access, accidental changes or security breaches.
3257061	3265981	Therefore, enterprises commonly rely on identity providers, single sign-on, role-based access
3265981	3272901	control and audit logging. The authentication process normally begins when a developer signs
3272901	3280581	in using an approved identity provider. This may include enterprise login systems such as SSO,
3280581	3288461	OAuth or multi-factor authentication. Once the user identity is confirmed, the
3288461	3292341	system checks whether the user has permission to access Codex, the
3292341	3297981	development workspace and the connected repositories. This ensures that Codex
3297981	3303821	activities are tied to a verified user and can be tracked for accountability.
3303821	3309921	Access configuration determines the scope of Codex's permissions. For example,
3309921	3318921	codecs may be allowed to read a repository, analyse code, create a branch, run tests or open a pull request.
3318921	3325921	In some cases, it may not be allowed to directly merge code or access production secrets.
3325921	3329921	These permissions should follow the principle of least privilege,
3329921	3335921	meaning codecs and users should receive only the access required to complete their assigned tasks.
3335921	3343361	Repository access is especially important. Codecs must often inspect project files,
3343361	3350321	understand dependencies and modify code. However, not every repository should be
3350321	3356421	accessible to every user or AI workflow. Enterprises should configure repository
3356421	3360361	permissions based on teams, projects and business sensitivity.
3361665	3367025	For example, a front-end developer may receive access to UI repositories
3367025	3370865	but not to payment infrastructure or identity management services.
3370865	3375865	Environment variables and secrets also require strict control.
3375865	3382865	Codecs may need to understand variable names, configuration patterns or runtime requirements,
3382865	3386865	but it should not expose or hard code secret values.
3386865	3393865	Sensitive credentials should be stored in secure secret managers and injected only when required.
3393865	3402465	This prevents accidental leakage of API keys, tokens, database passwords or cloud credentials
3402465	3405185	into source code.
3405185	3411485	Auditability is another major requirement in enterprise access configuration.
3411485	3416705	Organisations should be able to review who accessed codecs, which repositories were used,
3416705	3421545	what tasks were performed and what changes were generated.
3421545	3427605	logs help security teams investigate incidents, enforce governance policies, and demonstrate
3427605	3431705	compliance with internal or regulatory standards.
3431705	3438145	A well-designed authentication and access configuration model allows enterprises to use codecs safely
3438145	3440285	and efficiently.
3440285	3446865	It protects sensitive assets while still enabling developers to benefit from AI-assisted coding.
3446865	3453045	By combining strong identity verification, scoped permissions, secure secret handling
3453045	3458985	and continuous monitoring, organisations can create a controlled environment where Codex
3458985	3463205	improves productivity without increasing operational risk.
3463205	3466205	We discuss Codex workflows now.
3466205	3469745	We want to see how Codex uses large workflows.
3469745	3473865	We look at complete software solutions and workability.
3473865	3477645	Sometimes we must see how the whole process grows over time.
3477645	3482045	For this, we change and improve code on a large scale.
3482045	3486105	After these changes, we check the overall process understanding.
3486105	3489645	I will tell you about Codex workflows.
3489645	3493305	Codex helps developers in the software development lifecycle.
3493305	3495365	It does repeating tasks.
3495365	3498105	It makes the coding environment fast.
3498105	3501625	It helps us understand how to fix different problems.
3501625	3505125	It helps us understand different work processes.
3505125	3509285	The most important discussion is how we use codecs.
3509285	3511005	We start with a prompt.
3511005	3513385	We can add details in the prompt.
3513385	3515725	This helps software work well.
3515725	3520505	We use prompts to make software processes easy, fast.
3520505	3522085	We start with the prompt.
3522085	3524585	We can add details in the prompt.
3524585	3528125	The important thing in the prompt is a defined objective.
3528125	3531145	We must have a defined objective.
3531145	3535065	We bring this objective into our software and working process.
3535065	3538185	First, we take the generation process.
3538185	3541405	We understand the process on a large scale.
3541405	3544365	We see how we generate everything.
3544365	3546885	We have one big question.
3546885	3550425	The question is how to define the objective.
3550425	3552625	We look at things to define it.
3552625	3555945	We will see how these things work together.
3555945	3558925	This is a very strong and important point.
3558925	3563825	We must know how to set up objectives for large generation.
3563825	3567205	After we set the objective, we look at the next steps.
3567205	3570205	The next step is feature development.
3570205	3574025	Feature development is a process in our pipeline.
3574025	3578725	After development, the next thing is software defect identification.
3578725	3583445	We must make this defect identification process strong.
3583445	3586845	After we find defects, we move to next steps.
3586845	3590125	The next steps are refactoring and optimization.
3590125	3593605	First, we must define a task.
3593605	3597245	We must have a clear task definition.
3597245	3601045	After we define the task, we provide background context.
3601045	3604685	We provide this context on a large scale.
3604685	3607085	I will explain this process to you.
3607085	3610605	I will use a flow diagram to show how things work.
3610605	3613845	First, we have the task definition.
3613845	3617145	Next, we have Task Context.
3617145	3620805	We must know how to add the context.
3620805	3624345	After the context, we need a detailed prompt.
3624345	3627285	Then we connect our main codecs.
3627285	3630725	We connect codecs with our own codebases.
3630725	3635945	We connect codecs with our codebases to show complete analysis.
3635945	3639965	After analysis, we must have Solution Generation.
3639965	3643025	Solution Generation must be available.
3643025	3647225	After solution generation, the next step is review.
3647225	3650265	I tell you we need these things in our prompt.
3650265	3653745	When we have these things, our prompt starts.
3653745	3658245	Inside this prompt, our solution generation process starts.
3658245	3661245	Here we have our solution generation.
3661245	3664225	After we generate the solution, we review it.
3664225	3667545	We check everything in the review step.
3667545	3670285	After the review, another process starts.
3670285	3677285	We call this new process testing. Testing is very important here. In testing we include
3677285	3685185	debugging. Both testing and debugging must happen together. We need both in our workflow.
3685185	3690745	They help us find and fix problems. These steps make the software better and ready for
3690745	3696765	final stages. Both testing and debugging must be present.
3696765	3699845	The last step available here is refinement.
3699845	3703345	We call this refinement process iteration.
3703345	3706765	We do refinement to make software better.
3706765	3709885	After the refinement step, we commit changes.
3709885	3712785	We save all the changes we made.
3712785	3715345	This is the complete process.
3715345	3718045	At the end, our workflow closes.
3718045	3720865	It closes at the deployment stage.
3720865	3722785	We go to deployment.
3722785	3726065	We deploy our project into our system.
3726065	3728905	These steps are helpful on a large scale.
3728905	3731265	They help us create a better score.
3731265	3734985	They help us create a better decision tree for work.
3734985	3738845	This is how the complete workflow operates from start to finish.
3738845	3742405	We follow these simple rules to make good software.
3742405	3745945	Every step is important for the final product.
3745945	3748265	Deployment is the final goal of this journey.
3748265	3751085	Our next talk is about codecs.
3751085	3754365	We will learn about our projects in codecs.
3754365	3759525	Project navigation is a very important AI skill in modern software development.
3759525	3764765	In big business places, developers work with big repositories often.
3764765	3767785	These repositories have thousands of files.
3767785	3770965	We can see our multiple services directly.
3770965	3777365	It also sees big documentation, complex dependencies and multiple servers.
3777365	3782305	Understanding these projects by hand needs much time and effort.
3782305	3789665	helps developers understand the project structures well. It finds correct files, traces dependencies,
3789665	3796065	and locates our implementation details. I go to the project menu directly. I click
3796065	3803345	Start from scratch. I name the new project Metabrains. I start one project directly here.
3804065	3810225	I save it. Now we have a new project. There is no chat available yet in the project.
3810225	3813225	You see our Explorer and Object options.
3813225	3817225	If we turn on the Explorer, our file opens automatically.
3817225	3821225	You can see we have no document available yet.
3821225	3825225	With time, we will make many additions and changes.
3825225	3829225	Automatically, our response and style will change.
3829225	3831225	I will start from the beginning.
3831225	3835225	We will look at all the changes we make from start to now.
3835225	3839225	Along with changes, we will also see the time.
3839627	3844147	Along with changes we will also see the time. We will see how much time one full cycle takes.
3844147	3849467	We can look at the complete process directly. Sometimes we must approve things directly
3849467	3855907	to understand them, I will tell you. I will type what things should be in our project.
3855907	3865387	I write create an agent.md file. We will create the agent.md file here. This makes our agent
3865387	3871627	work in a much better way. I type because this is a corporate sales manager and content
3871627	3878307	creator project. It will do the first step of our project here. First of all, we give
3878307	3884867	the context and our details. We are making the employee do these things here. We will
3884867	3890787	include this directly for our approval. I tell you that a complete process discussion
3890787	3898307	is very important here. In this, we have to involve all our details. We must involve our
3898307	3904987	full working process here. You can see it will take some time, obviously. It is working
3904987	3913847	in our exact folder. If I refresh our folder here, you will see the agent.md file is created.
3913847	3920347	We can directly review it here. It created the agent.md file with a tailored operating
3920347	3927827	brief. This is for the corporate sales manager and content project. The agent.md file is
3927827	3934667	made here. You can see our exact source code and other things are available. We can open
3934667	3941467	it directly in our VS code. We can open it in the default application. We can also open
3941467	3948167	it in our terminal. These things are much better here. We have a complete system environment.
3949707	3956227	Automatically, we see all divisions and working ability here. Sometimes, this working ability
3956227	3963547	or complete process causes problems. It causes problems on a big scale. We see many issues
3963547	3970207	in our work. We usually create our complete empty MD file at the very start of the project
3970207	3978347	setup. So, on a big scale, if any issue happens later, we can understand it early. We can
3978347	3985087	do things early according to our system. This is a basic discussion now. We see how complete
3985087	3992187	generation happens. We see how we take a complete process or understanding with us. After the
3992187	3998627	agent.md file we will directly look at our project structure. I will go into the exact
3998627	4004727	same folder. I will include a new folder here. This is from a previously created section.
4005627	4011007	You can see our portfolios are available here. I will do all the portfolio discussion here.
4011927	4019167	I will now analyse our repository. I write analyse this repository and provide a comprehensive
4019167	4025827	overview of the project structure. It includes the main purpose of the application. Then we have
4025827	4032947	high-level architecture. Then we have important directories. Then we have all options for
4032947	4040287	important directories on a big scale. After major frameworks, we have entry points. After entry
4040287	4047567	points, we have configuration files. Then we have deployment-related files. Then we have testing
4047567	4052567	structure. Then it says present the information in a structured format,
4052567	4057667	suitable for onboarding a new developer. We can take our things directly in
4057667	4063007	developer onboarding too. We can involve them. This is a complete structured
4063007	4067847	repository layout that we use here. Sometimes we must see some changes in
4067847	4072767	this too. In this we also involve multiple repositories and options
4072767	4078827	directly. When I enter this it will directly go to our folder. The index file
4078827	4085127	is inside. You can see this is like our index file. When the index file opens a
4085127	4090647	complete portfolio website is available. Now we will see how to enhance and
4090647	4095887	understand this portfolio website on a big scale. This will happen in our codex
4095887	4103147	here. It understood the child item here. After that it showed our files. It has
4103147	4110707	shown the key pattern too. We have one HTML document. We have one style sheet. We
4110707	4117307	have one script bundle. Then we have some static assets. We also have all other
4117307	4123787	things available to use directly. Now I will take our details. I will see how our
4123787	4130687	process runs. I will see how all direct discussions and details run. With this we
4130687	4135607	will take our setup. Usually this needs a lot of time if we take these things in
4135607	4141527	another environment but here our things are much simpler now. We can include much
4141527	4147547	better things and accounts here. I will look at our direct use case now. It read
4147547	4152727	out our whole folder here. After that it told us there are no platform specific
4152727	4157407	deployment manifests checked into the repository. The deployment guidance is
4157407	4163287	document only. After that we have a testing structure. Then all other things
4163287	4168867	have come. Now we have gone inside our project. We have seen how we will include
4168867	4174487	our system. Now I will see what entry points are available there. I will write
4174487	4179307	to find the entry points. If we want to look at something other than entry points
4179307	4182687	we will involve all user authentication features here.
4183267	4185087	We will see how we can look at them.
4186047	4189647	Along with this, we will get a direct response from the complete system.
4190407	4193847	We will see how we take things directly in our system first.
4194847	4199327	I will type to locate and explain the implementation of the user authentication feature.
4200027	4202967	I will identify all the components involved here.
4203707	4206047	Then I will look at the authentication flow.
4206047	4209507	Then I will look at the authentication middleware
4209507	4212327	Then I will look at password handling
4212327	4215967	Then I will look at the token generation process
4215967	4219527	Then I will look at the session or token management
4219527	4225447	Then I will provide a step-by-step explanation of how the application starts
4225447	4230687	Then I will process the requests from login to successful authentication
4230687	4233887	These things bring all our details here
4233887	4236587	All our handling has come here now.
4237747	4243287	Generating code from requirements is one of the most practical uses of OpenAI codecs in everyday development.
4244347	4249127	Instead of translating every single business requirement into working code by hand,
4249787	4253587	developers can provide codecs with a vast amount of information or context.
4254787	4258427	We can include clear instructions, behaviours and context.
4259207	4262027	We have multiple forms of languages available to use.
4262027	4265027	Let me open Excalibur here.
4265027	4269027	As you can see, we have some business languages.
4269027	4279027	For example, we can allow users to export reports as CSV or involve role-based access control, also known as RBAC.
4279027	4283027	Codex helps bridge the gap between these requirements and implementations
4283027	4289027	by identifying relevant files, suggesting changes, creating new components,
4289027	4293027	updating APIs, and adding tests where needed.
4293027	4299027	However, Codex works best when the requirements are very specific in nature.
4299027	4303027	Let me show you how to include basics in Codex right from the start.
4303027	4308027	Suppose you want a plan mode, and after that you want to pursue a goal.
4308027	4311027	Then you might want to create a document.
4311027	4316027	After document creation, you might want to include photos.
4316027	4319027	You have multiple plugins that you can use side by side.
4320701	4326281	browser plugin you can use that one too. If you have specific content to use that
4326281	4332481	can be utilized as well. For instance we can go to documents or downloads, select
4332481	4335641	Select an available document and use it.
4335641	4338421	After that we select our model.
4338421	4344241	This latency is quite important, therefore I will use a latest model here.
4344241	4349541	With that latest model, we can increase speed and manage latency well.
4349541	4353921	After this, our prompt should contain very detailed options.
4353921	4358801	First of all, a well-set prompt has some specific elements available within it.
4358801	4361321	I will explain these elements to you.
4361321	4365321	A good prompt includes all these necessary components.
4365321	4372541	The very first thing is context, followed by the role, details, and then the requirements.
4372541	4377521	When discussing requirements, it is a crucial point because codex works better when the
4377521	4379781	requirements are specific.
4379781	4384261	A vague prompt may produce incomplete or misaligned code.
4384261	4390761	A strong prompt includes the feature goal, affected users, input and output behaviour,
4390761	4396521	or modules to consider, coding standards, test expectations and what our codex
4396521	4401321	should avoid changing. Developers should treat the codex generated code as a
4401321	4406081	first draft so we get a complete response right from the very start of it.
4406081	4412061	Next, after the requirements, we need to establish our acceptance criteria. This
4412061	4416801	defines the standard our response must maintain when we receive it. At the end
4416801	4422561	we sometimes use a negative prompt. In a negative prompt we specify the things
4422561	4427561	that we do not need. In the rest of the prompt we list all the necessary things
4427561	4433241	that we want. However, in a negative prompt we mention all those exact things
4433241	4438761	that are not required for our output at all. For example, let me show you a sample
4438761	4443681	prompt right here in this section. We can go into Codex and type out our prompt.
4443681	4452341	We will write that you are working in this repository as a senior software engineer with a lot of experience and solid technical background knowledge today.
4453561	4457821	This defines our role. The complete task is outlined in plain words.
4458721	4465901	After the task, you can see our functional requirements are discussed, such as adding an Export CSV button near the Reports table.
4466881	4470521	Towards the end, all the detailed steps we need to perform are available.
4471141	4473341	This is our acceptance criteria.
4473681	4476681	The export button appears on the report page.
4476681	4479681	Clicking the button downloads a valid CSV file,
4479681	4483681	and the CSV contains the same rows displayed on the table.
4483681	4487681	It will take data straight from the browser, commit the repository in GitHub,
4487681	4490681	and provide the response in document form.
4490681	4496681	Generating code from requirements with Codex improves overall development speed.
4496681	4500681	When our prompts are better, the final results we get will also be much better,
4500681	4506801	better, which we can then utilise today. Clear requirements, a defined scope and
4506801	4511841	strong acceptance criteria help codecs produce code that is easier to review,
4511841	4517921	test and merge in big enterprise teams. We are discussing how big enterprise
4517921	4523001	teams can incorporate these modern features on a larger scale today. Our
4523001	4526781	next discussion will be related to editing and refactoring existing code
4526781	4533781	We have generated this exact code as an example project where we are utilising all these core elements in real time.
4533781	4538781	Now, suppose our initial code is generated and ready.
4538781	4545781	To demonstrate this point well, I will show you a custom calculator code from our older previous generations.
4545781	4555781	In that existing code, we will perform and showcase our past iterations and refactoring processes step by step for all of you to see right here today.
4555781	4562201	today. Now we will discuss editing or refactoring the code. Here you can see
4562201	4566641	that we asked to create a calculator code. It took a quick look and made a
4566641	4571681	plan for us. After making the plan it implemented the calculator in the
4571681	4577741	calculator.py file. This is our calculator. Everything in it is
4577741	4582421	functional from start to finish. If we want to run it we will see that the
4582421	4588461	verification passed using the bundled Python runtime. Note that Python and py
4588461	4594301	are not on our system path, so if we want to use it in our environment we need all
4594301	4600481	these requirements. I will open PowerShell here or I will just open the
4600481	4606781	command prompt. In the command prompt we will give this command. When I press enter
4606781	4611941	you will see that we have a complete response included here. Now I will
4611941	4618301	include it here. There is an issue in the first line of our code. So we will run it
4618301	4624881	from here to here. I will copy this. After copying I will go back to the command
4624881	4631321	prompt. Here is the command prompt. Now we will include it in the command prompt.
4631321	4636881	When we include it you can see that because this file is very old our file
4636881	4643121	is not available here. But we can still run it in our browser. Now we will look
4643121	4648161	at our editing and refactoring here. Usually this is the most valuable
4648161	4653741	capability of our OpenAI codecs for enterprise software development. While
4653741	4658841	generating new code is useful, developers spend a lot of time improving,
4658841	4665061	maintaining and modernizing existing applications. Codecs can analyze the
4665061	4672141	current code base. It can understand relationships between files, identify code smells and suggest
4672141	4678681	improvements for better readability. First I will explain the first thing. This is what
4678681	4686221	we call refactoring code. This is a process of restructuring the existing code. It improves
4686221	4693421	readability, maintainability and internal design without changing its external behaviour.
4693421	4696941	We primarily involve this in our code review.
4696941	4702621	If I go to Excalordraw, I can tell you that after refactoring, the next thing is restructuring
4702621	4703621	or editing.
4703621	4706361	That is very simple.
4706361	4711441	It is simple because we can come into our code, include any line here, and include things
4711441	4713421	by giving a local comment.
4713421	4719741	Or, if we want to do overall refactoring, I can say to make this into an HTML file that
4719741	4722541	I can run in VS Code.
4722541	4726481	Here you can see that now it will directly take our prompt.
4726481	4729421	The code was previously available.
4729421	4735921	Now it will connect our Python calculator into a browser-friendly HTML version.
4735921	4739641	Alternatively I will open our VS Code.
4739641	4745481	You might remember that we already included codecs in Visual Studio Code before, so this
4745481	4750041	will also be available for us to use in a much easier way.
4750041	4755041	Along with this, in Visual Studio Code where everything else is, we will automatically
4755041	4758501	include our calculator file.
4758501	4759501	Codex is open.
4759501	4763521	All our generations and things are available in it.
4763521	4767341	Now you will see that our codex file has arrived here.
4767341	4771681	In the codex file, all our things are directly included.
4771681	4776761	Now you can see that if we want, we can directly open the calculator in the browser, or we
4776761	4780581	We can copy its link and go to another browser.
4780581	4784641	If we copy its link, we just have to go here.
4784641	4789481	When we open it here, the calculator will open in our browser.
4789481	4792061	This is a very simple calculator.
4792061	4797201	If we want to open it in the internal browser of Codex, that is also possible.
4797201	4800081	will load and run our calculator in the Codex browser.
4801264	4805904	Here you can see that if we want, we can directly use this file in our VS Code
4805904	4807744	from the options.
4807744	4811104	We can include annotations. If we want,
4811104	4815584	we can save a screenshot here. After saving the screenshot here,
4815744	4818744	we can also use it in another browser.
4818744	4821744	We can come here and use it here too.
4821744	4826744	So, if we want to make any design changes, we can do that directly.
4826744	4833744	When working with legacy systems, developers often face challenges such as inconsistent coding styles.
4833744	4837744	Here, the coding we have is AI-based coding.
4837744	4843744	However, if we talk about legacy systems, they are systems where we manually write all the code.
4843744	4848184	We make all the changes and alterations in that code ourselves.
4848184	4855504	There, sometimes there are outdated frameworks, poor documentation and tightly coupled components.
4855504	4862064	Codex can help developers understand the purpose of existing code before making modifications.
4862064	4866544	It does this by analysing the related files and dependencies.
4866544	4873504	It can recommend safer refactoring strategies and identify areas where changes may have downstream
4873504	4880004	effects. This significantly reduces the time required to understand unfamiliar code bases.
4880004	4887224	Despite these advantages, developers should carefully review all refactoring changes before
4887224	4892384	merging them into the production branches. Even when functionality appears unchanged,
4892384	4898944	modifications can introduce unintended side effects. Now, I will work on our code here.
4898944	4905064	I will go to our codex. In codex we will write a prompt that you are working as a
4905064	4909744	senior software engineer in this repository. The task is to refactor the
4909744	4914264	existing code without changing its functionality. We will improve the code
4914264	4918684	readability and maintainability and remove duplicate logic with simple
4918684	4924264	complex methods. There is a lot of detail here. The general overview of this
4924264	4928344	detail is that we should make our code readability and maintainability better.
4928344	4933544	As soon as I improve this, we start getting our response.
4933544	4935704	We can directly include this response.
4935704	4939164	First, it will look at the current state.
4939164	4944984	The main refactor target is that we will slightly change the HTML file.
4944984	4948724	First of all, we will include the keyboard handling.
4948724	4953324	After that, we will see multiple changes in this HTML file.
4953324	4957384	If we want to review it, our changes will automatically appear wherever changes are
4957384	4963704	being made in our file. You will see that the refactor is done in one focused pass.
4963704	4970024	I am validating both sides now. Python behaviour should still pass, and the HTML script should
4970024	4974504	still calculate and respond to the button and keyboard actions. Here our checks have
4974504	4982684	passed. Now, if we reload our calculator, many changes will be included in our calculator.
4982684	4985764	Now we have another very important thing.
4985764	4988564	It is not just doing a simple check.
4988564	4991864	It also performed a Python check.
4991864	4998984	If I show you the working, after the Python check it also included HTML behaviour checks.
4998984	5002444	The refactored HTML is built here.
5002444	5005484	It has only 123 lines.
5005484	5009704	I can say that our workability is much easier now.
5009704	5013944	If we look at the code review, it changed many lines in the code.
5013944	5020824	For example, instead of display value 0, it has set the display value to the default value.
5020824	5024864	Overall, it showed our functionality in depth.
5024864	5029704	It directly changed the error coming in the display into show error.
5029704	5034764	Here too, it changed set display error to show error.
5034764	5041004	In simple words, it improved our code maintainability and nullified the error-causing paths on a
5041004	5042984	large scale.
5042984	5047204	It manipulated the errors into the ShowError function.
5047204	5052544	Exactly here too, the SetDisplayError was changed to ShowError.
5052544	5057644	This means, in simple words, our code maintainability has improved.
5057644	5061424	It has removed the paths that cause errors on a large scale.
5061424	5067804	we will discuss context windows and scope. Context window is a new topic. People do not
5067804	5074824	discuss it much. I will tell you what a context window is. A context window is the maximum
5074824	5082284	text an AI model can hold at one time. It works as the AI's memory. Everything inside
5082284	5089144	this window, like prompts, history or files, is seen by the model. Before explaining how
5089144	5095424	it works, I will give you a simple example. For a simple example, I will go to ChatGPT.
5096524	5103784	First, I write a message in ChatGPT. I say, hi, I want to work with AI and HTML.
5104784	5110644	If I continue this conversation, it will write the code. This is simple prompting.
5111164	5118084	We get our answer through it. But if we do something else, if we give a very long prompt
5118084	5125464	again and again. You will see a message. The message says it is too long. Let us see the
5125464	5132444	size of the context window in ChatGPT. I will search for the context window of ChatGPT.
5132444	5140144	It will show the context window size. Usually the model has a 128,000 token window. This
5140144	5147104	This means it takes 96,000 words or 250 to 300 pages of text.
5147104	5150704	I will copy this text and paste it many times.
5150704	5154044	I will do this until the prompt becomes too long.
5154044	5158324	I will copy it and go to a word counter website.
5158324	5160584	It is a famous word counter.
5160584	5165364	When I paste the words here, you will see the website become slow.
5165364	5170604	This is because there are 9,776 words in total.
5170604	5172804	We put this in our prompt.
5172804	5176184	It has 76,000 characters.
5176184	5179124	Now suppose I paste the last text here.
5179124	5180984	You will see a message.
5180984	5184104	It says the long text is added as a file.
5184104	5186324	The text will show up here.
5186324	5190324	I will write that if I put this file in the chat it cannot process it.
5190324	5192784	The message is too long.
5192784	5196664	We want to see the context window size of ChatGPT.
5196664	5198424	It will take time.
5198424	5201824	You will see that the context window depends on the model.
5201824	5207324	OpenAI does not always show the exact limit, but if you see the message it means the text
5207324	5215564	is too long for one input, the file is too big, or the user interface has strict limits.
5215564	5219564	If we use fewer words, we will get our answer.
5219564	5223364	In the same way, when we go to Codex we can see limits.
5223364	5225784	In the new chat we have limits.
5225784	5228484	Wait a minute, I will open it here.
5228484	5230964	We know that Codex has some limits.
5230964	5236004	Even if we add many images, files and documents there are still limits.
5236004	5242364	In real business projects, apps have thousands of files and millions of lines of code.
5242364	5246284	No AI can read all the code at once.
5246284	5250504	Devils must help codecs focus on important information.
5250504	5252844	Scope sets the limits of a task.
5252844	5256784	It includes files, modules and features.
5256784	5259744	Setting the right scope stops bad changes.
5259744	5263164	It helps codecs focus on the right parts.
5263164	5265404	Now I will tell you directly.
5265404	5267484	Suppose we get an answer.
5267484	5269764	How will a full developer work?
5269764	5273444	For example, we will take an e-commerce store.
5273444	5276244	In our example we have an e-commerce store.
5276244	5279264	A developer wants to add a discount box to a product page.
5282073	5290273	Codex. He only shares the product model, service, controller, form and tests. This limits the
5290273	5295553	context. Codex can focus on the updates. It will not make bad changes in other
5295553	5302873	places. Where do we use this? When we make changes this is very helpful. We can
5302873	5308893	modify things easily. You will see two or three options here. We can open it in VS
5308893	5315873	code. We have a full MetaBrain's project here. It has all our files. We can run
5315873	5322053	the index file here. On the side we have our chat. Our codex is also running
5322053	5328413	directly. Besides codex we have an agents option. We can use agents to do
5328413	5334953	our work directly. Now we will verify our GitHub account. Do you remember how I did
5334953	5341933	GitHub authentication? We will authorize VS code directly. Our workflow and
5341933	5348433	personal details will be added here. This works for public and private projects.
5348433	5353613	We can include this directly. If I show you the sign in again, authorisation
5353613	5360753	comes directly. We can confirm it. Suppose we want to verify using email.
5360753	5367033	The email will come automatically. We will confirm the email here. These emails
5367033	5374853	run through a base setup. We got the code here. Then we will verify it. Our VS code
5374853	5382973	will sign in and connect automatically. After signing in, MetaBrainz connects with our co-pilot.
5382973	5389373	We are running many windows. In one place we run the agent. In another place we use
5389373	5399253	our IDE. In a third place, we use it as a chatbot. So, we must manage our context carefully.
5399253	5404753	Context window and scope management are very important for AI software development. By
5404753	5411913	giving the right information and clear boundaries, developers help codecs. It creates accurate,
5411913	5417533	good and reliable code. We must look at these important things carefully.
5417533	5422233	Now, our discussion is about reviewing our AI-generated code.
5422233	5427473	In the AI-generated code, we want to see how we previously used codes like
5427473	5432413	CreateCalculator multiple times, as you can see.
5432413	5439133	We have created the calculator here, and you can see that all our changes are also available here.
5439133	5445413	For these AI-generated changes, we first need to understand two or three things.
5445413	5451213	First, in this complete software we are using, whenever there are changes, the red values
5451213	5456393	will be all our previous values, and the green values will be our new possible changes that
5456393	5458693	we have used here.
5458693	5465013	If you look here, you can first see the set display error, but now in our new code, some
5465013	5467433	things have expanded.
5467433	5473373	Let us suppose I directly include a prompt here saying, I want a scientific calculator.
5473373	5478293	Now, a scientific calculator will be created here.
5478293	5483053	Usually we have this one code and we can call it version 1.
5483053	5488693	Automatically, this version of ours will be applied here, and along with this version,
5488693	5493493	if we have any other versions available here, they will be used.
5493493	5498173	First of all, it will take some time to think about what things were discussed in the previous
5498173	5500013	context.
5500013	5504053	It will review what discussions we were having previously.
5504053	5509773	After all those discussions, our code will automatically start generating here.
5509773	5513193	Alright, it is reconnecting with our work.
5513193	5518313	Our connection with the model is being created to see how a complete connection will be generated
5518313	5521573	and how our thinking will work on a larger scale.
5521573	5526813	Usually, when we are looking at such a code, we have to do validation.
5526813	5530273	We can separate our unified difference from here.
5530273	5534613	We call this split and we call the other one unified.
5534613	5540353	In the split view, our complete previous codebase is on one side and our new code is included
5540353	5542293	on the other side.
5542293	5547413	In the previous one, you can see the display error and here you can see how much our error
5547413	5549813	evaluation is available now.
5549813	5554313	Similarly, our if action is also available here.
5554313	5560153	We can see how much if action we had previously, and after that, how many evaluations are coming
5560153	5561973	in our run action.
5561973	5567473	Alright, so all these things are being directly included in our system.
5567473	5570253	We are looking at multiple changes here.
5570253	5574033	You can see that our connection is being created once again here.
5574033	5579453	We can change the model to a very simple one, make the speed fast, and also change the reasoning
5579453	5580453	here.
5580453	5588033	Now, besides all these things, we have two options available here, Review and Undo.
5588033	5593653	In the Review option, we can directly review our code once in the first scenario.
5593653	5597633	And Undo works exactly like our version control system.
5597633	5601493	It keeps multiple versions in our adopted system.
5601493	5606053	Here you can see that our system is now running, and it is telling us that it is upgrading
5606053	5608253	the existing HTML.
5608253	5613493	Now, let us suppose I take you to this HTML file.
5613493	5616273	I will show all the differences here.
5616273	5620713	They are here now and we will also enable the rich preview.
5620713	5624173	Now you can see that this is our newer file.
5624173	5629053	Even after the newer file, when we make changes again, those changes will also be visible
5629053	5630473	here.
5630473	5634653	You will see plus 32 and minus 21.
5634653	5639053	This shows how many lines of code were removed and how many lines of code were added to our
5639053	5641153	total system.
5641153	5646913	When both these things work together, we automatically start getting our response and work results.
5646913	5649173	It shows how we are managing things.
5649173	5654453	Alright, so this is our very detailed working process.
5654453	5657133	Here you can see all the changes.
5657133	5663173	For a simple example, as we are reviewing now, the title was previously Calculator, but now
5663173	5667673	Now our new title has become Scientific Calculator.
5667673	5673033	Alright, if we look here now, all the design changes of our calculator are shown here with
5673033	5675053	plus and minus signs.
5675053	5681673	Also, you can see that if we want to add something here, we can directly include a local comment.
5681673	5685693	For example, I can say here, I want round buttons.
5685693	5689633	Okay, so now we want our round buttons.
5689633	5693913	As soon as I post this comment, you can see it is included here.
5693913	5696453	Now this comment is added, alright?
5696453	5701393	Similarly, if we go here, I will say, I want more buttons.
5701393	5704893	I am making very simple changes in front of you.
5704893	5706813	I will add the comment.
5706813	5709893	Now there are two comments here, alright?
5709893	5714153	In the same way, at the end of this file, I will say that we need simpler functionality
5714153	5715153	here.
5715153	5718953	Okay, I will say, simple functionality please.
5720293	5722453	Alright, this comment is added here.
5723473	5726813	After that, we can go to the end or just go to the start.
5727773	5729973	In the start, I will change our name here.
5730713	5733173	Change the name as MetaBrainzCal.
5733993	5736013	Okay, MetaBrainzCal.
5737033	5739473	Alright, now our comment is added.
5740413	5743073	You can see that three or four comments are here now.
5743073	5750073	In our calculator, we have a comment in row number 46 and a comment in row number 102.
5750073	5756073	After that, there is a comment in row number 200 and then a comment in row number 6.
5757306	5765046	Now what we have to do here is I can say make the possible changes asked. Okay what will happen here
5765046	5770246	is that based on the changes we included in these comments the changes will happen at those exact
5770246	5775366	points. I will only show you this one change that we demanded at the end in the comments.
5776086	5779686	We will see how it changes the name of our scientific calculator here,
5780326	5786886	and this is a very advanced feature. We are reviewing our complete AI generated changes
5786886	5791366	to see how our reviews can be applied on a larger scale and how we can include them.
5792406	5797286	It will take some time to think. Obviously you can see that it is thinking here,
5797286	5801246	and after that it says, I will apply the review comments directly.
5802406	5804946	First of all, our name will be changed to MetaBrainz.
5805766	5808326	After that, the calculator buttons will be made circular.
5809286	5812066	A few practical scientific buttons will be included.
5813186	5814726	Here you can see our calculation.
5815886	5817626	MetaBrainzCal is written here.
5818606	5822906	After that, we also included a comment here that we want our buttons to be rounded.
5822906	5829906	So, you can see that by including height, aspect ratio, border radius and all these things,
5829906	5833906	it has provided us with some rounded buttons that we can directly see here.
5833906	5838906	Alright, so all these things are greatly included in our working process here.
5838906	5843906	And through this, we can include it in our system, and it will work here.
5843906	5846906	Now we will get all our changes here.
5846906	5849906	You can see that whatever visual changes we have,
5849906	5854666	it has included some lines in a file and showed us the changes here.
5854666	5856946	We can also open that here.
5856946	5863246	OK, after that, for the next changes it makes, you can see our thinking process here.
5863246	5868366	In the thinking process, as it is including our constants and other values, these files
5868366	5871826	will automatically come here side by side.
5871826	5874006	Now it has updated our file.
5874006	5876046	We have all the commands here.
5876046	5881046	As soon as we open this in our browser, all our discussed changes are here, like Metabrains
5881046	5882346	Cal.
5882346	5884826	Our buttons have become rounded.
5884826	5889686	And now, if we include anything here, that thing will automatically be directly included
5889686	5890686	here.
5890686	5893026	OK, our error came here.
5893026	5894726	We are seeing everything working.
5894726	5900066	Alright, if we suppose we need the value of pi here, we get our pi value.
5900066	5903986	If we need the value of log8, we can directly input it here.
5903986	5909626	Also, you can see that this delete option is working directly here too.
5909626	5915186	If we look at all the signs here, every sign that we have is working very easily.
5915186	5919066	We can directly enter all our values here.
5919066	5923726	If there is no responsiveness, we can go ahead and directly include responsiveness in our
5923726	5925786	code later.
5925786	5930266	But code review is the main thing that I have discussed with you.
5930266	5934426	After this, our next discussion is related to our prompt hints.
5934426	5938166	Next we discuss the main usage of a prompt library.
5938166	5942786	We will see how we can use it and where more options are included.
5942786	5944466	First I come here.
5944466	5949946	Instead of using everything, I will search the prompt library in Codex.
5949946	5952866	Here you see Codex prompting.
5952866	5958366	First I tell you this is a built-in collection of reusable workflows, templates and skills
5958366	5962506	in OpenAI Codecs and Agentic CLI.
5962506	5966806	When I go to prompting, you see we often use prompts.
5966806	5971986	You interact with the codecs by sending prompts that describe what you want.
5971986	5974586	Example prompts are shown here.
5974586	5976686	Thread is a single session.
5976686	5981646	It has your prompt plus the model outputs and tool calls that follow.
5981646	5984606	A thread can include multiple prompts.
5984606	5988146	We use a chain of process to take things forward.
5988146	5992606	I will explain this exact process right here in our codex.
5992606	5996706	In codex, we go to our main user settings.
5996706	6000486	Inside these settings we have personalization.
6000486	6005266	In personalization, our own custom instructions are included.
6005266	6010606	We can also switch our AI personality from pragmatic to friendly.
6010606	6014086	Both of these personalization options are here.
6014086	6019466	In custom instructions, we can include all custom-made, personalised instructions that
6019466	6021766	we want in our tool.
6021766	6025366	It is quite simple to include our text responses.
6025366	6031086	But sometimes, we must see our clear deviation and how we are working on stuff, and how these
6031086	6033806	custom instructions work.
6033806	6039086	We have our memory, which we can induce right here in our experimental form.
6039086	6045386	We see how our things can be included and how we can take our many processes forward.
6045386	6050166	Our standard options show how we will best include our own memory.
6050166	6053206	First is the main Enable Memories.
6053206	6056846	Second is our Good Tool Assisted Memories.
6056846	6062146	We can also involve Tool Assisted Memories and involve all our process or workability
6062146	6064306	in it.
6064306	6067626	Next thing is our own custom prompt libraries.
6067626	6070126	What is a good prompt library?
6070126	6075566	I will tell you first that our prompt library is a great reusable prompt hub.
6075566	6079466	In this we can do our text discussion multiple times.
6079466	6082946	We can do multiple workings for our single tool.
6082946	6086146	We must see one more thing here.
6086146	6091286	From the ChatGPT side, there is no prompt library available here yet.
6091286	6094726	We have clear information about basic prompting.
6094726	6099186	But if I talk about the Claude code, there is a distinct prompt library available.
6099186	6105326	We can go there and see the many prompts are collected from the various Anthropic guides.
6105326	6110926	This includes our common workflows and best practices, and how Anthropic teams take Claude
6110926	6113386	code forward.
6113386	6117966	If I want, we can also see the core understand prompts.
6117966	6124486	We see how we can use our own prompts if we need a new prompt for git, release, data,
6124486	6126486	automate or product.
6126486	6131486	A set number of proper prompts are available for every single thing.
6131486	6134486	We can reuse them multiple times over.
6134486	6139486	We can utilise multiple variations or our many functions.
6139486	6143486	This very same thing is available here in our Claude,
6143486	6151486	but if we go to our codex, then until now we do not have these full prompt libraries available.
6151486	6157006	We can do one other good thing here. We can come right here and ask a prompt question.
6157966	6163006	If we go into ChatGPT and for our codecs we include our own best prompts,
6163646	6167326	I can say I want a whole new prompt library for my codecs.
6168446	6172926	It will then give a good reusable clean codecs prompt library.
6174046	6181326	Inside it we have all our good useful prompts. We have our bug fixes, text test generator,
6181326	6191006	code review, refactoring, feature builder, API design, performance optimization and security audit prompt.
6192046	6194606	All these things will involve in that exact thing.
6195886	6202126	From there we will take and use it well. These various things are included in our entire core
6202126	6209166	system on a large scale. We must look at all these many things on a large scale to see how we can
6209166	6215646	reuse them. We will copy it and come inside this main system to use all our many prompts.
6216686	6222846	We will not use these exact things but besides this we have all our 12 core prompts.
6224046	6231406	As we go forward our prompt library will increase even more. From 1 to 12 our many different options
6231406	6238366	will be used and we will include them. These things are used very much inside the entire system.
6239813	6244053	With this, we have a lot of great automation in our work on a large scale.
6244753	6246153	We can use that well.
6247113	6251133	I will tell you, we also have cool automations here on the side.
6251133	6256673	We can run our day brief, week review or smart project monitor.
6257873	6262353	But besides that, if we look at our cool templates, we have very many.
6262813	6264953	Now our next discussion relates to integration.
6265913	6270053	We will see how to perform AI-enhanced CI slash CD.
6270993	6275333	First, I will explain the full definition of CI slash CD.
6276353	6278913	CI stands for continuous integration.
6278913	6283033	CD stands for continuous delivery and deployment.
6284333	6289073	Usually, when enterprise-level workflow loops run, we have multiple projects.
6289953	6297553	We have standalone projects, collaborative projects, or autonomous projects connected to multiple companies, industries, and businesses.
6298413	6301493	For them, we must look at integration and deployment.
6302033	6307613	This is a DevOps methodology that automates building, testing, and releasing software.
6307613	6310413	We can discuss this as automation.
6311413	6317093	This pipeline allows development teams to ship code updates frequently, safely and reliably,
6317533	6319933	while catching bugs early in the development cycle.
6321113	6326893	Usually we do CI slash CD at an industrial or enterprise level where we need automation.
6328013	6330273	First we have continuous integration.
6331273	6335533	It is a practice where developers regularly merge their code into a central repository
6335533	6342093	like GitHub or GitLab. Every time code is merged, an automated system builds the application
6342093	6348293	and runs tests until the integration finishes. This ensures that the new code does not break
6348293	6355793	the existing code base. It allows teams to catch errors instantly. Then we have continuous delivery
6355793	6364173	versus continuous deployment. How can we use CI slash CD? First, it gives a faster time to market.
6364173	6369733	New features and bug fixes reach users in hours instead of weeks or months.
6370733	6374853	There are fewer bugs, easier rollbacks and better developer productivity.
6376133	6383773	CI slash CD pipelines can be used in GitHub Actions, GitLab CI, Jenkins and Circle CI.
6384573	6387173	I will search for codecs on Google now.
6387173	6394633	For example, if I share here that I want this in Codex, then we can also do that, how it becomes possible.
6395933	6402973	Integrating the Codex command line into the pipeline enables OpenAI Codex to automatically evaluate build failures.
6403973	6409513	It analyses vulnerability scans and proposes minimal changes required to make the tests pass.
6410133	6412653	It executes code quality checks directly.
6412653	6416633	It also generates remediation patches or pull requests.
6417173	6423873	Usually, when we talk about our process, we can perform CI slash CD in multiple forms
6423873	6426113	inside our projects.
6426113	6431173	Here in this interface and outside it, if I go directly to the terminal, I can run the
6431173	6434593	CI slash CD pipeline.
6434593	6436053	How can I do this?
6436053	6440013	First, I will search for Codex CLI.
6440013	6444093	The developer platform will open, which we can access directly.
6444093	6446033	Here we must install it.
6446033	6449593	I will come here and command the system to install Codex.
6449593	6452493	We will copy and paste the required command.
6452493	6455693	You will see that Codex is already set up here.
6455693	6459053	Because of this, we do not need to install it again.
6459053	6463153	We simply type our Codex command and it will start running.
6463153	6465233	You have seen this here too.
6465233	6470093	Whenever we give a command, we have a terminal option available on the side.
6470093	6474493	Inside this, we can automatically initiate our working process.
6474493	6479253	We also have a browser option to run CI-cd pipelines.
6479253	6485253	Usually, continuous integration and continuous deployment have become a foundation of modern
6485253	6487253	software engineering.
6487253	6494833	Traditional CI-cd pipelines automate the building, testing and deployment processes.
6494833	6499633	This reduces manual effort and ensures consistent software delivery.
6499633	6507093	With the introduction of AI-powered development tools like OpenAI, Enhanced CI and CD introduces
6507093	6511393	a new layer of intelligence into the software delivery lifecycle.
6511393	6517093	Instead of merely reporting failures, AI systems can investigate the root cause.
6517093	6522333	They propose correlations and create pull requests containing fixes.
6522333	6527133	This dramatically reduces the time developers spend troubleshooting failed builds.
6527133	6532073	It allows engineering teams to focus on high value work such as feature development and
6532073	6534573	architectural improvement.
6534573	6537013	Let me show you a simple example.
6537013	6539373	We can take any system here.
6539373	6543333	When we give a prompt, you can see our working process begins.
6543333	6547233	We get options to debug an issue or review a plan.
6547233	6552013	I will select GitHub and ask it to review the newest repository.
6552013	6553933	The newest repository will appear.
6553933	6557933	Then, I will command it to analyse the latest pull request.
6557933	6560933	It must generate unit tests for newly added functions,
6560933	6563933	modified business logic and edge cases
6563933	6566933	to improve our error handling completely.
6566933	6568933	As soon as I include this,
6568933	6571933	the error handling scenarios will become much better.
6571933	6576933	The other responses will also appear here for us to analyse directly.
6576933	6579933	Usually, the GitHub workflow is infused here.
6579933	6585933	Inside the GitHub workflow, we can directly use our other generations or processes.
6585933	6589933	Our other regions and our understanding will also appear.
6589933	6592933	Side by side, I must tell you another thing.
6592933	6598933	We usually face a concern about how to check our processes inside out on a larger scale.
6598933	6601933	We will see that in a much better form now.
6601933	6607933	In the CI slash CD pipeline, you can see the local workspace is empty.
6607933	6613133	The GitHub account is authenticated, but Git is not available.
6613133	6618773	If we set up these things, we can cross-check our CI slash CD pipelines.
6618773	6623853	We prepare a repository and use the CI slash CD pipeline perfectly.
6623853	6628013	Here, I will give you the example of a pipeline.
6628013	6633053	If you prepare a pipeline of build, which have a request, it has many stage such as
6633053	6636413	names and tests will appear here.
6636413	6641873	If you connect codecs here, then our AI tasks can work side by side with it.
6641873	6646613	Our next topic is putting codecs into our work process.
6646613	6650033	This means adding codecs to our build system.
6650033	6653933	When we do this, the system helps us find problems.
6653933	6659933	If a build stops working or a task breaks, the tool sees the code quality issues.
6659933	6664853	Before, people had to look at every single problem by hand.
6664853	6668613	Now the system looks at the failures for us.
6668613	6672493	It gives ideas to fix them and creates tests.
6672493	6676093	It can even make pull requests with good answers.
6676093	6680173	In a normal process, a person sends code to GitHub.
6680173	6684833	Then our complete system starts running automatically.
6684833	6687453	Things begin to work on their own.
6687453	6690373	We usually watch these actions in our deployment area.
6690373	6694733	For enterprises, this saves a lot of time.
6694733	6698793	do not have to fix the same small problems again.
6698793	6702473	The Codex Assistant helps keep the work active.
6702473	6706173	It understands the whole process of how things run.
6706173	6709553	We like having a place without mistakes.
6709553	6712613	Now let us look at consistency.
6712613	6715973	This is a very important benefit.
6715973	6719373	Sometimes working directly with these pipelines can be hard.
6721754	6728754	First, I will go to our plugins section. We can see the GitHub plugin here.
6728754	6733174	Next, I will search for codecs in the bar.
6733174	6738254	We see many results, but I want to find it in the profile settings.
6738254	6744994	I look at the list of options like packages, co-pilot, pages and security.
6744994	6747674	Here I will search for the codecs.
6747674	6749954	And here we have our codecs.
6749954	6753754	We can also search in GitHub or settings.
6753754	6756474	Then I decide to grant access.
6756474	6759714	To do this, I open our repository.
6759714	6763234	I click on the code button and copy the link.
6763234	6768174	I will ask the chat, do you have access to this project?
6768174	6773614	The system will now check if it can reach the repository and provide us with it.
6773614	6778334	And how we can initiate our working or a larger scale.
6778334	6781234	Sometimes we have to look at these details ourselves.
6781234	6788234	Also, we can take a complete process out here and our generation will be completed in that.
6788234	6791434	This is usually present at a lesser extent.
6791434	6795714	But now we will initiate a full-fledged process here.
6795714	6800834	You will see that it has told us here that yes, I can access the repository.
6800834	6804714	The access to our repository has also arrived here.
6804714	6810914	The second thing it said is that our default branch is main, visibility is public and effective
6810914	6818154	permissions in the session are admin, maintain, push, pull and triage. I can
6818154	6823534	simply say here that we now have to include an agents.md file inside this.
6823534	6829394	This will directly include it and give it to us. But the thing is we cannot
6829394	6835174	create things inside this. So right now we will only cross-check our agents.md
6835174	6840234	file here to see if it is directly available to us or not. These are our
6840234	6846534	things. I will now take our full detailed discussion. You will see that directly
6846534	6853474	after just one second our agents.md file has been included here. Inside it, as you
6853474	6860814	see, git isn't available. So here, after inspecting, it has directly arrived. I can
6860814	6865014	give access here to directly push the code to see how we can improve or
6865014	6870474	include things on a large scale. Side by side another very important thing is
6870474	6876294	running here. Usually in a base pipeline I could not run git push origin here
6876294	6881254	because the directory is not a git repository. Git is not installed in our
6881254	6888134	current shell. Let us suppose we want to install git. How can we do that? First of
6888134	6893774	all we will open our PowerShell here. We come inside this one. Here I say our
6893774	6900354	PowerShell. This is our PowerShell window. Coming directly inside PowerShell, we will
6900354	6906774	state our Git version here. You are seeing that the Git version is available to us here.
6906774	6912114	Let us suppose we want to install our Git. If we use this directly, you are seeing that
6912114	6917934	now we will say we want to install Git with our basic widget. Automatically our widget
6917934	6923754	will be installed here. On the basis of that widget, we will take our things inside running.
6923774	6927774	Usually these things are not explained to us.
6927774	6931774	We are just initiating our production and working on a large scale.
6931774	6934774	Here it will take some time to install.
6934774	6937774	Until it installs we will wait here.
6937774	6941774	Now, due to some issues, our Git is not becoming active.
6941774	6944774	I tried a lot to activate our Git.
6944774	6946774	You are seeing the prefix.
6946774	6950774	Branch prefix is working. Everything is working.
6950774	6959774	We usually did not include our commit instructions, but still, it is possible that by opening these things, all these items come into working.
6960774	6968774	But still, as a matter of fact, the discussion here is that when integrating codecs, organisations start in non-production environments.
6969774	6973774	This allows codecs to analyse failures and generate suggestions.
6973774	6979934	Once the team gains confidence in the results, they can gradually introduce more advanced workflows.
6981334	6986434	These include automated pull request generations and our AI-assisted bug fixing.
6987634	6994154	Overall, Codex acts as an intelligent engineering assistant inside our CI-slash-CD pipeline.
6995074	6997754	It will overall help us in building all our things.
6998274	7001034	These entire matters have been discussed here.
7001034	7008154	An autofix workflow begins the moment a developer pushes code to a repository or submits a pull request for a review.
7009354	7025374	The CI slash CD pipeline automatically starts a series of validation processes such as compiling the application, running automated tests, checking code formatting standards, verifying linting rules and executing security scans.
7025374	7031654	In traditional software development environments, any failure in these checks would require
7031654	7037254	a developer to manually investigate logs, identify the source of the issue, and implement
7037254	7037794	a fix.
7038414	7043994	With codex-powered autofix workflows, the process becomes significantly more efficient.
7045254	7049914	Instead of merely reporting that something failed, the workflow can immediately begin
7049914	7052994	analysing the problem and preparing a potential solution.
7052994	7061454	This transforms CI-CD from a passive validation system into an active participant in software
7061454	7064714	maintenance and quality assurance.
7064714	7070814	Once a failure is detected, Codex examines all available information related to the problem.
7070814	7077934	This includes error messages, build logs, test outputs, recently modified files, project
7077934	7085834	documentation, repository instructions and any development guidelines defined in agents.md.
7085834	7090354	By reviewing these sources together, Codex gains a much broader understanding of the
7090354	7094314	issue than a simple rule-based automation tool.
7094314	7100554	For example, if a login-related test starts failing after a recent update, Codex can inspect
7100554	7107174	the authentication logic, compare the recent code changes, review the affected test cases
7107174	7111434	and determine where the behaviour diverged from expectations.
7111434	7117834	This contextual understanding is one of the major advantages of AI-assisted development workflows.
7117834	7123514	After gathering the necessary information, Codex performs root cause analysis.
7123514	7127734	Rather than attempting random modifications until a test passes,
7127734	7132014	it tries to determine why the failure occurred in the first place.
7132014	7135314	The underlying issue could be a missing import statement,
7135314	7138554	a renamed function that was not updated everywhere,
7138554	7141154	a changed API response structure,
7141154	7143514	an incorrect configuration value,
7143514	7147134	a dependency upgrade that introduced breaking changes,
7147134	7149274	or a test case that no longer reflects
7149274	7152134	the intended application behaviour.
7152134	7155094	By identifying the actual source of the problem,
7155094	7158134	codecs can generate fixes that are more accurate,
7158134	7161574	maintainable, and less likely to introduce new defects
7161574	7163834	elsewhere in the system.
7163834	7169394	Once the root cause has been identified, Codex generates a proposed solution.
7169394	7175094	A well-designed autofix workflow emphasises minimal and focused changes.
7175094	7179514	The goal is not to rewrite large portions of the application, but to make the smallest
7179514	7183214	possible modification that resolves the failure.
7183214	7189434	This approach reduces risk and makes the resulting changes easier for developers to review.
7189434	7194974	For example, if a build fails because of an incorrect import path, codecs should update
7194974	7200374	only the affected import statement rather than refactoring multiple unrelated files.
7201865	7206565	also provide explicit instructions to guide this process, such as requesting
7206565	7211305	that only necessary files be modified, preserving existing coding conventions,
7211305	7216285	and updating tests only when required to reflect legitimate behaviour changes.
7217525	7221625	Following fixed generation, validation becomes the next critical step.
7222665	7227525	The proposed solution is tested using the same pipeline checks that originally detected the problem.
7228605	7236045	Automated builds, unit tests, integration tests, linting tools and security scans are executed again
7236045	7238905	to confirm that the issue has been resolved successfully.
7238905	7249885	If the validation process still detects failures, developers can provide additional context or refined instructions and allow codecs to perform another iteration.
7251285	7258145	This feedback loop helps improve solution quality while ensuring that every proposed change is verified before moving forward.
7259365	7264985	Even when automated validation succeeds, human review remains an essential part of the workflow.
7264985	7279885	Developers examine the AI-generated modifications to confirm that the solution is technically correct, aligns with business requirements, follows architectural standards and does not introduce unintended side effects.
7281025	7292465	This review process also provides accountability and governance, which are especially important in enterprise environments where compliance, security and maintainability requirements must be carefully enforced.
7292465	7298865	Once the fix has been approved, the changes can be merged into the main branch and included
7298865	7301065	in future deployments.
7301065	7308505	Over time, teams can analyse recurring issues and improve their development processes accordingly.
7308505	7316205	Repository instructions, testing strategies, agents.md guidelines and CI-CD configurations
7316205	7322005	can be updated to help codecs handle similar situations more effectively in the future.
7322005	7327505	As a result, autofix workflows not only resolve immediate problems, but also contribute to
7327505	7332845	continuous improvement across the software development lifecycle, enabling teams to deliver
7332845	7338625	higher quality software faster, while reducing the manual effort required to maintain complex
7338625	7339625	systems.
7339625	7345045	Now, the discussion we have is related to configuring automated bug resolution.
7345045	7347585	We can say this on a large scale.
7347585	7352345	In our codecs, along with other things, a discussion was going on.
7352345	7355765	This is most valuable for enterprise use cases.
7355765	7362725	For OpenAI codecs, instead of developers manually investigating every test field, linting error,
7362725	7369085	securing warnings or production defects, codecs can analyse the issue, identify the affected
7369085	7375265	files, generate a proposed fix and create a pull request for human review.
7375265	7380065	This significantly reduces the time spent on repetitive maintenance tasks, while allowing
7380065	7385665	focus for engineers to concentrate on high-level architectural business problems.
7385665	7393285	In modern software teams, bugs are often discovered through CI-CD pipelines, monitoring systems,
7393285	7396845	issue trackers and security scanners.
7396845	7401825	Codecs can integrate into these workflows so that when an issue occurs, the AI automatically
7401825	7407905	receives the failure logs, repository context, coding standards, and our project instructions.
7409105	7415345	Alright, the critical aspect we have for automated bug resolution is defining clear boundaries.
7416385	7421425	Enterprise organisations should never allow AI to directly deploy files into production.
7422305	7428465	Instead, codecs should generate code changes, execute tests, and create pull requests that
7428465	7430965	that require developer approval.
7430965	7433565	This maintains governance and accountability
7433565	7436465	while still benefiting from automation.
7436465	7439005	Human reviewers can remain fully responsible
7439005	7441025	for validating the basic logic.
7441965	7445465	Now, let me tell you a very important thing.
7445465	7449925	Our agents.md file plays a crucial role in the process.
7449925	7452805	What happens is they provide our project specifications
7452805	7455725	and instructions that guide Codex's decision making
7455725	7457845	during bug resolution.
7457845	7467245	These instructions define the coding conventions, testing requirements, security constraints, dependency policies and our architectural patterns.
7468385	7473985	The more structured the agents.md file is, the more accurate and reliable the fixes become.
7474965	7480605	Organisations must look at another thing alongside agents.md – confidence thresholds.
7480605	7486805	For example, codecs may automatically fix linting errors and formatting issues, while
7486805	7493745	security vulnerabilities or database-related bugs require a mandatory senior engineer review.
7493745	7498905	An example of this is that first of all, we have to do this step by step.
7498905	7503985	The first part of our process is to identify our bug trigger resources and define where
7503985	7506485	the bug reports originate.
7506485	7512545	Usually what happens is we see this in our CI slash CD builds, or we can see this in our
7512545	7518665	unit tests we perform, or we can see this in our integration test failures.
7518665	7524245	Sometimes issues can arise in GitHub, or our security scans can cause an issue.
7524245	7529805	Alright, after that we have to identify the AI and look at the AI's fix permissions.
7529805	7536425	If, let's suppose, there's a formatting issue, a linting issue, or a unit test failure,
7536425	7540725	We'll automatically look at all of them, and a detailed discussion will take place regarding
7540725	7543885	production incidents and everything.
7543885	7548205	Agents.md is our most important file which I mentioned here.
7548205	7553545	What happens in Agents.md is we can see the automated bug resolution rules.
7553545	7558285	Whenever we fix a bug, we should minimize the code changes, we should never modify the
7558285	7564325	database schemas, we should preserve the API contracts, add our tests for everyone, and
7564325	7567405	run all of the affected test suites.
7567405	7571945	We must explain the root cause and also create a pull request summary.
7571945	7577205	You can see all of this in agents.md, where we address the bugs, and multiple things are
7577205	7578205	included.
7578205	7585805	Then, if I, let's suppose, perform proper CI slash CD integration, meaning after identifying
7585805	7589525	the trigger sources, we've defined our AI.
7589525	7594705	Then if I say we want to configure CI slash CD here, what I'll do first is take you to
7594705	7596985	the configuration.
7596985	7602165	In the configuration workflow, we first discuss the build failure, then we understand our
7602165	7608725	codex investigation, generate the fix, run the tests, create the pull request, develop
7608725	7612725	our reviews and also then merge our workings.
7612725	7614825	So this will come here.
7614825	7620065	Then the next and most important process, which will be discussed in our setup here,
7620065	7622845	will be our validation of fixes.
7622845	7629705	Here we will require our unit tests, integration tests, security scans, code reviews and our
7629705	7632065	build verifications.
7632065	7635505	These will directly be used to approve our process.
7635505	7641385	Alright, now as an example, if I go into Codex and open a new chat, what will happen in our
7641385	7645845	chat is I'll say directly that a GitHub action has failed. We'll include the
7645845	7650505	repository name directly. We have our failure logs here and the tasks are
7650505	7655545	being discussed the most here. Alright, after that we have our unit test
7655545	7660445	failure which we will use. After that, whatever automated bug resolution we
7660445	7665565	have directly we will configure it. We will discuss a OneGo project today. We
7665565	7670905	will direct a full repository in our OneGo project. First we will create all
7670905	7676185	project code and details. After that we will check our iterations and possible
7676185	7680827	improvements. Then we will use GitHub and Codex.
7681827	7685827	Here is our Codex. We open Codex.
7685827	7689827	Inside Codex, we generate a full project before using prompts.
7689827	7693827	In Codex, we must include the SetAgents file.
7693827	7697227	But we will first exit this project.
7697227	7700227	Then we will build a new project here.
7700227	7703087	I will close this one.
7703087	7706627	We close it and build a new project again.
7706627	7708987	You see projects are available here.
7708987	7712507	I can organise them or start from scratch.
7712507	7715827	We will name our project OneGo.
7715827	7720847	In this project we will build a complete application with everything.
7720847	7723467	First we will pin this project.
7723467	7726967	After pinning, we open it in our Explorer.
7726967	7730367	Our Explorer has no file inside.
7730367	7734327	Later, all generations will come into this file.
7734327	7737387	We have our VS Code and Terminal.
7737387	7741547	I told you before we can use codecs in our terminal.
7741547	7744927	In VS Code, our cursor is available.
7744927	7747287	I will first tell you the plan.
7747287	7749967	We will open our plan mode.
7749967	7752207	We have no plugins yet.
7752207	7754887	We will not use the browser much.
7754887	7758847	We will use the 5.4 model in our GPT.
7758847	7762367	We will use the medium 5.4 model.
7762367	7766267	We will use fast speed here, not default speed.
7766267	7768647	It will be used here.
7768647	7771427	We will not connect GitHub for now.
7771427	7774927	I will say in one go that I am going to make a project
7774927	7777667	about a health care application.
7777667	7780627	Can you plan a project for me?
7780627	7782207	Project planning will start here.
7783207	7785347	First, it will settle output resources.
7786467	7787767	I will not include them now.
7788807	7790587	We look at current workspace.
7791767	7793607	You see nothing is there in workspace.
7795207	7798707	Who is the primary user for the first version of the healthcare app?
7799367	7801267	We have patients and doctors.
7802167	7805507	I will say, this application is for patients.
7806367	7809027	We want to build an application for our patients.
7809027	7815487	What kind of first release do you want to plan? MVP or balanced or ambitious?
7816367	7823607	I will choose MVP. What is our delivery target? We want to build a web application here.
7824167	7828527	I will not build a mobile application. I will build a web app here.
7829247	7835547	The current decision is clear. Patient facing, MVP sized and optimised for a web app.
7835547	7838807	I still need to lock the feature set.
7840067	7841387	Now we have our feature sets.
7842147	7844347	Which feature bundle should define the MVP?
7845527	7846567	Booking and records?
7847327	7849287	We will use this simple option.
7850787	7853947	How should the plan treat healthcare compliance in the first version?
7854867	7858167	We will use HIPAA ready design, which is recommended.
7859167	7863027	We can also use full compliance track or lightweight prototype.
7863027	7867447	How much external integration should the first plan include?
7868727	7871207	I will say minimal integration will be included.
7872147	7873527	These things are recommended here.
7874347	7876527	Through them our entire process comes.
7878007	7879347	What will be the delivery timeline?
7880327	7882847	What will be the delivery timeline for our project?
7883967	7886887	I will say I want it in an urgent manner.
7887867	7890987	This is a fourth part where we can include what we want.
7890987	7893747	What team should this plan assume?
7895007	7896147	Our small team is here.
7897127	7900327	Instead of a small team, we can choose Solo Builder.
7901007	7902967	Our solo builder is here now.
7904327	7905627	What kind of plan do you need?
7906107	7907947	Build plan or business build?
7908727	7911127	We will work with a simple build plan.
7912107	7914667	Now it reduces the project scope and other things.
7915607	7918107	You see, multiple questions are asked here.
7918107	7922907	For a solo builder, what does urgent mean for the first usable release?
7923847	7925427	We will answer one week.
7926327	7927947	We will include one week here.
7929007	7930447	Our plan will come here.
7931547	7935327	Build a patient-facing WebMVP for a solo builder
7935327	7938327	optimised for one week urgent prototype
7938327	7942107	while keeping the design HIPAA aware and future ready
7942107	7944047	for real healthcare data handling.
7944047	7948267	I will read the plan once, then we will implement it.
7949267	7951447	I am saying that we have the entire process.
7952647	7955267	We say our product definition is also happening here.
7956547	7961387	After product definition, our recommended MVP features have also arrived here.
7962687	7965387	Frontend and backend have come in our technical approach.
7966307	7970707	I will tell it that I want just a working frontend and minimal backend.
7970707	7977627	Also, it should be just HTML and CSS with JS logics.
7977627	7980787	We want our product in a simpler way.
7980787	7982927	All these things will come here.
7982927	7985387	The stack has arrived.
7985387	7988207	What should a minimal backend do?
7988207	7991567	We can use a tiny mock API.
7991567	7994827	We can use a basic form backend.
7994827	7998347	We will not use any real backend.
7998347	8001147	How should the frontend be structured?
8001147	8005907	I can say a multi-page application will be required here.
8005907	8009147	What level of frontend quality is needed?
8009147	8014167	I will say we need a portfolio quality user interface.
8014167	8016727	Our plan is created.
8016727	8021447	You can see we have JSON objects and local storage here.
8021447	8026687	Key changes are to reframe the project as a frontend prototype, not a production ready
8026687	8027687	option.
8027687	8030687	Now we can implement this plan.
8030687	8033687	During implementation, it will bring our coding.
8033687	8036687	It is checking the workspace shape.
8036687	8041687	We will look at static app files and shared styles and JavaScript layers here.
8041687	8046687	We will also check the open file to see what things are discussed in it.
8046687	8050687	First it took basic index HTML.
8050687	8053687	We will open our file explorer.
8053687	8056687	We will open 1Go from Documents.
8056687	8062187	For the time being, we have no file or format available in one go.
8062187	8065387	But later our files will appear.
8065387	8071687	It has confirmed our HTML pages and state stylesheet and JS layer.
8071687	8075007	In plugins, our GitHub is not installed yet.
8075007	8079367	I will go to our codec settings to install GitHub once.
8079367	8081407	We will go to our settings.
8081407	8083947	You can see our connections here.
8083947	8087867	In settings, you can see we have our connections.
8087867	8093047	Besides connections, we have our MCP servers here which we can use.
8093047	8096587	We also use plugins here which we can connect.
8096587	8098907	I will go to our plugins.
8098907	8101567	You can see our plugins are available.
8101567	8106127	Where all our other details are, we will include our direct option.
8106127	8109007	In configuration we have our plugins.
8109007	8111827	We can use user configuration.
8111827	8117227	We have sandbox settings and current version and everything is working.
8117227	8120807	In MCP servers our plugins have arrived.
8120807	8125887	We can also see our most used plugin here and how it is discussed.
8125887	8128867	Then we have plugins inside our hooks.
8128867	8133907	And we have our computer use plugin, so any app and our Google Chrome browser has also
8133907	8135787	arrived here.
8135787	8139147	I will bring our plugins into our settings search.
8139147	8141027	These are our plugins.
8141027	8143587	I will use GitHub here.
8143587	8147447	When I connect GitHub, you can see all details have arrived here.
8147447	8151647	Because we are using the Michael DuPont account, we will bring the same Michael DuPont email
8151647	8153187	here.
8153187	8155707	We click on Add Plugin.
8155707	8157767	Adding GitHub will appear.
8157767	8159187	It is approved by our admin.
8159908	8163828	We will go to Connect and continue to GitHub.
8163828	8167908	We will get our detail in our browser, which we will use.
8167908	8170708	You will see that GitHub is now connected.
8170708	8173828	We can try it out in the chat too.
8173828	8179828	In GitHub, we have our repositories and pull requests, and all things have arrived.
8179828	8182828	Our GitHub access is now connected.
8182828	8186828	We have our repositories and issues, and pull requests inside it.
8186828	8192828	We have 97 actions available in the GitHub app related to Read and Write.
8192828	8196828	We can use it for Read and Write functions.
8196828	8200828	If we want to try it in the chat, we can do that too.
8200828	8204988	After this, we go to our healthcare application.
8204988	8209248	You will see that a total of 9 files generated here.
8209248	8212768	You can see in these files we have our app.js.
8212768	8217648	If I go here and reload it, our file structure is still not very strong.
8217648	8221948	But you will see that all our assets are available here.
8221948	8223908	Index and records.
8223908	8227508	And all these files are generated here overall.
8227508	8232508	Now it also told us it found a portability issue in the static assets.
8232508	8236548	A few non-ASCII characters slipped into the labels.
8236548	8238168	It will run them.
8238168	8240328	The command is normalised.
8240328	8243408	I am loading the normal browser.
8243408	8246948	Now we will connect things in our in-app browser.
8246948	8249688	You will see I did not give any prompt.
8249688	8252868	I did not give any prompt on a large scale.
8252868	8256988	I gave a basic prompt that I need a healthcare application.
8256988	8262068	It planned it and took multiple recommendations from me during planning.
8262068	8266508	In the end it generated all our assets in one go.
8266508	8271948	Appointments and dashboard and doctors and index and record files are generated.
8271948	8275188	Now browser automation has also arrived.
8275188	8279228	We have all files for implementation and we can run prototypes.
8279228	8282368	Here is our documentation.
8282368	8289748	Now if I open our file explorer and go to documents and one go, our folder is empty right now.
8289748	8294788	But if I look at our index.html here in the file explorer, you will see that we have a
8294788	8297028	file available.
8297028	8301908	If I open this file in our browser, you will see our project has arrived.
8301908	8304788	It is a healthcare app prototype.
8304788	8309808	We are accessing healthcare here with appointments and records and reminders.
8309808	8313048	When we want to enter a dashboard we sign in here.
8313048	8315488	Our doctors have arrived in it.
8315488	8318268	After doctors our appointments have arrived.
8318268	8320628	And our records have arrived.
8320628	8323968	This is our whole process as you can see.
8323968	8327768	If we want we can confirm any other appointment too.
8327768	8330108	I will confirm an appointment.
8330108	8332528	I will say I have a heart pain.
8332528	8334688	I will just include a reason.
8334688	8338288	When we include this part our second appointment will come.
8338288	8340908	This means our page is loading.
8340908	8347008	If we go to records we have our medications and allergies and recent visits available.
8347008	8351648	If we go to doctors, all doctors we have are listed here.
8351648	8353968	Then comes our dashboard.
8353968	8358628	Inside this dashboard we have our current summary showing the plan and conditions and
8358628	8360548	recent visits.
8360548	8366628	Our insurance card and hydration reminder and medication review are all available.
8366628	8372148	Members and unwanted things are available here. If we want we can build a new demo
8372148	8377848	account instead of demo credentials. I will close this one. I will give a prompt
8377848	8382588	here. I liked my first draft and I want to make this an official app for the
8382588	8388548	patients. Add some vibrant health-based colors in the website. Also try to make
8388548	8393948	it more real. Our prototype is very much liked. In the prototype our login and
8393948	8399388	doctors are very real. But this dashboard has some issues. When I bring it to the phone
8399388	8405368	view it does not look special. It has many issues. This dashboard does not go higher
8405368	8411808	from here. The second thing is our login panel goes too far back. If we go to our network
8411808	8418788	inside the console, nothing special is loading. This means we have no back end. It created
8418788	8425208	a working front end for us. I have given a prompt to update our prototype. You see we
8425208	8431368	have our browser available in plugins. Due to this we can use it. It says I am updating
8431368	8437708	the prototype. It is updating the prototype towards a more launch-oriented Alaska patient
8437708	8444148	app. First I am verifying the current front end structure. Then I will replace the mock
8444148	8450148	positioning with real Alaska provider data. It will shift the design towards a premium
8450148	8455868	Apple adjacent aesthetic without copying Apple owned logos or icons, because we cannot
8455868	8462348	copy the icons. But if we want, we can copy aesthetics based on an ecosystem. And we are
8462348	8468828	going to do the same thing here. This thing will be induced here. In styles you see we
8468828	8474328	we have many changes. It is performing enhancements in our file overall.
8474328	8481328	I have included one thing in the OneGo project. I want to run the Apple ecosystem here.
8481328	8487708	Apple ecosystem means the user interface enhancements in our MacBook or iPhones. I want to adapt
8487708	8494328	them in our project. All those things are happening here. You see what it is doing first.
8494328	8497028	I gave this information here.
8497028	8500168	Use real doctor information from Alaska.
8500168	8502408	I want to launch it there.
8502408	8505568	It is taking Alaska doctor profiles from the list.
8505568	8508968	First, it read all our files.
8508968	8512308	Then it understood index.js file.
8512308	8516128	Then it understood all files in data.js.
8516128	8519868	After that it is carrying on our research purpose.
8519868	8524288	When these things are included, our final website version will come in a better form
8524288	8532288	Let me tell you an important thing. In Codex, whatever things are happening now, you can see them all here.
8532288	8540288	If we have any output, we can see it too. If we have any source, we can see which source it is utilising here.
8540288	8545288	Like here, from a regional hospital list, it is retrieving doctors.
8545288	8553288	First, it makes concrete changes, replacing generic healthcare content with Alaska-specific facility and care context.
8553288	8559968	Second, it is rebuilding the visual system into a brighter, premium look that feels native
8559968	8566088	on iPhone and Mac without copying Apple trademarks or proprietary icon sets.
8566088	8569648	All these changes are being created right now here.
8569648	8574568	In the Styles section, you can see that we have many changes appearing.
8574568	8579248	We are experiencing many changes because it is performing complete enhancements in our
8579248	8581368	file overall.
8581368	8586468	All the styling updates are being processed to match the ecosystem we requested.
8586468	8589208	Our project design is improving to look professional.
8589208	8593308	The software implementation has reached the required final stages.
8593308	8595228	All web files were edited.
8595228	8597788	The main index file is now running.
8597788	8600888	The visual brand appears much better now.
8600888	8604248	Demo logging credentials exist in the database.
8604248	8608048	Entering the main dashboard shows AuroraCare Alaska.
8608048	8613888	Navigating to care teams displays available health and vascular care, internal medicine
8613888	8616368	and real-time schedules.
8616368	8622108	Alaska Regional Cardiology and Providence Primary Care Access Details are visible with exact
8622108	8625568	addresses and contact access details.
8625568	8627768	We can book a medical appointment here.
8627768	8632788	For example, a normal check-up for a child can be scheduled at 10.15.
8632788	8637088	A new medical appointment request is submitted for 1.30.
8637088	8638928	The system updates the patient schedule.
8639819	8641939	The active list shows scheduled visits.
8642839	8645139	We can cancel any booked visit from the records.
8646179	8650299	Previous health records display current patient medications and known allergies.
8650299	8654499	Recent clinical visits and lab reviews are also listed.
8654499	8659299	All recommended system features are implemented in this application version.
8659299	8663299	All these recommended software features are now complete.
8663299	8667299	Next, a brand new change will be adopted.
8667299	8670299	A new user profile feature is needed.
8670299	8677299	The end user should create a new account, add personal details and access a personalized dashboard.
8677299	8682799	Logging out of the current active session brings us to the main screen.
8682799	8686299	Clicking on Create a Demo Account opens a new form.
8686299	8689299	A new name, Alex, is entered.
8689299	8693299	The email address, alex at gmail dot com, is provided.
8693299	8697299	A secure password is created for this new account.
8697299	8700299	The brand new demo account is accessed.
8700299	8703299	Looking at the health records for this new user,
8703299	8706899	previous medications and known allergies are still visible.
8706899	8710379	The recent clinical visit data is also showing
8710379	8715499	old information. This problem happens because synthetic mock data is used.
8715499	8720999	When a new user account is created, all personal details should start fresh.
8720999	8725539	We need to include actual user inputs instead of synthetic data.
8725539	8729079	Even if previous scheduled appointments are cancelled
8729079	8732359	they remain in the application database for the new patient.
8732359	8736759	This behaviour applies to every new patient profile created.
8736759	8740259	New data is not available yet in the interface.
8740259	8744859	To solve this issue, new code logic must be introduced.
8744859	8748659	A text prompt is written to update the application logic.
8748659	8751759	The missing profile fields need to be added
8751759	8756639	and displayed on the main dashboard. The user account creation flow must be
8756639	8757399	complete from
8757399	8761459	end to end. The new user must feel personalized
8761459	8765019	without falling back to generic demo data.
8765019	8768019	The core application logic is updating.
8768019	8772179	Five project files are being edited to implement the changes.
8772179	8779299	These code items include data, HTML, dashboard, index and records files.
8779299	8782739	More software changes are expected to arrive soon.
8782739	8785619	The main project goal is defined now.
8785619	8790179	A new created user account must feel custom and personalized.
8790179	8793179	It should not fall back to generic demo data.
8793179	8797179	The user profile flow is implemented in the source code.
8797179	8801179	Syntax checks are running to verify the software changes.
8801179	8805179	The main index file now includes a complete sign-up form.
8805179	8810179	Logging out again allows us to test the updated demo account creation.
8810179	8814179	The new registration form requires comprehensive user details.
8814179	8823179	Full name, email, phone number, date of birth, blood type, address and medical insurance information must be provided.
8823179	8827179	Emergency contact details are also required to complete the setup.
8827179	8831179	These user details will be stored across the application assets.
8831179	8836179	The new account registration form is filled with specific user data.
8836179	8840179	The first name, Alex, is entered along with the email address.
8840179	8842179	A random phone number is provided.
8842179	8847579	The proper date of birth is set. The blood type is selected as A positive.
8848579	8857919	The user city is entered as Alaska. The geographic region is specified as USA, region, state, Alaska.
8858959	8862939	An insurance plan named Master Insure Pro is added.
8864019	8866259	An emergency contact number is also provided.
8866859	8871179	In the end, a secure password is created to finalise the account.
8872179	8875179	The new user account is created.
8875179	8880179	Navigating to the medical records section shows the updated patient identity.
8880179	8885179	All personal details provided during sign-up are displayed here.
8885179	8889179	The scheduled appointments section is now empty and ready for new bookings.
8889179	8894179	The care team section reflects the correct operational details.
8894179	8897179	The personalised user dashboard is functional.
8897179	8901399	Multiple future system changes can be integrated as the project evolves.
8902619	8904979	All main project details are configured.
8906019	8908919	The next crucial step is to upload the project code.
8910019	8914359	A command request is made to push all files into a remote GitHub repository.
8915599	8920239	The operating system checks available GitHub capabilities within the active workspace.
8921219	8924159	A local system Git installation is not found.
8924159	8929159	The active folder is not recognised as a valid Git repository.
8929159	8934159	Two concrete system blockers prevent the code push process.
8934159	8938159	First, the Git software is not installed on the machine.
8938159	8943159	Second, there is no connected remote GitHub repository available.
8943159	8948159	Suggested options are provided to resolve these software issues.
8948159	8952159	A new public code repository must be created first.
8952159	8957159	The main GitHub website is open to create a new online repository.
8957159	8960159	The user login credentials are saved.
8960159	8965159	A new repository named OneGoProjectHealthcare is created.
8965159	8968159	The access visibility is set to public.
8968159	8971159	The repository creation process completes.
8971159	8975159	The Internet repository link is now available for connection.
8975159	8980159	The required remote repository link is copied from GitHub.
8980159	8986659	This specific link is pasted into the system prompt to initiate the web connection.
8986659	8991659	The active system processes the target online repository URL.
8991659	8996999	It checks whether the main GitHub connector has the necessary account access.
8996999	8999779	The code push access is verified.
8999779	9003499	The current local project files are being read in order.
9003499	9007879	The development plan is to publish them into the main code branch.
9007879	9011879	This action is done through the built-in GitHub connector.
9011879	9016379	The raw text content of all project files is extracted.
9016379	9019819	The public code files are prepared for web publishing.
9019819	9024739	A small project readme file is also generated for the repository.
9024739	9028499	At this moment, the online repository is empty.
9028499	9033879	Refreshing the web GitHub page confirms no files are uploaded yet.
9033879	9037859	The background publishing application is running the pull request.
9037859	9043539	Once the upload process is approved, the new content will be available online.
9043539	9048219	The computer system waits for the background publishing process to execute.
9048219	9051339	A new approval prompt appears on the screen.
9051339	9056339	It requests security permission to allow GitHub to run the file creation tool.
9056339	9060979	The required permission is granted by selecting the Allow option.
9060979	9067179	This choice ensures automatic file creation without repetitive manual user approvals.
9067179	9071639	A subsequent system request asks to create code git blobs.
9071639	9075199	This security permission is also allowed to proceed.
9075199	9081739	These technical steps are necessary to transfer the local workspace files to the remote web environment.
9081739	9087059	If the source code is left in the local workspace, it cannot be shared or deployed.
9087059	9092099	Moving it to the online repository ensures the system is integrated.
9092099	9095419	Two separate system blockers are identified again.
9095419	9099859	the local machine still lacks a local software Git installation.
9099859	9105279	The web GitHub integration can read files, but write operations are blocked.
9105279	9110799	This problem happens because the integration cannot access the necessary developer tools.
9110799	9115979	To resolve this exact issue, a local system installation is required.
9115979	9117979	A new internet browser tab is opened.
9119827	9125727	install git is executed. The official git software installation page is accessed.
9125727	9131187	The Windows desktop operating system option is selected. The standalone
9131187	9135947	software installer for Windows is downloaded. The software download process
9135947	9141147	will take some time to finish. The installation setup will be executed soon.
9141147	9147087	The main git installer file is saved to the computer desktop. The file download
9147087	9152027	continues in the background. In the meantime the computer system provides a
9152027	9156627	text list of terminal commands. These commands are required to push the
9156627	9162327	source code by hand. Before executing them, remote repository permissions must
9162327	9167667	be verified. The main GitHub settings page is opened to ensure proper developer
9167667	9173907	access rights. The account security and variables section is examined. The account
9173907	9178707	moderation options are also visible. Navigating to the repository security
9178707	9184227	permissions is necessary to allow new code uploads. The active pull request
9184227	9188967	settings are reviewed. The code merge commits and squash merging options are
9188967	9193547	enabled by default. The version commit settings and archive features are
9193547	9198327	checked. The critical danger zone is avoided to prevent accidental project
9198327	9203627	deletion. Everything appears to be configured in a proper state. The git
9203627	9208187	software installer download is now complete. The application setup file will
9208187	9213047	be executed next to install the software on the computer. The downloaded git
9213047	9218147	software installer is executed from the computer desktop. The application setup
9218147	9222727	wizard appears on the screen. The standard default installation options are
9222727	9227727	selected by clicking the next button multiple times. The default components
9227727	9232607	are chosen for the system installation. The default code editor is maintained.
9232607	9236727	The initial project branch name configuration is left as a default
9236727	9242927	choice. The system path environment is updated. The software installation process
9242927	9248447	begins extracting core files. The visual progress bar indicates the current
9248447	9253487	installation status. The program installation is completed without errors.
9253487	9259847	The active current terminal window is closed. A fresh new terminal session is
9259847	9264947	launched to apply the updated installation paths. The specific git
9264947	9271007	initialize command is executed again. The operating system initializes an empty
9271007	9277087	local git repository. The local development project folder is now tracked by the git tool.
9278207	9281567	The next required command is copied from the text instructions.
9282767	9286687	The project branch is renamed to main using the active terminal.
9287887	9290847	The text command executes without any prompt errors.
9291967	9298207	The remote origin target command is copied next. This specific command links the local code
9298207	9304567	repository to the new created online GitHub repository. The web link is pasted
9304567	9309267	into the terminal and executed. The internet connection is established
9309267	9314947	without issues. The next development step requires adding all project files to the
9314947	9321247	code staging area. The standard git add command is prepared. An error prompt
9321247	9326947	occurs stating access permission is denied. The operating system cannot open
9326947	9330567	a distinct application data directory.
9330567	9333947	This file access issue must be resolved.
9333947	9338307	The access permission denied error halts the running process.
9338307	9343327	The operating system attempts to add developer files from the root user directory instead
9343327	9345607	of the project folder.
9345607	9348467	This behaviour is a crucial mistake.
9348467	9353067	The code terminal is operating in the wrong system directory path.
9353067	9359707	A new Terminal Application tab must be opened within the exact correct project folder.
9359707	9363267	The root user terminal is closed without delay.
9363267	9369547	The new command terminal now displays the correct document path for the software project.
9369547	9374847	The standard git initialize command is executed again in the right folder.
9374847	9380067	An empty code repository is initialized here without any issues.
9380067	9385627	The Branch Rename Text command is executed to set the main branch.
9385627	9392407	The Remote Origin command is pasted and executed to link the online GitHub repository.
9392407	9396167	The correct project folder is now connected.
9396167	9401107	The next workflow step is to add all files to the staging area.
9401107	9406167	The simple Git Add command is executed without errors this time.
9406167	9410767	All main project files are added to the code staging area.
9410767	9416267	The standard git commit command is executed with a descriptive message.
9416267	9421507	The operating system returns an author identity unknown error.
9421507	9426487	The code commit cannot proceed without proper user identification.
9426487	9431507	The global user configuration commands must be executed first.
9431507	9435687	The terminal command to set the user email is copied.
9435687	9441887	The account email address is updated to match the online GitHub account credentials.
9441887	9445787	The command is executed without any system errors.
9445787	9450387	The terminal command to set the username is copied next.
9450387	9455487	The developer username is retrieved from the Web GitHub profile page.
9455487	9460387	The target username is pasted into the terminal command line.
9460387	9464687	The system configuration is updated without issues.
9464687	9468667	The required author identity is now established.
9468667	9473367	The standard git commit command is executed once again.
9473367	9477507	This specific time, the code commit is a success.
9477507	9481887	All modified files are recorded in the local repository.
9481887	9485527	The source code is ready for the final push.
9485527	9492447	The main commit process includes all necessary application files, the design assets, HTML
9492447	9497007	web pages and application data files are secured.
9497007	9501707	The final terminal command to push the source code is executed.
9501707	9508287	The command terminal requests user authentication to access the remote GitHub repository.
9508287	9513267	A new internet browser window opens for the user login process.
9513267	9517407	The Sign in with internet browser option is selected.
9517407	9523167	The existing active session credentials are used to authorise the upload transaction.
9523167	9526907	The access authorisation succeeds without delay.
9526907	9532547	Returning to the command terminal confirms the code push process is active.
9532547	9537027	The data objects are compressed and written to the remote web server.
9537027	9541867	The main code branch is set up to track the remote origin point.
9541867	9545447	The entire application project is uploaded.
9545447	9550827	The online GitHub repository page is refreshed in the internet browser.
9550827	9554807	All local project files are now visible online.
9554807	9559667	The assets folder and HTML text documents are listed.
9559667	9563927	The code upload process is verified and a success.
9563927	9570427	The uploaded index document file is opened on GitHub to verify its code contents.
9570427	9575607	The online code matches the local computer version without flaws.
9575607	9579527	The source blame and file history options are functional.
9579527	9583287	The raw text code can be accessed any time.
9583287	9586947	The entire upload process is now concluded.
9586947	9592507	The initial project objective was to build a medical healthcare application project.
9592507	9595307	A detailed development plan was formulated first.
9598331	9604851	basic minimum viable product. The database backend requirements were later removed to
9604851	9608471	to focus on the user front-end interface.
9608471	9615131	The HTML and CSS design structures were developed with minimal JavaScript logic.
9615131	9621771	Various design iterations improved the visual page aesthetics and user experience.
9621771	9626851	The personalized user profile creation feature was integrated.
9626851	9632351	In the end, the local source code was pushed to a public code repository.
9632351	9636571	The application project is stored and accessible.
9636571	9641171	Future code modifications can be implemented and tracked through this version repository
9641171	9643871	system without effort.
9643871	9649031	The detailed software implementation plan proved effective in practice.
9649031	9655611	We established a strong code foundation using standard modern web technologies.
9655611	9662111	The front-end user interface provides a seamless, smooth experience for clinical patients managing
9662111	9664551	their healthcare needs.
9664551	9671851	The synthetic mock data limitations were overcome by implementing dynamic user input handling.
9671851	9677211	The medical appointment scheduling and user cancellation workflows operate without any
9677211	9679351	system errors.
9679351	9685831	Essential patient medical records remain accessible on the personalised user dashboard.
9685831	9691731	By utilising the Git version control system, the main source code remains protected against
9691731	9698591	accidental data loss. The open public repository allows other software developers to review
9698591	9704971	the application project structure. This developer workflow demonstrates a practical approach
9704971	9711491	to rapid web application development and code deployment. The initial system setup challenges
9711491	9718111	regarding local machine software requirements were resolved with great speed. The comprehensive
9718111	9724771	command terminal instructions ensured execution of necessary developer commands.
9724771	9732571	The final software outcome is a functional, well-documented and versioned front-end application.
9732571	9735211	The established project goals are fulfilled.
9735211	9739831	The discussion relates to possible iterations we can include here.
9739831	9745691	In our use cases, we create projects multiple times, requiring iterations.
9745691	9750031	We can include these iterations to see what is possible.
9750031	9751831	Iterations start from the beginning.
9751831	9755151	We include project details and formats.
9755151	9758731	Another option is available after project creation.
9758731	9762451	Moving to the end, our index was complete at this step.
9762451	9769531	Here, in frontend, backend, appointments and records, our option has arrived.
9769531	9771471	Changes are never small.
9771471	9775971	For changes, we will include details multiple times.
9775971	9781311	Another important thing is working in an environment requiring code changes.
9781311	9783591	Iterations become version-based.
9783591	9787911	The first website version was quite different from the current version.
9787911	9792651	We must understand version histories to see which was more compatible.
9792651	9796891	Sometimes we include specific things from a specific version.
9796891	9800691	Going into our project, this was the final version.
9800691	9806571	Looking at this project, considering the whole use case, the logo is incorrect.
9806571	9808571	We can change the logo.
9808571	9812851	The dashboard should be a sliding dashboard, not a consistent one.
9812851	9817191	Instead of this, some analytics should be involved here.
9817191	9822691	Looking here, the card distance and the empty space in the website should be minimal.
9822691	9825931	We should fill such spaces beforehand.
9825931	9831051	In our website text, search engine optimization is not involved.
9831051	9833891	The colors involved here are quite dull.
9833891	9838311	We can improve all these things just by giving it some prompts.
9838311	9841151	Our iteration will start happening now.
9841151	9847951	Alongside iteration, another important thing is making large scale improvements via prompts.
9847951	9853451	Since this tool is based on our prompts, any new improvement will be based on prompts.
9853451	9856911	there is no other way to improve our stuff.
9856911	9860491	These things will be induced here with our ongoing time.
9860491	9863851	As our time increases, we must iterate these things
9863851	9866891	and see how we are taking them forward.
9866891	9869571	Along with this, another important thing
9869571	9872571	is that when making improvements based on prompts,
9872571	9874891	error chances increase.
9874891	9878551	Therefore, we should review our code first.
9878551	9881091	After reviewing the code, we should take things
9881091	9884651	towards our other generations and discussions.
9884651	9887471	Sometimes, within our code itself,
9887471	9890971	there are multiple errors we spend time correcting.
9890971	9894271	We are focusing on making the dashboard intuitive.
9894271	9896931	The layout needs adjustments so upcoming visits
9896931	9899331	and active reminders are visible to the user.
9900351	9902271	Care teams and appointment sections
9902271	9904751	must be integrated together.
9904751	9907531	This ensures the entire application functions
9907531	9911331	without visual or technical interruptions.
9911331	9915851	This completes our entire discussion related to our iteration.
9915851	9919291	Along with the iteration, we covered possible improvements
9919291	9921691	that needed to be discussed.
9921691	9925111	Looking at the bottom section, the reminders and profile
9925111	9928691	loaded cards have gaps needing fixes.
9928691	9932331	The design should feel premium and responsive.
9932331	9934811	The patient readiness items must be tracked
9934811	9937631	on one premium dashboard.
9937631	9940311	When looking at source options for medical centres,
9940311	9943791	like Providence Alaska Medical Centre or Alaska Native Medical
9943791	9947851	Centre, information must be displayed.
9947851	9950611	The layout structure lacks proper alignment,
9950611	9953571	and text blocks feel disconnected.
9953571	9958451	We will use specific commands to refine these interface elements.
9958451	9961411	Once we apply new styles, the final product
9961411	9963811	will look more professional.
9963811	9971131	Everything will be committed to the repository, ensuring all changes are saved and tracked for future updates and continuous development.
9971651	9972891	Now comes the last part.
9973791	9976631	At the end of this course, you saw one main thing.
9977351	9979351	It was our GitHub and Codex tools.
9980211	9981511	We tried to connect GitHub.
9982311	9983971	Then we got many tech issues.
9984491	9987771	I will say here I will use our plugin of GitHub now.
9988431	9991291	I will start a discussion with the GitHub plugin tool.
9991291	9995551	I will ask, can you check if GitHub plugin is working?
9996451	9998291	This will test our plugin once.
9998951	10001491	We will see if our plugin works in any user case.
10002111	10005111	If our plugin is not available, we can check it.
10005851	10007971	You can see we have verification now.
10008871	10010551	You can see that I have verified it.
10011331	10013111	This login account Robert is here.
10013911	10015711	You will remember our main account here.
10016111	10017291	That is connected here.
10018191	10020031	Its user ID has also come.
10020031	10024771	that confirm that the plugin is installed, reachable and authenticated.
10025771	10028251	Now I can say, what can I do with this?
10028931	10030911	This will start giving us a response.
10031711	10033751	It will tell us where we can use this plugin.
10034831	10037211	This tool is not available on a weak level,
10037971	10040551	but still we have to see how our tool can work here.
10041151	10045411	You will see here it says you can ask it to read multiple actions.
10046491	10048591	In this we also get more recommendations.
10048591	10052591	I will suggest to you that we should use multiple plugins.
10052591	10056591	Like right now, you are seeing that we can use our windows.
10056591	10060591	We have our Chrome and data analytics and product design.
10060591	10066591	We also have Apollo and Atio and Carter CRM and Clay and Circleback.
10066591	10070591	We have Granola and Otter and Canva.
10070591	10072591	We can use all these plugins.
10073431	10074811	We have many options.
10075651	10078631	If we bring any of these in here, we can use it out.
10079291	10082431	For every niche, we have separate options available for us.
10083031	10087571	Like for our education and research, we also have options available right here.
10087571	10090531	We have our Dow Jones Factiva here.
10090951	10094651	We have our GovTribe and we have Life Science Research.
10095551	10098691	For finance, we have multiple softwares available right here.
10099751	10104411	So what Codex does is on a large scale it gives us multiple plugins to use.
10105331	10109691	From these, the used plugin on our developer side is our GitHub plugin.
10110691	10115851	But if we want to use multiple plugins on our whole enterprise level, we can do that too.
10115851	10118851	With that, our price will increase.
10118851	10122851	Our usage cost will also become a cost that is quite high.
10125851	10130851	The OpenAI ecosystem is a collection of tools, models and platforms
10130851	10136851	that help individuals and organisations use artificial intelligence in practical workflows.
10137851	10142851	In this diagram, OpenAI ecosystem is the central idea
10142851	10146451	and the main branches show the important parts connected to it.
10147831	10151131	ChatGPT is one of the most familiar parts of the ecosystem.
10152271	10156611	It helps users write content, explain concepts, solve problems,
10157251	10159951	summarise information and support daily work.
10160771	10165751	In software development, ChatGPT can help developers understand errors,
10166331	10171911	write documentation, plan features and improve prompts before using them with coding tools.
10172851	10180451	The OpenAI API allows developers to connect OpenAI models directly into their own applications.
10180451	10192411	For example, a company can build a chatbot, document assistant, coding assistant, customer support tool or automation system using the API.
10193971	10198351	This makes AI usable inside real business products and enterprise systems.
10199811	10202011	Codex is focused on software development.
10202851	10212851	It helps developers generate code, refactor files, explain existing code, create tests, debug issues, and work with repositories.
10213851	10222851	In an Enterprise course, Codex is important because it shows how AI can support real development workflows instead of only answering questions.
10223851	10227851	The Models branch represents the AI models behind the ecosystem.
10227851	10234391	These models can work with text, code, images and other types of input depending on the
10234391	10237471	product or configuration.
10237471	10242351	Better models usually mean better reasoning, better code understanding and more accurate
10242351	10244351	responses.
10244351	10249651	Finally, enterprise tools are important for organisations.
10249651	10257491	Enterprises need security, governance, permissions, auditing and control over how AI is used.
10257491	10263511	These tools help companies adopt AI safely while protecting data, managing access and
10263511	10265991	following internal policies.
10265991	10273131	Overall, the diagram shows that the OpenAI ecosystem is not just one product.
10273131	10280631	It includes user-facing tools, developer APIs, coding assistance, advanced models and enterprise
10280631	10282131	controls.
10282131	10288991	Together, these parts help teams build, automate, learn and develop software more efficiently.
10292891	10300411	This conclusion mind map summarises the key lessons learned throughout the OpenAI Codex Enterprise Development course.
10301191	10308131	The central idea is that AI-assisted development is becoming an important part of modern software engineering
10308131	10317751	and organisations that learn to use these tools effectively can significantly improve productivity, software quality and development speed.
10318611	10322511	The first branch focuses on OpenAI Codex itself.
10323591	10336091	Throughout the course, learners discovered how Codex helps developers generate code, analyse repositories, refactor applications, create tests and automate repetitive development tasks.
10336091	10344571	Rather than replacing developers, Codex acts as an intelligent development assistant that helps teams work more efficiently.
10345471	10348791	The next branch highlights the development workflow.
10350091	10356171	One of the most important lessons from the course is that AI can support every stage of software development.
10357391	10364951	Developers can use Codex during planning, implementation, testing, debugging and deployment preparation.
10366091	10369771	Instead of viewing AI as a tool used only for coding,
10369771	10375691	organisations can integrate it into the complete software development lifecycle.
10375691	10381291	The Enterprise Adoption section emphasises that successful AI implementation
10381291	10384651	requires more than technical capability.
10384651	10387931	Organisations must establish governance frameworks,
10387931	10393611	security controls, compliance processes and collaboration standards.
10393611	10403491	Enterprise teams need visibility into how AI is used and must ensure that generated code meets organisational policies and quality requirements.
10404791	10410291	The best practices branch represents the habits that produce the best results when working with codecs.
10411371	10415311	Effective prompt engineering helps developers communicate requirements clearly.
10416451	10419931	Code reviews ensure generated code is maintainable and secure.
10419931	10426931	Validation and testing confirm that AI-generated features satisfy business requirements.
10426931	10431931	These practices help maximise the value of AI-assisted development.
10431931	10435931	Another important area is operational excellence.
10435931	10444931	As AI adoption grows, organisations must monitor usage, manage costs, optimise resources and measure performance.
10444931	10456311	Understanding token consumption, tracking productivity improvements and evaluating return on investment help organisations scale AI responsibly and efficiently.
10457271	10462971	The continuous learning branch reminds learners that AI technologies evolve rapidly.
10464111	10473371	Developers should stay informed about new codex capabilities, open AI platform updates, community best practices and industry trends.
10473371	10481051	Teams that continuously learn and adapt will gain the greatest long-term benefits from AI-assisted development.
10482091	10486451	The Future of Development section looks ahead to emerging trends.
10487611	10496831	AI assistants will become more capable, agent-based workflows will become more common, and human-AI collaboration will continue to evolve.
10496831	10504831	Developers will increasingly focus on architecture, business logic and strategic decision making,
10504831	10507831	while AI handles more implementation tasks.
10507831	10514831	Finally, the most important takeaway is that AI augments developers rather than replacing them.
10514831	10519831	Human expertise remains essential for understanding business requirements,
10519831	10528771	making architectural decisions, reviewing code quality, managing risk and ensuring software meets organisational goals.
10529951	10538951	When used effectively, Codex enables developers to deliver better software faster while maintaining quality, security and reliability.
10538951	10546531	In summary, the course demonstrates that successful enterprise AI adoption requires a combination
10546531	10552571	of technical skills, governance practices, continuous learning, and thoughtful collaboration
10552571	10554591	between humans and AI systems.