WEBVTT

00:00:00.000 --> 00:00:03.680
Hi everyone and a very warm welcome to this course on Codex.

00:00:04.140 --> 00:00:08.000
Really excited to have you here today and hope to learn a lot of things together.

00:00:08.360 --> 00:00:11.160
We will learn how to use Codex for enterprise development.

00:00:12.040 --> 00:00:17.400
We will see how it works as a coding assistant and its many functions in different situations.

00:00:18.880 --> 00:00:20.880
Codex is a tool made by OpenAI.

00:00:21.900 --> 00:00:24.500
You might know their famous tool called ChatGPT.

00:00:24.500 --> 00:00:31.940
OpenAI is the main company behind ChatGPT and they handle all the AI generation and work.

00:00:33.080 --> 00:00:35.340
First, I will show you the OpenAI website.

00:00:36.500 --> 00:00:40.500
On their website, they say their research will lead to artificial general intelligence,

00:00:41.180 --> 00:00:43.360
which is a system that can solve human problems.

00:00:44.300 --> 00:00:50.100
In the products section, you can see tools like ChatGPT, Codex, Atlas and Prism.

00:00:50.100 --> 00:01:00.040
ChatGPT is a very large tool that includes images, deep research and GPTs, codecs, multiple applications and libraries.

00:01:01.140 --> 00:01:04.000
If we talk about apps, we have multiple apps connection.

00:01:04.900 --> 00:01:11.800
You can connect it with popular apps like Adobe, Airtable, Booking.com, Canva, Spotify and more.

00:01:12.780 --> 00:01:15.600
Now let us look at OpenAI Codex.

00:01:16.600 --> 00:01:19.480
Codex is an AI software engineering agent.

00:01:20.100 --> 00:01:25.100
It helps developers write, understand, change, test and ship code easily.

00:01:25.100 --> 00:01:29.100
It is not just a simple chatbot that only answers questions.

00:01:29.100 --> 00:01:34.100
It works directly with your project files and helps with the whole repository structure

00:01:34.100 --> 00:01:39.100
and can make the changes, run commands and assists with development cycles.

00:01:39.100 --> 00:01:43.100
It gives developers real engineering results.

00:01:43.100 --> 00:01:48.100
Codex is also inside ChatGPT, so you can use it directly.

00:01:48.100 --> 00:01:52.100
There is a specific app for Codex, and you can download it for Windows.

00:01:53.100 --> 00:02:02.100
We will see how Codex makes real engineering work faster, from planning and building the features, to fixing and releases and cross-checking.

00:02:03.100 --> 00:02:08.100
There is also a command line interface, or CLI, on GitHub for Codex.

00:02:09.100 --> 00:02:15.100
CLI means Command Line Interface. It is a text-based interface used to talk to software and computers.

00:02:15.100 --> 00:02:21.340
Instead of clicking buttons with a mouse on visual icons, you type text commands and the

00:02:21.340 --> 00:02:26.740
text-based user interface used to interact with the software, operating system and on

00:02:26.740 --> 00:02:31.560
your keyboard instead of using a mouse to click on visual items and press enter to make

00:02:31.560 --> 00:02:32.560
them work.

00:02:32.560 --> 00:02:35.980
We will learn how to use this CLI.

00:02:35.980 --> 00:02:41.480
Codex helps what a developer wants to do and turns it into engineering output.

00:02:41.480 --> 00:02:47.380
You can describe a bug or a new feature, test environment, documentation, task, in natural

00:02:47.380 --> 00:02:49.500
language.

00:02:49.500 --> 00:02:54.860
Codex can analyse the database identifying files, proposed changes and generate limitation

00:02:54.860 --> 00:02:56.420
steps.

00:02:56.420 --> 00:03:03.100
This makes it useful not only for the writer but also for navigating unfamiliar systemd.

00:03:03.100 --> 00:03:05.560
Here we have codex discussion.

00:03:05.560 --> 00:03:11.460
In this course we will talk about daily development, prompting, making agents and using codex to

00:03:11.460 --> 00:03:17.460
for a long time. We will cover all of these important topics together.

00:03:18.580 --> 00:03:24.460
So, moving on, the next critical discussion is primarily related to exactly

00:03:24.460 --> 00:03:30.220
how we are going to securely install codecs on our machine. First, well before

00:03:30.220 --> 00:03:34.580
actually installing it anywhere else, we will practically use the standard

00:03:34.580 --> 00:03:39.420
command-line interface to get things started. But right before that specific

00:03:39.420 --> 00:03:44.800
step, we can smoothly download the dedicated version specifically meant for Windows operating

00:03:44.800 --> 00:03:51.860
systems. Now, I already have the necessary Codex installer fully ready to go here. I

00:03:51.860 --> 00:03:57.840
simply open up the main system downloads folder right now. Then, I firmly run the executable

00:03:57.840 --> 00:04:03.800
installer directly as a system administrator. The core software immediately starts to install

00:04:03.800 --> 00:04:10.520
itself smoothly. Simultaneously, the Microsoft Store seamlessly begins its essential download

00:04:10.520 --> 00:04:17.360
process. Finally, when the entire download completely finishes, Codex will successfully

00:04:17.360 --> 00:04:23.580
run. Interestingly, we can certainly also manage to install it safely across multiple

00:04:23.580 --> 00:04:29.380
different computer systems. As we smoothly scroll further down the main page, you will

00:04:29.380 --> 00:04:34.720
clearly see three distinct setup options presented. The very first one is the

00:04:34.720 --> 00:04:40.440
standard standalone app. If we really want to use a code editor we can install it

00:04:40.440 --> 00:04:46.000
directly within our preferred IDE. Fortunately we already have Visual Studio

00:04:46.000 --> 00:04:52.780
code fully set up. Right inside VS Code a highly helpful AI is fully available. It

00:04:52.780 --> 00:04:59.260
is completely automated and we can easily use various models right here. To

00:04:59.260 --> 00:05:05.540
To successfully add this to our daily workflow, we simply need to install it in VS Code.

00:05:05.540 --> 00:05:10.820
We securely click Allow in VS Code and Codex will seamlessly open.

00:05:10.820 --> 00:05:16.980
Essentially, it is OpenAI's powerful coding agent that constantly works with you.

00:05:16.980 --> 00:05:24.900
It is fully included in ChatGPT+, Pro, Business, Education and Enterprise plans.

00:05:24.900 --> 00:05:31.900
First and foremost we absolutely must carefully check our specific ChatGPT subscription plan.

00:05:31.900 --> 00:05:36.580
I will officially open up the ChatGPT interface right now.

00:05:36.580 --> 00:05:42.300
As you can clearly see, we currently have the Plus version fully activated.

00:05:42.300 --> 00:05:47.500
Looking closely in the dedicated upgrade plan section, you clearly see our active billing

00:05:47.500 --> 00:05:48.940
plan.

00:05:48.940 --> 00:05:52.340
It is indeed the standard Plus plan.

00:05:52.340 --> 00:05:58.460
This essentially means all our ongoing coding work is completely safe and secure.

00:05:58.460 --> 00:06:01.400
Codex is fully available to use today.

00:06:01.400 --> 00:06:06.380
The strictly required language model is situated right here.

00:06:06.380 --> 00:06:12.500
Moving back into VS Code, we will effectively start the complete software installation.

00:06:12.500 --> 00:06:16.180
It securely installs just like a standard web extension.

00:06:16.180 --> 00:06:20.840
First, we smoothly pair it directly with Codex.

00:06:20.840 --> 00:06:27.620
We basically add Codex as a dedicated side panel within VS Code to seamlessly chat, intuitively

00:06:27.620 --> 00:06:31.460
edit and carefully check all our changes.

00:06:31.460 --> 00:06:37.620
Then, we can confidently use Codex directly in the cloud, sending massive jobs straight

00:06:37.620 --> 00:06:39.300
to it.

00:06:39.300 --> 00:06:44.740
Moving gracefully to the very next step, we simply need to safely sign in using our primary

00:06:44.740 --> 00:06:47.940
ChatGPT account credentials.

00:06:47.940 --> 00:06:53.320
Once fully authenticated, our main application will automatically install directly into the

00:06:53.320 --> 00:06:54.320
workspace.

00:06:54.320 --> 00:07:00.800
Now, the third available setup option is to actually install this directly inside our

00:07:00.800 --> 00:07:03.000
system terminal.

00:07:03.000 --> 00:07:09.900
For this specific method, just look closely at the Keep going in the terminal prompt section.

00:07:09.900 --> 00:07:14.320
We carefully copy this exact command string to our clipboard.

00:07:14.320 --> 00:07:21.360
Following that, we explicitly open up the system command prompt, making sure to run it strictly as an administrator.

00:07:22.320 --> 00:07:25.600
The Windows PowerShell interface naturally opens up.

00:07:26.660 --> 00:07:33.820
Within PowerShell itself, we formally install the OpenAI Codex tool utilizing the NPM Package Manager.

00:07:34.680 --> 00:07:39.360
Naturally, it will definitely take a little bit of time to fully install properly.

00:07:39.360 --> 00:07:44.860
The underlying system will sequentially gather necessary data in a much better way.

00:07:44.860 --> 00:07:49.360
Codex is actively installing and we have our app ready.

00:07:49.360 --> 00:07:52.360
Now we go to settings.

00:07:52.360 --> 00:07:57.360
We purposefully open the main application settings directly from the main dashboard.

00:08:00.603 --> 00:08:04.583
settings menu there are actually many different customisable options

00:08:04.583 --> 00:08:10.183
available. I specifically navigate over to the appearance tab in order to make

00:08:10.183 --> 00:08:15.803
some visual interface changes. First, I completely change the overall display

00:08:15.803 --> 00:08:22.843
theme to a comfortable dark mode. Next, I noticeably increase the base system UI

00:08:22.843 --> 00:08:28.783
size for better visibility. We then carefully choose our preferred font

00:08:28.783 --> 00:08:34.643
style and slightly adjust the visual contrast. Initially, I confidently write

00:08:34.643 --> 00:08:42.163
in 32 for the primary font size, however upon seeing it, 32 is admittedly just a bit too

00:08:42.163 --> 00:08:50.443
big for my screen. So I quickly change it down to exactly 24. Honestly, 24 is a genuinely

00:08:50.443 --> 00:08:57.643
comfortable size for long coding sessions. For the dedicated code font, we firmly use

00:08:57.643 --> 00:09:06.183
size 20. Moving on, we strategically turn off the reduce motion option. We ensure we

00:09:06.183 --> 00:09:12.923
use standard pointer cursors and gently lower the screen contrast. Everything is working

00:09:12.923 --> 00:09:20.103
well. Honestly, the overall reading experience is just so much better right now. Before we

00:09:20.103 --> 00:09:25.883
made those crucial visual tweaks, the default text font was incredibly small and honestly

00:09:25.883 --> 00:09:31.523
hard to read. We absolutely had to step in and make the font significantly bigger for

00:09:31.523 --> 00:09:39.203
basic clarity. I truly believe that 24 and 20 are excellent, highly optimized sizes for

00:09:39.203 --> 00:09:42.483
our daily coding tasks.

00:09:42.483 --> 00:09:48.063
Now if we quickly navigate over to the General Configuration Settings menu, we can clearly

00:09:48.063 --> 00:09:54.403
see multiple distinct operational modes available to choose from. I promise that I will carefully

00:09:54.403 --> 00:09:59.603
explain all of these specific working modes in much greater detail a little bit later on.

00:10:00.603 --> 00:10:04.763
Right now, all our required system packages are successfully installed.

00:10:05.503 --> 00:10:10.163
The powerful OpenAI codex itself is completely installed.

00:10:11.103 --> 00:10:15.223
Now, we just essentially need to forcefully run it one more time.

00:10:16.183 --> 00:10:19.843
I smoothly tab back over to the chat GPT window.

00:10:19.843 --> 00:10:23.723
I explicitly type out and clearly ask.

00:10:24.443 --> 00:10:26.623
I have basically run this command in the terminal.

00:10:27.343 --> 00:10:29.043
What do I do next to start it?

00:10:30.163 --> 00:10:35.903
We will now officially start the require process right here within our local system terminal.

00:10:36.763 --> 00:10:40.303
The entire background installation procedure is completely finished.

00:10:41.123 --> 00:10:46.743
It successfully managed to add two vital software packages in just about 36 seconds total.

00:10:46.743 --> 00:10:53.743
The software carefully checks the current NPM installation status alongside the available AI models.

00:10:53.743 --> 00:10:58.743
First and foremost, we must verify the active codex version.

00:10:58.743 --> 00:11:03.743
I simply type NPM codex directly into the prompt.

00:11:03.743 --> 00:11:10.743
The resulting codex CLI version currently shows up as 0.139.0.

00:11:10.743 --> 00:11:15.743
Next, we actively run codex so we can finally start to code.

00:11:15.743 --> 00:11:22.903
to code. We type codex right into the system environment. A brand new security message

00:11:22.903 --> 00:11:29.663
suddenly appears on the screen. It clearly asks, do you currently trust the exact contents

00:11:29.663 --> 00:11:36.203
of this specific directory? Working directly with untrusted contents definitely carries

00:11:36.203 --> 00:11:43.063
inherent security risks or potential prompt injections. Trusting that directory directly

00:11:43.063 --> 00:11:46.663
allows for reading local configuration settings.

00:11:46.663 --> 00:11:50.903
I confidently click yes and smoothly continue.

00:11:50.903 --> 00:11:54.583
After successfully getting that required yes confirmation,

00:11:54.583 --> 00:11:59.223
we now finally have our direct working option ready to go.

00:11:59.223 --> 00:12:04.303
We have the full power of the OpenAI codex at our fingertips.

00:12:04.303 --> 00:12:10.143
Our specifically selected AI model is currently GPT 5.5.

00:12:10.143 --> 00:12:15.823
Our active working directory is listed safely as System32.

00:12:15.823 --> 00:12:20.943
We can comfortably make direct code changes right here in this space.

00:12:20.943 --> 00:12:25.103
If I quickly send over a very simple introductory message,

00:12:25.103 --> 00:12:29.103
it impressively replies back almost automatically.

00:12:29.103 --> 00:12:31.023
I simply write out,

00:12:31.023 --> 00:12:36.783
can you explicitly help me in generating some basic HTML code?

00:12:36.783 --> 00:12:40.183
It quickly gives a remarkably short, concise response.

00:12:41.183 --> 00:12:43.883
It plainly says, yes, absolutely.

00:12:44.843 --> 00:12:50.723
Just tell me exactly what you want the final HTML page to do, or what you want it to look like.

00:12:51.843 --> 00:12:55.143
Paste any existing code snippets you might already have.

00:12:55.143 --> 00:13:02.803
If you happen to start entirely from scratch, I can easily create a simple HTML framework for you.

00:13:03.843 --> 00:13:05.383
Our coding journey begins.

00:13:05.383 --> 00:13:08.383
I press Ctrl C to pause.

00:13:09.243 --> 00:13:10.343
It shows the response.

00:13:11.403 --> 00:13:15.823
The interface clearly displays our complete token usage statistics right on the screen.

00:13:16.743 --> 00:13:22.563
The grand total comes out to exactly 7,939 tokens used.

00:13:23.743 --> 00:13:28.983
The initial input strictly accounted for 7,881 tokens.

00:13:29.663 --> 00:13:34.683
Meanwhile, the generated output was a remarkably short 58 tokens.

00:13:35.383 --> 00:13:41.383
To seamlessly continue this exact same chat session, we carefully copy the provided resume

00:13:41.383 --> 00:13:42.383
command.

00:13:42.383 --> 00:13:47.383
I smoothly paste that specific command right back in here.

00:13:47.383 --> 00:13:51.883
Instantly, the previous conversation thread beautifully continues right where we left

00:13:51.883 --> 00:13:52.883
off.

00:13:52.883 --> 00:13:58.943
If I suddenly decide that I want to completely change the underlying AI model, we currently

00:13:58.943 --> 00:14:02.823
have three distinct options available.

00:14:02.823 --> 00:14:09.043
Next is GPT 5.5, which is essentially the frontier model specifically built for complex

00:14:09.043 --> 00:14:11.683
coding tasks.

00:14:11.683 --> 00:14:19.543
Next is GPT 5.4, the strongest overall model strictly meant for everyday standard coding.

00:14:19.543 --> 00:14:26.243
Finally, we have the incredibly lightweight GPT 5.4 mini.

00:14:26.243 --> 00:14:30.863
We also have very handy slash commands completely ready to use.

00:14:30.863 --> 00:14:35.143
we will clearly show exactly how to effectively use them moving forward.

00:14:35.143 --> 00:14:38.823
Let's use slash commands.

00:14:38.823 --> 00:14:44.483
When I proactively type out a forward slash, Codex immediately shows a complete, highly

00:14:44.483 --> 00:14:48.023
detailed working menu of commands.

00:14:48.023 --> 00:14:53.403
First and foremost, we can fully configure how Codex strictly operates.

00:14:53.403 --> 00:14:56.983
We have the primary model selection option available.

00:14:56.983 --> 00:15:01.563
We also have the specific fast option explicitly listed.

00:15:01.563 --> 00:15:08.963
We have the IDE integration, to easily include currently open files and broader context.

00:15:08.963 --> 00:15:14.683
We actively have detail permissions to precisely choose exactly what codecs can or cannot do

00:15:14.683 --> 00:15:16.823
safely.

00:15:16.823 --> 00:15:23.143
We have dedicated key maps specifically designed for setting custom keyboard shortcuts.

00:15:23.143 --> 00:15:28.183
We have Vim mode strictly intended for our main code composer.

00:15:28.183 --> 00:15:32.423
We logically have the Sandbox Add to Directory feature ready.

00:15:32.423 --> 00:15:37.163
Finally, we have the Experimental Feature section.

00:15:37.163 --> 00:15:43.823
I intentionally select the very first configuration option to explore the available models.

00:15:43.823 --> 00:15:49.263
I ultimately choose the GPT 5.4 Mini variant.

00:15:49.263 --> 00:15:53.483
Now we selectively choose the preferred reasoning level.

00:15:53.483 --> 00:15:57.423
We specifically select low reasoning instead of the standard medium.

00:15:58.702 --> 00:16:02.802
We can carefully view current IDE sessions and files.

00:16:02.802 --> 00:16:06.462
Next, we review permissions.

00:16:06.462 --> 00:16:11.162
There are several highly specific model permissions carefully listed here.

00:16:11.162 --> 00:16:17.082
The Read Only setting strictly means that Codex can only safely read active files located

00:16:17.082 --> 00:16:20.002
within the current workspace environment.

00:16:20.002 --> 00:16:25.342
It absolutely requires your direct manual approval before it can ever attempt to edit

00:16:25.342 --> 00:16:29.822
files or directly access the live internet.

00:16:29.822 --> 00:16:35.262
The Ask for Approval setting actually serves as the standard default mode, where Codex

00:16:35.262 --> 00:16:41.562
can seamlessly run, read or even edit files inside the current workspace and fully read

00:16:41.562 --> 00:16:48.562
the active command prompt. Still, explicit manual approval is completely required to

00:16:48.562 --> 00:16:55.622
permanently edit files or access the internet. Approved for me intelligently only asks for

00:16:55.622 --> 00:17:02.782
explicit permission when it encounters potentially unsafe system actions. Full access simply

00:17:02.782 --> 00:17:08.862
means Codex can freely edit files far outside the designated workspace and easily access

00:17:08.862 --> 00:17:15.962
the internet without ever asking for prior approval. Exercise extreme caution and ask

00:17:15.962 --> 00:17:24.242
vital questions when using this. I explicitly choose the Approve for me setting. Our updated

00:17:24.242 --> 00:17:31.342
permissions are cleanly applied. I press Enter and transition to the Keymap configuration.

00:17:31.342 --> 00:17:38.282
In Keymap we have our transcript, external editor, clear terminal and more options.

00:17:38.282 --> 00:17:44.122
We practically have multiple distinct configuration options readily available right here, alongside

00:17:44.122 --> 00:17:48.562
some incredibly useful direct operational options.

00:17:48.562 --> 00:17:53.962
What we can actually do here is utilise the basic left and right keyboard arrow keys to

00:17:53.962 --> 00:17:57.122
smoothly navigate and group items.

00:17:57.122 --> 00:18:04.082
We firmly use the Enter key whenever we strictly need to modify or edit an existing shortcut.

00:18:04.082 --> 00:18:10.282
We smartly use the star symbol strictly for creating completely custom shortcuts, the

00:18:10.282 --> 00:18:16.142
dash symbol to quickly unbind an active key, and the Escape key to easily close out the

00:18:16.142 --> 00:18:18.402
menu entirely.

00:18:18.402 --> 00:18:24.122
I simply press Escape right now to smoothly go back to the previous screen.

00:18:24.122 --> 00:18:29.082
Right after successfully configuring our system permissions, we logically have our custom key

00:18:29.082 --> 00:18:32.362
maps fully sorted out.

00:18:32.362 --> 00:18:36.942
Next up, we carefully review our active system approvals.

00:18:36.942 --> 00:18:42.042
You can transparently see absolutely all the recent system changes we manually made right

00:18:42.042 --> 00:18:43.862
here.

00:18:43.862 --> 00:18:48.422
We actually changed our primary AI model twice today.

00:18:48.422 --> 00:18:52.582
We closely reviewed the IDE context settings.

00:18:52.582 --> 00:18:57.522
We officially updated our security permissions to Approve for me.

00:18:57.522 --> 00:19:00.882
Finally, I press Control-C.

00:19:00.882 --> 00:19:06.302
Executing that specific command officially closes out the active chat session entirely.

00:19:06.302 --> 00:19:12.722
It is crucial to note that this specific underlying configuration genuinely remains the exact same

00:19:12.722 --> 00:19:16.902
across every single linked application environment.

00:19:16.902 --> 00:19:22.262
Thankfully, the powerful Codex tool is readily available right here too.

00:19:22.262 --> 00:19:26.422
We can practically do so many different amazing things with it.

00:19:26.422 --> 00:19:32.182
If we smartly decide to switch over to the exclusive pre-release software version, absolutely

00:19:32.182 --> 00:19:37.082
all the newest experimental features become instantly available.

00:19:37.082 --> 00:19:43.342
I am going to intentionally open up a brand new dedicated project folder officially named

00:19:43.342 --> 00:19:46.342
Metabrains for our work.

00:19:46.342 --> 00:19:53.342
We carefully select this exact folder directory and smoothly open up our fresh chat interface.

00:19:53.342 --> 00:19:58.242
I explicitly confirm that I fully trust the verified authors operating in this specific

00:19:58.242 --> 00:20:00.202
environment.

00:20:00.202 --> 00:20:03.902
I smoothly close this secondary pop-up window.

00:20:03.902 --> 00:20:10.762
I promptly open up a brand new code file appropriately named index.html.

00:20:10.762 --> 00:20:16.102
You can distinctly see the familiar codex logo right inside this document.

00:20:16.102 --> 00:20:22.362
We can now finally start to actively write out our core underlying code snippets.

00:20:22.362 --> 00:20:28.742
The generated Codex AI response will seamlessly appear right here on the interface.

00:20:28.742 --> 00:20:34.782
We will be able to clearly see our active IDE connection, the linked source repository,

00:20:34.782 --> 00:20:41.802
the comprehensive onboarding bug log and of course, our preferred dark mode visual theme.

00:20:41.802 --> 00:20:47.582
We will consistently get highly accurate direct responses moving forward.

00:20:47.582 --> 00:20:53.362
Now we need to take a very close look at our overall system usage metrics.

00:20:53.362 --> 00:20:58.082
I purposefully navigate back over to the main settings page.

00:20:58.082 --> 00:21:03.982
The exact same user account is actively being used uniformly everywhere.

00:21:03.982 --> 00:21:09.022
We can easily modify our deeper codec software settings right here.

00:21:09.022 --> 00:21:16.662
You clearly see broad configurations, custom personalisation, advanced MCP servers, webhook

00:21:16.662 --> 00:21:21.762
integrations, system usage and active billing.

00:21:21.762 --> 00:21:27.422
We absolutely need to check these panels timely and consistently to perfectly know exactly

00:21:27.422 --> 00:21:31.542
how we are efficiently carrying all these things forward.

00:21:31.542 --> 00:21:34.602
We can chat and utilise commands.

00:21:34.602 --> 00:21:37.102
We can switch models and connect apps.

00:21:37.102 --> 00:21:41.882
Inside the primary settings menu, we prominently have the visual appearance and core system

00:21:41.882 --> 00:21:45.022
configuration tabs right at the top.

00:21:45.022 --> 00:21:50.982
We absolutely also have detail personalization settings, custom keyboard shortcuts, active

00:21:50.982 --> 00:21:54.922
usage limits and standard billing information.

00:21:54.922 --> 00:22:02.202
The general designated application usage limit strictly caps out at exactly 5 hours.

00:22:02.202 --> 00:22:05.842
we happily have a massive 99% of that time left available.

00:22:06.782 --> 00:22:11.862
The broader weekly limit currently shows 100% completely left over.

00:22:12.982 --> 00:22:16.762
We have successfully expanded our overall codex usage capabilities

00:22:16.762 --> 00:22:21.342
alongside the powerful GPT 5.5 deep thinking mode.

00:22:22.482 --> 00:22:25.882
We can effortlessly purchase an additional credit balance whenever needed.

00:22:27.242 --> 00:22:29.702
Supported system integrations proudly include

00:22:29.702 --> 00:22:31.502
seamless browser connections,

00:22:31.502 --> 00:22:36.502
broad computer use permissions and robust MCP servers.

00:22:36.502 --> 00:22:43.502
The core coding section beautifully includes active webhooks, secure remote connections,

00:22:43.502 --> 00:22:49.502
complete Git source control, safe isolated environments and managed work trees.

00:22:49.502 --> 00:22:54.502
Our foundational setup phase is now entirely complete.

00:22:54.502 --> 00:23:00.502
The highly anticipated direct usage strictly begins right now.

00:23:01.502 --> 00:23:09.542
We will now efficiently set up highly secure cloud-based development environments right here in this specific module.

00:23:10.502 --> 00:23:15.802
You probably remember that we previously ran our Codex agent directly here on the local machine.

00:23:17.082 --> 00:23:22.242
Absolutely all of our core operational functions were safely contained directly inside it.

00:23:22.242 --> 00:23:28.802
Now, however, we will purposefully run our advanced cloud-based development environment

00:23:28.802 --> 00:23:32.902
securely integrated directly within our main codec setup.

00:23:34.002 --> 00:23:38.702
First things first, I will quickly navigate back over to the main settings panel

00:23:38.702 --> 00:23:42.542
and intentionally make the system font slightly smaller for better viewing.

00:23:43.662 --> 00:23:46.802
We gracefully go over to the visual appearance tab

00:23:46.802 --> 00:23:52.302
and actively change the primary tech size down from 24 to precisely 20.

00:23:53.242 --> 00:23:57.462
Now, the overall tech size is just so much better and more manageable.

00:23:58.854 --> 00:24:04.434
I will clearly explain to you generally what these advanced cloud-based development environments actually are.

00:24:05.254 --> 00:24:09.414
We will deeply understand this entire concept right here today.

00:24:09.414 --> 00:24:18.054
You absolutely should know right up front that this is essentially a pre-configured, entirely remotely hosted software workspace.

00:24:19.094 --> 00:24:24.954
It actively contains your preferred IDE alongside all your necessary background tools.

00:24:26.214 --> 00:24:33.894
Modern developers can effortlessly code, rigorously test and smoothly deploy complex software straight from the web browser.

00:24:33.894 --> 00:24:41.334
The acronym CDE specifically stands for Cloud Development Environment.

00:24:42.814 --> 00:24:46.834
It effectively solves that highly frustrating, age-old problem

00:24:46.834 --> 00:24:53.154
when a specific piece of code miraculously only works on one specific person's local computer.

00:24:54.574 --> 00:24:58.954
Brand new software engineers can easily start actively coding in mere minutes.

00:25:00.074 --> 00:25:01.934
This is our dedicated cloud system.

00:25:01.934 --> 00:25:08.114
Now, let's take a moment to talk about Codex itself.

00:25:08.114 --> 00:25:14.254
Codex fundamentally has some massive, undeniably big advantages here.

00:25:14.254 --> 00:25:21.214
Codex genuinely works absolute best when it can safely access the entire full code repository.

00:25:21.214 --> 00:25:24.974
It impressively also has powerful built-in deployment tools.

00:25:24.974 --> 00:25:30.974
A cloud environment safely lets Codex seamlessly talk directly to remote code repositories.

00:25:30.974 --> 00:25:37.974
It can reliably run terminal commands, execute unit tests and thoroughly check projects.

00:25:37.974 --> 00:25:41.974
It safely makes automated code changes.

00:25:41.974 --> 00:25:46.974
The biggest overall benefit is undeniable, absolute consistency.

00:25:46.974 --> 00:25:50.974
In significantly older traditional local development environments,

00:25:50.974 --> 00:25:55.974
various developers constantly use completely different underlying operating systems

00:25:55.974 --> 00:25:58.974
and vastly different local machine settings.

00:25:58.974 --> 00:26:05.974
settings. This inherently creates the infamous, frustrating, well, it perfectly works on my

00:26:05.974 --> 00:26:12.134
machine problem. Modern, streamlined cloud environments completely remove these highly

00:26:12.134 --> 00:26:19.094
annoying problems entirely. Absolutely everything that we actively do right here, for example,

00:26:19.094 --> 00:26:25.914
the previously pinned chat log specifically about making a functional calculator application,

00:26:25.914 --> 00:26:32.334
all our deep technical discussions are safely stored permanently in this robust cloud system.

00:26:33.494 --> 00:26:39.374
We can effortlessly and rapidly review our collective past work right here at any given time.

00:26:40.534 --> 00:26:45.394
Other incredibly massive benefits strictly include nearly instant team onboarding,

00:26:46.014 --> 00:26:52.334
highly consistent underlying tool setups, absolute hardware independence and reliable

00:26:52.334 --> 00:26:54.274
long-term session persistence.

00:26:54.274 --> 00:27:01.474
Now, moving forward, we will thoughtfully choose a specific cloud development platform to use.

00:27:01.474 --> 00:27:05.874
I will happily show you some excellent real-world examples shortly.

00:27:07.134 --> 00:27:11.894
First and foremost, we will take a very close look at GitHub Codespaces today.

00:27:13.014 --> 00:27:17.894
It is a remarkably secure, highly robust cloud development environment used by many.

00:27:17.894 --> 00:27:24.914
If we genuinely do not want to use this specific one, we can alternatively utilise Gitpod.

00:27:25.874 --> 00:27:29.914
We actually use the Gitpod platform quite a lot in our daily workflows.

00:27:30.994 --> 00:27:35.934
It is a fantastic, strictly on-demand, highly scalable development environment.

00:27:36.934 --> 00:27:44.994
For massively big enterprise companies, we consistently have the AWS Cloud9 infrastructure safely available.

00:27:47.894 --> 00:27:50.894
for our larger, more complex coding tasks.

00:27:50.894 --> 00:27:57.894
It is basically a fully complete cloud-based integration development environment from Amazon.

00:27:57.894 --> 00:28:03.894
It is truly a complete, fully featured IDE right in your browser.

00:28:03.894 --> 00:28:11.894
We can effortlessly write, smoothly run and quickly fix our complex code directly inside it.

00:28:11.894 --> 00:28:15.894
These are a few older, very solid examples.

00:28:15.894 --> 00:28:24.634
Now, I will explicitly search the web to see if Codex itself is officially classified as a cloud-based development environment.

00:28:25.434 --> 00:28:27.934
It confidently says, yes.

00:28:29.294 --> 00:28:36.094
Codex, created by OpenAI, is officially a cloud-based AI software engineering agent.

00:28:36.094 --> 00:28:49.814
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.

00:28:50.754 --> 00:29:02.974
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.

00:29:02.974 --> 00:29:09.354
I strongly suggest that we consistently use this incredible tool to intentionally make

00:29:09.354 --> 00:29:14.074
a highly secure, deeply isolated remote workspace.

00:29:14.074 --> 00:29:19.114
There are honestly quite a lot of highly technical back-end things actively running here.

00:29:19.114 --> 00:29:23.494
I will quickly hop back and change the UI font size once again, because it simply does

00:29:23.494 --> 00:29:26.814
not look visually right on this display.

00:29:26.814 --> 00:29:30.974
I will purposefully make it just a little bit bigger, strictly for the sake of our video

00:29:30.974 --> 00:29:38.454
course clarity. Now we simply go straight back into our main codex application. Everything

00:29:38.454 --> 00:29:43.834
visually looks exceptionally good now. We have our advanced reasoning engine and other

00:29:43.834 --> 00:29:50.534
vital backend things running. We will take a complete comprehensive look at this next.

00:29:50.534 --> 00:29:55.674
This perfectly shows how we put things into a complete cloud-based setup.

00:29:55.674 --> 00:30:04.134
Now, moving smoothly forward, our very next crucial task is to securely connect our remote

00:30:04.134 --> 00:30:06.974
GitHub repositories directly.

00:30:06.974 --> 00:30:11.714
We absolutely need to establish a solid link to our GitHub account directly within the

00:30:11.714 --> 00:30:14.514
main codec system.

00:30:14.514 --> 00:30:20.034
Inside our primary GitHub platform, a tremendous amount of distinct configurable options are

00:30:20.034 --> 00:30:22.674
always readily available.

00:30:22.674 --> 00:30:27.174
You can clearly see the active status regarding the connection with GitHub right here on the

00:30:27.174 --> 00:30:29.174
interface.

00:30:29.174 --> 00:30:34.794
If I cautiously go over to the main settings panel, specifically looking closely in the

00:30:34.794 --> 00:30:41.154
Connections option area, there is currently absolutely no active connection established.

00:30:41.154 --> 00:30:46.574
The standard SSH and secure Git credential options similarly show that there are simply

00:30:46.574 --> 00:30:49.234
no active connections present.

00:30:49.234 --> 00:30:55.554
Furthermore, down in the Remote Servers and Local Browser tab, there is similarly no connection.

00:30:56.554 --> 00:31:02.274
In the Computer Use section, we can alternatively use the Google Chrome browser extension.

00:31:03.494 --> 00:31:09.914
So, our primary GitHub repository profile is clearly not effectively connected to the system just yet.

00:31:10.734 --> 00:31:14.114
I will intentionally just type out the specific query.

00:31:14.674 --> 00:31:18.034
Is GitHub firmly connected to Codex right now?

00:31:18.034 --> 00:31:22.494
to quickly see if we actually get a reassuring green verification tick.

00:31:23.394 --> 00:31:28.134
This built-in diagnostic tool will thoroughly check the back-end systems

00:31:28.134 --> 00:31:32.894
and explicitly tell us if our GitHub account is successfully connected or not.

00:31:34.294 --> 00:31:38.114
Simultaneously, I will efficiently search for the precise phrasing

00:31:38.114 --> 00:31:42.654
GitHub and official codex integration securely online.

00:31:42.654 --> 00:31:50.714
This highly powerful system connection can miraculously be added directly without any significant friction.

00:31:51.834 --> 00:31:56.314
It prominently includes highly advanced automated pull request code reviews,

00:31:56.974 --> 00:32:02.894
a dedicated co-pilot AI coding agent and deeply integrated GitHub workflow actions.

00:32:04.017 --> 00:32:10.297
We will comprehensively discuss absolutely all of these incredible back-end setup options in extreme detail.

00:32:10.917 --> 00:32:16.437
The diagnostic system now clearly shows that the official GitHub integration plugin

00:32:16.437 --> 00:32:21.117
is indeed fully available directly within the primary codex plugin section.

00:32:21.497 --> 00:32:25.357
But, unfortunately, this specific local workspace folder

00:32:25.357 --> 00:32:29.097
is actually not initialised as a valid Git repository right now.

00:32:29.757 --> 00:32:33.477
A brand new Git tracking folder is quickly being created in the background.

00:32:34.637 --> 00:32:39.097
Now, if we explicitly click the prominent plus button on the user interface,

00:32:39.097 --> 00:32:44.017
we can clearly see the GitHub icon safely listed in the available plugins directory.

00:32:44.017 --> 00:32:53.297
But we critically want to verify exactly which specific user account is currently connected directly to our active GitHub plugin extension.

00:32:54.017 --> 00:33:01.177
We currently cannot seem to find our primary GitHub profile, so we will manually initiate a deep search for it.

00:33:01.937 --> 00:33:07.837
When we effectively run the search, the official GitHub authentication app finally appears.

00:33:07.837 --> 00:33:16.817
The application safely requests broad permission to actively access repositories, track software issues and manage pull requests.

00:33:17.297 --> 00:33:20.377
But we have simply not fully connected it just yet.

00:33:21.197 --> 00:33:24.997
So we will proceed to log securely into our main GitHub account.

00:33:25.977 --> 00:33:30.957
This is our dedicated primary account explicitly named metabrains-del.

00:33:31.557 --> 00:33:36.457
It undeniably has many repositories and we have done a lot of work here.

00:33:36.457 --> 00:33:43.117
We will now meticulously connect this specific GitHub account directly to our active Codex

00:33:43.117 --> 00:33:45.517
system workspace.

00:33:45.517 --> 00:33:50.457
When I confidently click the connect button, it explicitly asks for final permission to

00:33:50.457 --> 00:33:53.877
securely connect to GitHub servers.

00:33:53.877 --> 00:33:59.897
It safely allows the underlying ChatGPT engine to carefully read our previous chats and stored

00:33:59.897 --> 00:34:05.877
memories to consistently give significantly better, context-aware answers.

00:34:05.877 --> 00:34:10.657
It clearly states that your deep personal privacy permissions are heavily respected,

00:34:10.657 --> 00:34:13.677
and you are always completely in control.

00:34:13.677 --> 00:34:19.057
It does warn that external connectors may possibly introduce some slight security risk.

00:34:19.057 --> 00:34:23.477
I will boldly open up our Direct GitHub Developer Dashboard.

00:34:23.477 --> 00:34:28.657
You can visually see that the secure GitHub app authorisation connection is actively starting

00:34:28.657 --> 00:34:30.557
in the background.

00:34:30.557 --> 00:34:36.277
Absolutely all our ongoing critical development work is safely housed right here.

00:34:36.277 --> 00:34:40.737
We will press firmly to continue onward to GitHub so we can comfortably go straight to

00:34:40.737 --> 00:34:43.237
our main profile account.

00:34:43.237 --> 00:34:47.337
It will naturally take a little bit of processing time to fully connect.

00:34:47.337 --> 00:34:49.717
A basic connection will form.

00:34:49.717 --> 00:34:51.757
You can see it is connected.

00:34:51.757 --> 00:34:53.237
I open plugins again.

00:34:53.237 --> 00:34:58.237
Now you will actively see that our dedicated GitHub plugin is finally working precisely

00:34:58.237 --> 00:34:59.237
as intended.

00:34:59.237 --> 00:35:03.897
It smoothly works specifically because it is successfully connected to the backend.

00:35:04.777 --> 00:35:12.057
If it is ever mysteriously not connected, we can easily check our credentials again to see if we can actively reconnect it.

00:35:12.717 --> 00:35:19.097
We currently have our active user login, but unfortunately, adding the specific external link just failed.

00:35:20.197 --> 00:35:22.357
Why exactly did it suddenly fail here?

00:35:23.137 --> 00:35:28.037
We must remember that this is our specific ChatGPT Plus tier account.

00:35:28.037 --> 00:35:33.617
You absolutely must remember this vital detail because it impacts our permissions.

00:35:34.557 --> 00:35:39.937
Now we will purposefully open up the completely alternative ChatGPT account instead.

00:35:40.717 --> 00:35:47.777
We will securely bring our dedicated Michael DuPont user account right here into the active workspace to try again.

00:35:48.717 --> 00:35:54.017
Our premium ChatGPT plus subscription tier is fully available right here.

00:35:54.017 --> 00:35:59.517
Now we will carefully attempt to securely connect the integration system once again.

00:35:59.517 --> 00:36:04.917
It will systematically connect our main chat GPT interface to the repository.

00:36:04.917 --> 00:36:14.217
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.

00:36:14.217 --> 00:36:20.417
We obviously also have the standard option to immediately disconnect the authorization any time.

00:36:20.417 --> 00:36:26.657
We will gracefully proceed straight directly over to the main GitHub authorisation portal.

00:36:27.857 --> 00:36:33.137
Now it will successfully build the required connection directly in our correct targeted application.

00:36:34.457 --> 00:36:38.597
It strictly demands highly secure multi-factor user authentication.

00:36:39.877 --> 00:36:44.177
We will comfortably utilise the standard Authenticator mobile app to handle this.

00:36:44.677 --> 00:36:50.317
The mobile Authenticator app will swiftly finish processing our deep security verification.

00:36:50.417 --> 00:36:57.417
Now you can clearly see that our primary GitHub profile is finally directly connected perfectly.

00:36:57.417 --> 00:37:02.417
I will quickly pivot back over to our main codex interface.

00:37:02.417 --> 00:37:08.417
You can clearly see that our secure software link is now fully established and solidly connected.

00:37:08.417 --> 00:37:13.417
If we carefully look directly at our active system plugins list right now,

00:37:13.417 --> 00:37:19.417
absolutely all our relevant GitHub integration tasks have delightfully started showing up directly in there.

00:37:19.417 --> 00:37:25.417
We will smoothly navigate back over to our main chat terminal interface.

00:37:25.417 --> 00:37:33.417
You can very clearly see our dedicated GitHub functionality is directly added and fully available right there.

00:37:33.417 --> 00:37:41.417
We will quickly go back over to the plugins tab and our GitHub features will be permanently included in the active workflow loop.

00:37:41.417 --> 00:37:46.417
It will effortlessly come directly into our daily software development work.

00:37:46.417 --> 00:37:52.817
Ultimately, we have incredibly successfully added our robust Codex AI tool to perfectly

00:37:52.817 --> 00:37:58.657
sync with our remote GitHub code repositories.

00:37:58.657 --> 00:38:04.137
Moving logically to the very next crucial step, we will thoroughly talk about the highly

00:38:04.137 --> 00:38:08.857
specific agents.md configuration file.

00:38:08.857 --> 00:38:14.517
This incredibly important file is primarily used for organising massively big software

00:38:14.517 --> 00:38:19.797
development projects. We specifically utilise it whenever we happen to have

00:38:19.797 --> 00:38:25.617
many complex automated tasks or a full highly detailed business use case to

00:38:25.617 --> 00:38:31.017
carefully look at. I will intentionally open it up right here on the screen so

00:38:31.017 --> 00:38:35.137
you can clearly see exactly where these vital agent configuration files

00:38:35.137 --> 00:38:41.517
naturally come from and exactly where to easily find them. It will reliably give

00:38:41.517 --> 00:38:45.937
us the system response directly and accurately.

00:38:45.937 --> 00:38:52.717
The dedicated agents.md file immensely helps us to deeply inspect and standardise our overall

00:38:52.717 --> 00:38:55.237
project architecture.

00:38:55.237 --> 00:39:00.017
You can clearly see it actively looking deep inside our raw project files.

00:39:00.017 --> 00:39:06.837
Here, it explicitly states that the active workspace is entirely empty right now.

00:39:06.837 --> 00:39:11.477
There is absolutely no agents.md file found.

00:39:11.477 --> 00:39:17.357
It checked the temporary scratch space and verified there is no file.

00:39:17.357 --> 00:39:23.677
To successfully create one from scratch, we absolutely must make a brand new, correctly

00:39:23.677 --> 00:39:26.977
formatted Agents.md file.

00:39:26.977 --> 00:39:32.977
I will manually go ahead and create a brand new foundational file right here for you.

00:39:32.977 --> 00:39:39.117
This incredibly efficient way, we can consistently see absolutely all the necessary high level

00:39:39.117 --> 00:39:44.717
production details firmly embedded safely within this specific file.

00:39:44.717 --> 00:39:51.017
First, the core Structured Agents file is quickly drafted out.

00:39:51.017 --> 00:39:56.897
Right after that initial phase, we can comfortably make far more highly nuanced text changes

00:39:56.897 --> 00:39:58.437
to this preliminary draft.

00:39:59.778 --> 00:40:05.158
In this specific advanced technical setup, we usually really need to carefully check

00:40:05.158 --> 00:40:11.638
if our highly specific basic operational rules or distinct business use cases are actually

00:40:11.638 --> 00:40:13.918
working properly.

00:40:13.918 --> 00:40:18.698
successfully and directly created an excellent base foundational agent file

00:40:18.698 --> 00:40:25.258
right here for us. If we carefully review the generated file we can clearly see

00:40:25.258 --> 00:40:30.738
its intended core purpose. Besides the purpose there is a clear project

00:40:30.738 --> 00:40:37.698
overview. We also see a working agreement, a layout and editing rules. We can

00:40:37.698 --> 00:40:42.118
actively cross-check all of these fundamental operational rules precisely

00:40:42.118 --> 00:40:47.878
here in the document. I will also make sure to explicitly tell you exactly where

00:40:47.878 --> 00:40:53.698
this specialized configuration file is typically used. We consistently use the

00:40:53.698 --> 00:40:58.738
specialized agents.md file to effectively establish strict working

00:40:58.738 --> 00:41:04.998
boundaries and core rules for literally any AI agent operating in the workspace.

00:41:04.998 --> 00:41:10.198
There are basically no other bizarre tasks or unrelated work explicitly meant

00:41:10.198 --> 00:41:17.458
for it. Sometimes, unfortunately, we literally have to go deep down into our underlying operating

00:41:17.458 --> 00:41:24.958
system just to manually set up the complex agents.md file perfectly. This tedious manual

00:41:24.958 --> 00:41:30.958
process admittedly takes quite a lot of valuable development time. We essentially have to carefully

00:41:30.958 --> 00:41:37.138
look at so many different distinct things, like our strict project requirements, core team work

00:41:37.138 --> 00:41:44.418
ethics and several other highly detailed technical options. We absolutely need to fully know how to

00:41:44.418 --> 00:41:50.318
properly handle these nuanced things. But for massively big projects, we only deliberately

00:41:50.318 --> 00:41:58.178
include our basic setup requirements here. Moving right along, next we will deeply discuss exactly

00:41:58.178 --> 00:42:04.178
how to effectively use this incredibly vital agents.md file in standard practice.

00:42:04.178 --> 00:42:14.358
Deeply understanding this specific core concept is an undeniably very important foundational part of the entire development process

00:42:14.358 --> 00:42:23.358
We absolutely need to fully know exactly how to actively create the underlying file directly from absolute scratch

00:42:24.478 --> 00:42:30.738
Now we purposefully transition and move seamlessly right over to the very next important part

00:42:30.738 --> 00:42:42.558
We will fundamentally learn exactly how to appropriately handle highly complex things and deeply understand them right after actively creating the foundational file.

00:42:43.498 --> 00:42:48.898
This is fundamentally a highly special, deeply vital system instruction file.

00:42:49.898 --> 00:42:57.618
It consistently provides invaluable deep guidance and much needed environmental context directly for our automated work.

00:42:57.618 --> 00:43:05.158
It can absolutely also be used incredibly effectively, exactly like a traditional readme developer file.

00:43:06.298 --> 00:43:12.158
You might vividly remember that standard software developers constantly use structured readme files.

00:43:12.978 --> 00:43:15.998
In the exact same way, we can use this file.

00:43:15.998 --> 00:43:30.438
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.

00:43:31.158 --> 00:43:39.078
We can comfortably and securely include absolutely all of our strict foundational base development requirements firmly inside it.

00:43:39.658 --> 00:43:45.298
This proactive step will flawlessly kickstart our broader automation work immediately.

00:43:45.998 --> 00:43:52.238
I will gladly proceed to show you an excellent, highly structured example right now.

00:43:52.238 --> 00:43:57.998
I will purposely open up Microsoft Word or a standard blank doc text document.

00:43:57.998 --> 00:44:02.698
I am deliberately using a blank doc right now, strictly so we can comfortably start

00:44:02.698 --> 00:44:06.118
a fresh, entirely new, empty document.

00:44:06.118 --> 00:44:12.318
Here, you can very clearly see exactly what critical structural things are highly recommended

00:44:12.318 --> 00:44:13.878
and available.

00:44:13.878 --> 00:44:19.538
First, we logically have the high-level project overview section.

00:44:19.538 --> 00:44:24.878
This clearly tells us exactly what core deliverables we strictly need in the project.

00:44:24.878 --> 00:44:32.158
Next, we definitely have the strict team coding standards that we must absolutely follow.

00:44:32.158 --> 00:44:38.758
After that, we discuss repository structures, testing requirements, security rules and large-scale

00:44:38.758 --> 00:44:40.858
systems.

00:44:40.858 --> 00:44:46.138
We will practically use a fully functional, highly complete, overarching working system

00:44:46.138 --> 00:44:47.138
here.

00:44:47.138 --> 00:44:53.858
Our strictly prohibited, highly restricted system areas will absolutely also be meticulously

00:44:53.858 --> 00:44:57.898
explicitly listed right here for immense safety.

00:44:57.898 --> 00:45:04.858
Then, our highly nuanced, deeply specific primary AI operational instructions will be

00:45:04.858 --> 00:45:07.798
thoroughly included next.

00:45:07.798 --> 00:45:13.198
Right after all the comprehensive AI baseline instructions, we will seamlessly have all

00:45:13.198 --> 00:45:18.758
our broader, full-feature architectural options carefully documented.

00:45:18.758 --> 00:45:24.078
This is essentially exactly what we traditionally call a comprehensive, well-structured readme

00:45:24.078 --> 00:45:26.978
file in standard development.

00:45:26.978 --> 00:45:32.958
It practically has all our complete, strict baseline instructions deeply hard-coded and

00:45:32.958 --> 00:45:36.118
built directly right into it.

00:45:36.118 --> 00:45:41.758
After this section is successfully completed, the very next essential technical thing dynamically

00:45:41.758 --> 00:45:47.258
available is dealing with our sensitive back-end environment variables.

00:45:47.258 --> 00:45:53.298
We will deeply see precisely how we can effectively, securely manage these highly critical system

00:45:53.298 --> 00:45:55.718
environment variables.

00:45:55.718 --> 00:46:03.898
Now, our next incredibly critical technical discussion is primarily about handling robust

00:46:03.898 --> 00:46:11.578
backend environment variables. These are essentially highly dynamic, configurable key values operating

00:46:11.578 --> 00:46:17.418
in the background. We can actively store them either directly or indirectly deep within

00:46:17.418 --> 00:46:23.538
our underlying operating system infrastructure. We can comfortably and securely utilise them

00:46:23.538 --> 00:46:31.138
later for absolutely all of our other automated complex coding tasks. Usually, we deeply involve

00:46:31.138 --> 00:46:38.318
our complete, highly systematic overall workflow process directly here to explicitly see exactly

00:46:38.318 --> 00:46:44.118
how a full, robust software system is successfully constructed.

00:46:44.118 --> 00:46:49.498
These are highly dynamic back-end key values that are stored strictly and directly inside

00:46:49.498 --> 00:46:55.618
the native operating system, kept entirely safely outside of our vulnerable, raw source

00:46:55.618 --> 00:47:02.858
code files. They heavily detect and dictate precisely how the running process fundamentally

00:47:02.858 --> 00:47:09.918
behaves. This brilliant system effortlessly allows developers to incredibly safely store

00:47:09.918 --> 00:47:17.258
highly sensitive security credentials. What exactly are sensitive credentials? It is highly

00:47:17.258 --> 00:47:24.818
vital to see this clearly. If we fail to understand this, our work suffers. Sometimes developers

00:47:24.818 --> 00:47:30.258
are understandably incredibly afraid that their highly sensitive personal or corporate

00:47:30.258 --> 00:47:36.438
information will eventually accidentally leak to the dangerous public internet.

00:47:36.438 --> 00:47:39.838
Why exactly does this enormous fear exist?

00:47:39.838 --> 00:47:45.818
Basically, because our complete interconnected development environment inherently has some

00:47:45.818 --> 00:47:48.938
deeply guarded secrets.

00:47:48.938 --> 00:47:54.698
These highly confidential items definitely include things like private API keys, secure

00:47:54.698 --> 00:47:58.658
admin account usernames and highly encrypted user passwords.

00:47:59.801 --> 00:48:03.581
We absolutely have to carefully look closely at them and protect them.

00:48:04.661 --> 00:48:11.441
Now we officially pivot to selectively talk about the massive, overarching enterprise operational level.

00:48:11.441 --> 00:48:17.181
What exactly inherently happens operating at the massive enterprise scale level?

00:48:18.061 --> 00:48:23.661
Let us quickly intentionally open up a brand new, fresh, isolated chat window.

00:48:24.661 --> 00:48:30.061
At the highest enterprise level, actively managing profound structural secrets properly

00:48:30.061 --> 00:48:36.001
is absolutely critical for safely protecting tremendously sensitive proprietary information.

00:48:37.241 --> 00:48:40.841
Secrets routinely may include remote cloud access keys,

00:48:40.841 --> 00:48:47.841
massive database passwords, complex encryption keys, vital third-party API credentials,

00:48:48.641 --> 00:48:51.161
and various access authentication tokens.

00:48:52.521 --> 00:48:56.001
Handling environment variables securely with codecs is important.

00:48:56.481 --> 00:49:04.061
These specific, crucial security items are undeniably very important to actively manage appropriately right here.

00:49:04.061 --> 00:49:11.061
Usually, wildly different distinct deployment environments inherently fundamentally require

00:49:11.061 --> 00:49:14.281
completely different sets of unique configuration values.

00:49:15.501 --> 00:49:19.801
We can intelligently deploy and actively utilise them safely over there.

00:49:21.201 --> 00:49:28.321
Let me clearly tell you, whenever I actively try to perform a direct system search for standard environment variables,

00:49:28.321 --> 00:49:35.521
you immediately see our primary system environment variables are visibly available precisely right here.

00:49:36.521 --> 00:49:45.541
You will undeniably see that absolutely all of our current environment variables are entirely accessible and available literally right now.

00:49:46.821 --> 00:49:51.301
Sometimes it happens to merely be the static number of active system processors.

00:49:52.681 --> 00:49:56.481
Sometimes it is a highly confidential external API key.

00:49:56.481 --> 00:50:02.821
We can smoothly dive deep directly right into the back-end system variables menu,

00:50:03.701 --> 00:50:06.661
carefully enter the specific custom variable name

00:50:06.661 --> 00:50:12.241
and its corresponding strict value directly and permanently safely store it.

00:50:13.561 --> 00:50:19.461
So, the next time we run a use case, all variables are automatically set perfectly.

00:50:20.601 --> 00:50:25.961
How exactly is this properly handled inside a secure underlying database architecture?

00:50:26.481 --> 00:50:33.241
As you can visibly observe precisely here, located deep inside the primary configuration

00:50:33.241 --> 00:50:41.081
interface, we purposely actively include a dedicated corporate company database link.

00:50:41.081 --> 00:50:47.561
If there happens to clearly be a specific network port required, we firmly include it.

00:50:47.561 --> 00:50:53.241
If there explicitly is an overarching master application configuration requirement, we

00:50:53.241 --> 00:51:00.241
we safely add the core app environment variable alongside the specific designated app port.

00:51:00.241 --> 00:51:08.701
Secure, highly confidential API credentials will absolutely come directly right here.

00:51:08.701 --> 00:51:15.821
For one clear example, if we genuinely want to safely utilise an external OpenAI API authentication

00:51:15.821 --> 00:51:20.261
key, we securely do it precisely here.

00:51:20.261 --> 00:51:25.881
We can undoubtedly also clearly see secure encrypted payment gateway keys stored right

00:51:25.881 --> 00:51:26.881
here.

00:51:26.881 --> 00:51:33.401
Then, there are massive authentication backend settings designed purely to store multiple

00:51:33.401 --> 00:51:36.081
dynamic secrets.

00:51:36.081 --> 00:51:43.341
These environment variables brilliantly enable large organisations to safely manage app configurations.

00:51:43.341 --> 00:51:47.601
It prevents leaking sensitive information.

00:51:47.601 --> 00:51:54.481
handles keys safely too without hard coding. I will definitively also sincerely tell you

00:51:54.481 --> 00:51:59.821
that strict environment variables frankly may not initially actively seem incredibly

00:51:59.821 --> 00:52:04.761
very important right now when we merely successfully create basic simple software,

00:52:05.641 --> 00:52:10.701
absolutely like a fundamental basic calculator or standard normal terminal tools.

00:52:10.701 --> 00:52:17.601
however the exact moment when we actively rigorously try to fundamentally change our

00:52:17.601 --> 00:52:23.981
massive software architecture or alter major things safely on a significantly much larger

00:52:23.981 --> 00:52:31.041
incredibly massive corporate scale literally many distinct individual things wildly realistically

00:52:31.041 --> 00:52:38.021
start changing aggressively side by side simultaneously we immediately rapidly actively

00:52:38.021 --> 00:52:44.241
see literally multiple deep cascading fundamental code structural changes happening.

00:52:45.141 --> 00:52:52.461
Now, moving confidently right forward seamlessly, we will deeply, actively, rigorously, explicitly

00:52:52.461 --> 00:52:59.141
discuss all of these major systematic fundamental software changes and deeply integrated highly

00:52:59.141 --> 00:53:01.581
complex AI functions directly later.

00:53:02.081 --> 00:53:05.041
We will explore this in the next sections perfectly.

00:53:08.021 --> 00:53:16.021
Authentication and access configuration is a critical part of using OpenAI codecs in an enterprise development environment.

00:53:17.021 --> 00:53:23.021
Authentication verifies the identity of the user or system attempting to use codecs,

00:53:23.021 --> 00:53:29.021
while access configuration defines what that user or system is allowed to do.

00:53:29.021 --> 00:53:42.801
Together, these controls ensure that only authorised developers, teams and automation tools can interact with repositories, environments, APIs and sensitive project resources.

00:53:43.781 --> 00:53:55.781
In enterprise software development, Codex usually works with cloud-based development environments, GitHub repositories, CI-cd pipelines and internal tools.

00:53:55.781 --> 00:54:07.041
Because these systems may contain confidential source code, credentials, customer data and deployment configurations, access must be carefully managed.

00:54:08.441 --> 00:54:17.061
A weak authentication setup can expose the organisation to unauthorised code access, accidental changes or security breaches.

00:54:17.061 --> 00:54:25.981
Therefore, enterprises commonly rely on identity providers, single sign-on, role-based access

00:54:25.981 --> 00:54:32.901
control and audit logging. The authentication process normally begins when a developer signs

00:54:32.901 --> 00:54:40.581
in using an approved identity provider. This may include enterprise login systems such as SSO,

00:54:40.581 --> 00:54:48.461
OAuth or multi-factor authentication. Once the user identity is confirmed, the

00:54:48.461 --> 00:54:52.341
system checks whether the user has permission to access Codex, the

00:54:52.341 --> 00:54:57.981
development workspace and the connected repositories. This ensures that Codex

00:54:57.981 --> 00:55:03.821
activities are tied to a verified user and can be tracked for accountability.

00:55:03.821 --> 00:55:09.921
Access configuration determines the scope of Codex's permissions. For example,

00:55:09.921 --> 00:55:18.921
codecs may be allowed to read a repository, analyse code, create a branch, run tests or open a pull request.

00:55:18.921 --> 00:55:25.921
In some cases, it may not be allowed to directly merge code or access production secrets.

00:55:25.921 --> 00:55:29.921
These permissions should follow the principle of least privilege,

00:55:29.921 --> 00:55:35.921
meaning codecs and users should receive only the access required to complete their assigned tasks.

00:55:35.921 --> 00:55:43.361
Repository access is especially important. Codecs must often inspect project files,

00:55:43.361 --> 00:55:50.321
understand dependencies and modify code. However, not every repository should be

00:55:50.321 --> 00:55:56.421
accessible to every user or AI workflow. Enterprises should configure repository

00:55:56.421 --> 00:56:00.361
permissions based on teams, projects and business sensitivity.

00:56:01.665 --> 00:56:07.025
For example, a front-end developer may receive access to UI repositories

00:56:07.025 --> 00:56:10.865
but not to payment infrastructure or identity management services.

00:56:10.865 --> 00:56:15.865
Environment variables and secrets also require strict control.

00:56:15.865 --> 00:56:22.865
Codecs may need to understand variable names, configuration patterns or runtime requirements,

00:56:22.865 --> 00:56:26.865
but it should not expose or hard code secret values.

00:56:26.865 --> 00:56:33.865
Sensitive credentials should be stored in secure secret managers and injected only when required.

00:56:33.865 --> 00:56:42.465
This prevents accidental leakage of API keys, tokens, database passwords or cloud credentials

00:56:42.465 --> 00:56:45.185
into source code.

00:56:45.185 --> 00:56:51.485
Auditability is another major requirement in enterprise access configuration.

00:56:51.485 --> 00:56:56.705
Organisations should be able to review who accessed codecs, which repositories were used,

00:56:56.705 --> 00:57:01.545
what tasks were performed and what changes were generated.

00:57:01.545 --> 00:57:07.605
logs help security teams investigate incidents, enforce governance policies, and demonstrate

00:57:07.605 --> 00:57:11.705
compliance with internal or regulatory standards.

00:57:11.705 --> 00:57:18.145
A well-designed authentication and access configuration model allows enterprises to use codecs safely

00:57:18.145 --> 00:57:20.285
and efficiently.

00:57:20.285 --> 00:57:26.865
It protects sensitive assets while still enabling developers to benefit from AI-assisted coding.

00:57:26.865 --> 00:57:33.045
By combining strong identity verification, scoped permissions, secure secret handling

00:57:33.045 --> 00:57:38.985
and continuous monitoring, organisations can create a controlled environment where Codex

00:57:38.985 --> 00:57:43.205
improves productivity without increasing operational risk.

00:57:43.205 --> 00:57:46.205
We discuss Codex workflows now.

00:57:46.205 --> 00:57:49.745
We want to see how Codex uses large workflows.

00:57:49.745 --> 00:57:53.865
We look at complete software solutions and workability.

00:57:53.865 --> 00:57:57.645
Sometimes we must see how the whole process grows over time.

00:57:57.645 --> 00:58:02.045
For this, we change and improve code on a large scale.

00:58:02.045 --> 00:58:06.105
After these changes, we check the overall process understanding.

00:58:06.105 --> 00:58:09.645
I will tell you about Codex workflows.

00:58:09.645 --> 00:58:13.305
Codex helps developers in the software development lifecycle.

00:58:13.305 --> 00:58:15.365
It does repeating tasks.

00:58:15.365 --> 00:58:18.105
It makes the coding environment fast.

00:58:18.105 --> 00:58:21.625
It helps us understand how to fix different problems.

00:58:21.625 --> 00:58:25.125
It helps us understand different work processes.

00:58:25.125 --> 00:58:29.285
The most important discussion is how we use codecs.

00:58:29.285 --> 00:58:31.005
We start with a prompt.

00:58:31.005 --> 00:58:33.385
We can add details in the prompt.

00:58:33.385 --> 00:58:35.725
This helps software work well.

00:58:35.725 --> 00:58:40.505
We use prompts to make software processes easy, fast.

00:58:40.505 --> 00:58:42.085
We start with the prompt.

00:58:42.085 --> 00:58:44.585
We can add details in the prompt.

00:58:44.585 --> 00:58:48.125
The important thing in the prompt is a defined objective.

00:58:48.125 --> 00:58:51.145
We must have a defined objective.

00:58:51.145 --> 00:58:55.065
We bring this objective into our software and working process.

00:58:55.065 --> 00:58:58.185
First, we take the generation process.

00:58:58.185 --> 00:59:01.405
We understand the process on a large scale.

00:59:01.405 --> 00:59:04.365
We see how we generate everything.

00:59:04.365 --> 00:59:06.885
We have one big question.

00:59:06.885 --> 00:59:10.425
The question is how to define the objective.

00:59:10.425 --> 00:59:12.625
We look at things to define it.

00:59:12.625 --> 00:59:15.945
We will see how these things work together.

00:59:15.945 --> 00:59:18.925
This is a very strong and important point.

00:59:18.925 --> 00:59:23.825
We must know how to set up objectives for large generation.

00:59:23.825 --> 00:59:27.205
After we set the objective, we look at the next steps.

00:59:27.205 --> 00:59:30.205
The next step is feature development.

00:59:30.205 --> 00:59:34.025
Feature development is a process in our pipeline.

00:59:34.025 --> 00:59:38.725
After development, the next thing is software defect identification.

00:59:38.725 --> 00:59:43.445
We must make this defect identification process strong.

00:59:43.445 --> 00:59:46.845
After we find defects, we move to next steps.

00:59:46.845 --> 00:59:50.125
The next steps are refactoring and optimization.

00:59:50.125 --> 00:59:53.605
First, we must define a task.

00:59:53.605 --> 00:59:57.245
We must have a clear task definition.

00:59:57.245 --> 01:00:01.045
After we define the task, we provide background context.

01:00:01.045 --> 01:00:04.685
We provide this context on a large scale.

01:00:04.685 --> 01:00:07.085
I will explain this process to you.

01:00:07.085 --> 01:00:10.605
I will use a flow diagram to show how things work.

01:00:10.605 --> 01:00:13.845
First, we have the task definition.

01:00:13.845 --> 01:00:17.145
Next, we have Task Context.

01:00:17.145 --> 01:00:20.805
We must know how to add the context.

01:00:20.805 --> 01:00:24.345
After the context, we need a detailed prompt.

01:00:24.345 --> 01:00:27.285
Then we connect our main codecs.

01:00:27.285 --> 01:00:30.725
We connect codecs with our own codebases.

01:00:30.725 --> 01:00:35.945
We connect codecs with our codebases to show complete analysis.

01:00:35.945 --> 01:00:39.965
After analysis, we must have Solution Generation.

01:00:39.965 --> 01:00:43.025
Solution Generation must be available.

01:00:43.025 --> 01:00:47.225
After solution generation, the next step is review.

01:00:47.225 --> 01:00:50.265
I tell you we need these things in our prompt.

01:00:50.265 --> 01:00:53.745
When we have these things, our prompt starts.

01:00:53.745 --> 01:00:58.245
Inside this prompt, our solution generation process starts.

01:00:58.245 --> 01:01:01.245
Here we have our solution generation.

01:01:01.245 --> 01:01:04.225
After we generate the solution, we review it.

01:01:04.225 --> 01:01:07.545
We check everything in the review step.

01:01:07.545 --> 01:01:10.285
After the review, another process starts.

01:01:10.285 --> 01:01:17.285
We call this new process testing. Testing is very important here. In testing we include

01:01:17.285 --> 01:01:25.185
debugging. Both testing and debugging must happen together. We need both in our workflow.

01:01:25.185 --> 01:01:30.745
They help us find and fix problems. These steps make the software better and ready for

01:01:30.745 --> 01:01:36.765
final stages. Both testing and debugging must be present.

01:01:36.765 --> 01:01:39.845
The last step available here is refinement.

01:01:39.845 --> 01:01:43.345
We call this refinement process iteration.

01:01:43.345 --> 01:01:46.765
We do refinement to make software better.

01:01:46.765 --> 01:01:49.885
After the refinement step, we commit changes.

01:01:49.885 --> 01:01:52.785
We save all the changes we made.

01:01:52.785 --> 01:01:55.345
This is the complete process.

01:01:55.345 --> 01:01:58.045
At the end, our workflow closes.

01:01:58.045 --> 01:02:00.865
It closes at the deployment stage.

01:02:00.865 --> 01:02:02.785
We go to deployment.

01:02:02.785 --> 01:02:06.065
We deploy our project into our system.

01:02:06.065 --> 01:02:08.905
These steps are helpful on a large scale.

01:02:08.905 --> 01:02:11.265
They help us create a better score.

01:02:11.265 --> 01:02:14.985
They help us create a better decision tree for work.

01:02:14.985 --> 01:02:18.845
This is how the complete workflow operates from start to finish.

01:02:18.845 --> 01:02:22.405
We follow these simple rules to make good software.

01:02:22.405 --> 01:02:25.945
Every step is important for the final product.

01:02:25.945 --> 01:02:28.265
Deployment is the final goal of this journey.

01:02:28.265 --> 01:02:31.085
Our next talk is about codecs.

01:02:31.085 --> 01:02:34.365
We will learn about our projects in codecs.

01:02:34.365 --> 01:02:39.525
Project navigation is a very important AI skill in modern software development.

01:02:39.525 --> 01:02:44.765
In big business places, developers work with big repositories often.

01:02:44.765 --> 01:02:47.785
These repositories have thousands of files.

01:02:47.785 --> 01:02:50.965
We can see our multiple services directly.

01:02:50.965 --> 01:02:57.365
It also sees big documentation, complex dependencies and multiple servers.

01:02:57.365 --> 01:03:02.305
Understanding these projects by hand needs much time and effort.

01:03:02.305 --> 01:03:09.665
helps developers understand the project structures well. It finds correct files, traces dependencies,

01:03:09.665 --> 01:03:16.065
and locates our implementation details. I go to the project menu directly. I click

01:03:16.065 --> 01:03:23.345
Start from scratch. I name the new project Metabrains. I start one project directly here.

01:03:24.065 --> 01:03:30.225
I save it. Now we have a new project. There is no chat available yet in the project.

01:03:30.225 --> 01:03:33.225
You see our Explorer and Object options.

01:03:33.225 --> 01:03:37.225
If we turn on the Explorer, our file opens automatically.

01:03:37.225 --> 01:03:41.225
You can see we have no document available yet.

01:03:41.225 --> 01:03:45.225
With time, we will make many additions and changes.

01:03:45.225 --> 01:03:49.225
Automatically, our response and style will change.

01:03:49.225 --> 01:03:51.225
I will start from the beginning.

01:03:51.225 --> 01:03:55.225
We will look at all the changes we make from start to now.

01:03:55.225 --> 01:03:59.225
Along with changes, we will also see the time.

01:03:59.627 --> 01:04:04.147
Along with changes we will also see the time. We will see how much time one full cycle takes.

01:04:04.147 --> 01:04:09.467
We can look at the complete process directly. Sometimes we must approve things directly

01:04:09.467 --> 01:04:15.907
to understand them, I will tell you. I will type what things should be in our project.

01:04:15.907 --> 01:04:25.387
I write create an agent.md file. We will create the agent.md file here. This makes our agent

01:04:25.387 --> 01:04:31.627
work in a much better way. I type because this is a corporate sales manager and content

01:04:31.627 --> 01:04:38.307
creator project. It will do the first step of our project here. First of all, we give

01:04:38.307 --> 01:04:44.867
the context and our details. We are making the employee do these things here. We will

01:04:44.867 --> 01:04:50.787
include this directly for our approval. I tell you that a complete process discussion

01:04:50.787 --> 01:04:58.307
is very important here. In this, we have to involve all our details. We must involve our

01:04:58.307 --> 01:05:04.987
full working process here. You can see it will take some time, obviously. It is working

01:05:04.987 --> 01:05:13.847
in our exact folder. If I refresh our folder here, you will see the agent.md file is created.

01:05:13.847 --> 01:05:20.347
We can directly review it here. It created the agent.md file with a tailored operating

01:05:20.347 --> 01:05:27.827
brief. This is for the corporate sales manager and content project. The agent.md file is

01:05:27.827 --> 01:05:34.667
made here. You can see our exact source code and other things are available. We can open

01:05:34.667 --> 01:05:41.467
it directly in our VS code. We can open it in the default application. We can also open

01:05:41.467 --> 01:05:48.167
it in our terminal. These things are much better here. We have a complete system environment.

01:05:49.707 --> 01:05:56.227
Automatically, we see all divisions and working ability here. Sometimes, this working ability

01:05:56.227 --> 01:06:03.547
or complete process causes problems. It causes problems on a big scale. We see many issues

01:06:03.547 --> 01:06:10.207
in our work. We usually create our complete empty MD file at the very start of the project

01:06:10.207 --> 01:06:18.347
setup. So, on a big scale, if any issue happens later, we can understand it early. We can

01:06:18.347 --> 01:06:25.087
do things early according to our system. This is a basic discussion now. We see how complete

01:06:25.087 --> 01:06:32.187
generation happens. We see how we take a complete process or understanding with us. After the

01:06:32.187 --> 01:06:38.627
agent.md file we will directly look at our project structure. I will go into the exact

01:06:38.627 --> 01:06:44.727
same folder. I will include a new folder here. This is from a previously created section.

01:06:45.627 --> 01:06:51.007
You can see our portfolios are available here. I will do all the portfolio discussion here.

01:06:51.927 --> 01:06:59.167
I will now analyse our repository. I write analyse this repository and provide a comprehensive

01:06:59.167 --> 01:07:05.827
overview of the project structure. It includes the main purpose of the application. Then we have

01:07:05.827 --> 01:07:12.947
high-level architecture. Then we have important directories. Then we have all options for

01:07:12.947 --> 01:07:20.287
important directories on a big scale. After major frameworks, we have entry points. After entry

01:07:20.287 --> 01:07:27.567
points, we have configuration files. Then we have deployment-related files. Then we have testing

01:07:27.567 --> 01:07:32.567
structure. Then it says present the information in a structured format,

01:07:32.567 --> 01:07:37.667
suitable for onboarding a new developer. We can take our things directly in

01:07:37.667 --> 01:07:43.007
developer onboarding too. We can involve them. This is a complete structured

01:07:43.007 --> 01:07:47.847
repository layout that we use here. Sometimes we must see some changes in

01:07:47.847 --> 01:07:52.767
this too. In this we also involve multiple repositories and options

01:07:52.767 --> 01:07:58.827
directly. When I enter this it will directly go to our folder. The index file

01:07:58.827 --> 01:08:05.127
is inside. You can see this is like our index file. When the index file opens a

01:08:05.127 --> 01:08:10.647
complete portfolio website is available. Now we will see how to enhance and

01:08:10.647 --> 01:08:15.887
understand this portfolio website on a big scale. This will happen in our codex

01:08:15.887 --> 01:08:23.147
here. It understood the child item here. After that it showed our files. It has

01:08:23.147 --> 01:08:30.707
shown the key pattern too. We have one HTML document. We have one style sheet. We

01:08:30.707 --> 01:08:37.307
have one script bundle. Then we have some static assets. We also have all other

01:08:37.307 --> 01:08:43.787
things available to use directly. Now I will take our details. I will see how our

01:08:43.787 --> 01:08:50.687
process runs. I will see how all direct discussions and details run. With this we

01:08:50.687 --> 01:08:55.607
will take our setup. Usually this needs a lot of time if we take these things in

01:08:55.607 --> 01:09:01.527
another environment but here our things are much simpler now. We can include much

01:09:01.527 --> 01:09:07.547
better things and accounts here. I will look at our direct use case now. It read

01:09:07.547 --> 01:09:12.727
out our whole folder here. After that it told us there are no platform specific

01:09:12.727 --> 01:09:17.407
deployment manifests checked into the repository. The deployment guidance is

01:09:17.407 --> 01:09:23.287
document only. After that we have a testing structure. Then all other things

01:09:23.287 --> 01:09:28.867
have come. Now we have gone inside our project. We have seen how we will include

01:09:28.867 --> 01:09:34.487
our system. Now I will see what entry points are available there. I will write

01:09:34.487 --> 01:09:39.307
to find the entry points. If we want to look at something other than entry points

01:09:39.307 --> 01:09:42.687
we will involve all user authentication features here.

01:09:43.267 --> 01:09:45.087
We will see how we can look at them.

01:09:46.047 --> 01:09:49.647
Along with this, we will get a direct response from the complete system.

01:09:50.407 --> 01:09:53.847
We will see how we take things directly in our system first.

01:09:54.847 --> 01:09:59.327
I will type to locate and explain the implementation of the user authentication feature.

01:10:00.027 --> 01:10:02.967
I will identify all the components involved here.

01:10:03.707 --> 01:10:06.047
Then I will look at the authentication flow.

01:10:06.047 --> 01:10:09.507
Then I will look at the authentication middleware

01:10:09.507 --> 01:10:12.327
Then I will look at password handling

01:10:12.327 --> 01:10:15.967
Then I will look at the token generation process

01:10:15.967 --> 01:10:19.527
Then I will look at the session or token management

01:10:19.527 --> 01:10:25.447
Then I will provide a step-by-step explanation of how the application starts

01:10:25.447 --> 01:10:30.687
Then I will process the requests from login to successful authentication

01:10:30.687 --> 01:10:33.887
These things bring all our details here

01:10:33.887 --> 01:10:36.587
All our handling has come here now.

01:10:37.747 --> 01:10:43.287
Generating code from requirements is one of the most practical uses of OpenAI codecs in everyday development.

01:10:44.347 --> 01:10:49.127
Instead of translating every single business requirement into working code by hand,

01:10:49.787 --> 01:10:53.587
developers can provide codecs with a vast amount of information or context.

01:10:54.787 --> 01:10:58.427
We can include clear instructions, behaviours and context.

01:10:59.207 --> 01:11:02.027
We have multiple forms of languages available to use.

01:11:02.027 --> 01:11:05.027
Let me open Excalibur here.

01:11:05.027 --> 01:11:09.027
As you can see, we have some business languages.

01:11:09.027 --> 01:11:19.027
For example, we can allow users to export reports as CSV or involve role-based access control, also known as RBAC.

01:11:19.027 --> 01:11:23.027
Codex helps bridge the gap between these requirements and implementations

01:11:23.027 --> 01:11:29.027
by identifying relevant files, suggesting changes, creating new components,

01:11:29.027 --> 01:11:33.027
updating APIs, and adding tests where needed.

01:11:33.027 --> 01:11:39.027
However, Codex works best when the requirements are very specific in nature.

01:11:39.027 --> 01:11:43.027
Let me show you how to include basics in Codex right from the start.

01:11:43.027 --> 01:11:48.027
Suppose you want a plan mode, and after that you want to pursue a goal.

01:11:48.027 --> 01:11:51.027
Then you might want to create a document.

01:11:51.027 --> 01:11:56.027
After document creation, you might want to include photos.

01:11:56.027 --> 01:11:59.027
You have multiple plugins that you can use side by side.

01:12:00.701 --> 01:12:06.281
browser plugin you can use that one too. If you have specific content to use that

01:12:06.281 --> 01:12:12.481
can be utilized as well. For instance we can go to documents or downloads, select

01:12:12.481 --> 01:12:15.641
Select an available document and use it.

01:12:15.641 --> 01:12:18.421
After that we select our model.

01:12:18.421 --> 01:12:24.241
This latency is quite important, therefore I will use a latest model here.

01:12:24.241 --> 01:12:29.541
With that latest model, we can increase speed and manage latency well.

01:12:29.541 --> 01:12:33.921
After this, our prompt should contain very detailed options.

01:12:33.921 --> 01:12:38.801
First of all, a well-set prompt has some specific elements available within it.

01:12:38.801 --> 01:12:41.321
I will explain these elements to you.

01:12:41.321 --> 01:12:45.321
A good prompt includes all these necessary components.

01:12:45.321 --> 01:12:52.541
The very first thing is context, followed by the role, details, and then the requirements.

01:12:52.541 --> 01:12:57.521
When discussing requirements, it is a crucial point because codex works better when the

01:12:57.521 --> 01:12:59.781
requirements are specific.

01:12:59.781 --> 01:13:04.261
A vague prompt may produce incomplete or misaligned code.

01:13:04.261 --> 01:13:10.761
A strong prompt includes the feature goal, affected users, input and output behaviour,

01:13:10.761 --> 01:13:16.521
or modules to consider, coding standards, test expectations and what our codex

01:13:16.521 --> 01:13:21.321
should avoid changing. Developers should treat the codex generated code as a

01:13:21.321 --> 01:13:26.081
first draft so we get a complete response right from the very start of it.

01:13:26.081 --> 01:13:32.061
Next, after the requirements, we need to establish our acceptance criteria. This

01:13:32.061 --> 01:13:36.801
defines the standard our response must maintain when we receive it. At the end

01:13:36.801 --> 01:13:42.561
we sometimes use a negative prompt. In a negative prompt we specify the things

01:13:42.561 --> 01:13:47.561
that we do not need. In the rest of the prompt we list all the necessary things

01:13:47.561 --> 01:13:53.241
that we want. However, in a negative prompt we mention all those exact things

01:13:53.241 --> 01:13:58.761
that are not required for our output at all. For example, let me show you a sample

01:13:58.761 --> 01:14:03.681
prompt right here in this section. We can go into Codex and type out our prompt.

01:14:03.681 --> 01:14:12.341
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.

01:14:13.561 --> 01:14:17.821
This defines our role. The complete task is outlined in plain words.

01:14:18.721 --> 01:14:25.901
After the task, you can see our functional requirements are discussed, such as adding an Export CSV button near the Reports table.

01:14:26.881 --> 01:14:30.521
Towards the end, all the detailed steps we need to perform are available.

01:14:31.141 --> 01:14:33.341
This is our acceptance criteria.

01:14:33.681 --> 01:14:36.681
The export button appears on the report page.

01:14:36.681 --> 01:14:39.681
Clicking the button downloads a valid CSV file,

01:14:39.681 --> 01:14:43.681
and the CSV contains the same rows displayed on the table.

01:14:43.681 --> 01:14:47.681
It will take data straight from the browser, commit the repository in GitHub,

01:14:47.681 --> 01:14:50.681
and provide the response in document form.

01:14:50.681 --> 01:14:56.681
Generating code from requirements with Codex improves overall development speed.

01:14:56.681 --> 01:15:00.681
When our prompts are better, the final results we get will also be much better,

01:15:00.681 --> 01:15:06.801
better, which we can then utilise today. Clear requirements, a defined scope and

01:15:06.801 --> 01:15:11.841
strong acceptance criteria help codecs produce code that is easier to review,

01:15:11.841 --> 01:15:17.921
test and merge in big enterprise teams. We are discussing how big enterprise

01:15:17.921 --> 01:15:23.001
teams can incorporate these modern features on a larger scale today. Our

01:15:23.001 --> 01:15:26.781
next discussion will be related to editing and refactoring existing code

01:15:26.781 --> 01:15:33.781
We have generated this exact code as an example project where we are utilising all these core elements in real time.

01:15:33.781 --> 01:15:38.781
Now, suppose our initial code is generated and ready.

01:15:38.781 --> 01:15:45.781
To demonstrate this point well, I will show you a custom calculator code from our older previous generations.

01:15:45.781 --> 01:15:55.781
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.

01:15:55.781 --> 01:16:02.201
today. Now we will discuss editing or refactoring the code. Here you can see

01:16:02.201 --> 01:16:06.641
that we asked to create a calculator code. It took a quick look and made a

01:16:06.641 --> 01:16:11.681
plan for us. After making the plan it implemented the calculator in the

01:16:11.681 --> 01:16:17.741
calculator.py file. This is our calculator. Everything in it is

01:16:17.741 --> 01:16:22.421
functional from start to finish. If we want to run it we will see that the

01:16:22.421 --> 01:16:28.461
verification passed using the bundled Python runtime. Note that Python and py

01:16:28.461 --> 01:16:34.301
are not on our system path, so if we want to use it in our environment we need all

01:16:34.301 --> 01:16:40.481
these requirements. I will open PowerShell here or I will just open the

01:16:40.481 --> 01:16:46.781
command prompt. In the command prompt we will give this command. When I press enter

01:16:46.781 --> 01:16:51.941
you will see that we have a complete response included here. Now I will

01:16:51.941 --> 01:16:58.301
include it here. There is an issue in the first line of our code. So we will run it

01:16:58.301 --> 01:17:04.881
from here to here. I will copy this. After copying I will go back to the command

01:17:04.881 --> 01:17:11.321
prompt. Here is the command prompt. Now we will include it in the command prompt.

01:17:11.321 --> 01:17:16.881
When we include it you can see that because this file is very old our file

01:17:16.881 --> 01:17:23.121
is not available here. But we can still run it in our browser. Now we will look

01:17:23.121 --> 01:17:28.161
at our editing and refactoring here. Usually this is the most valuable

01:17:28.161 --> 01:17:33.741
capability of our OpenAI codecs for enterprise software development. While

01:17:33.741 --> 01:17:38.841
generating new code is useful, developers spend a lot of time improving,

01:17:38.841 --> 01:17:45.061
maintaining and modernizing existing applications. Codecs can analyze the

01:17:45.061 --> 01:17:52.141
current code base. It can understand relationships between files, identify code smells and suggest

01:17:52.141 --> 01:17:58.681
improvements for better readability. First I will explain the first thing. This is what

01:17:58.681 --> 01:18:06.221
we call refactoring code. This is a process of restructuring the existing code. It improves

01:18:06.221 --> 01:18:13.421
readability, maintainability and internal design without changing its external behaviour.

01:18:13.421 --> 01:18:16.941
We primarily involve this in our code review.

01:18:16.941 --> 01:18:22.621
If I go to Excalordraw, I can tell you that after refactoring, the next thing is restructuring

01:18:22.621 --> 01:18:23.621
or editing.

01:18:23.621 --> 01:18:26.361
That is very simple.

01:18:26.361 --> 01:18:31.441
It is simple because we can come into our code, include any line here, and include things

01:18:31.441 --> 01:18:33.421
by giving a local comment.

01:18:33.421 --> 01:18:39.741
Or, if we want to do overall refactoring, I can say to make this into an HTML file that

01:18:39.741 --> 01:18:42.541
I can run in VS Code.

01:18:42.541 --> 01:18:46.481
Here you can see that now it will directly take our prompt.

01:18:46.481 --> 01:18:49.421
The code was previously available.

01:18:49.421 --> 01:18:55.921
Now it will connect our Python calculator into a browser-friendly HTML version.

01:18:55.921 --> 01:18:59.641
Alternatively I will open our VS Code.

01:18:59.641 --> 01:19:05.481
You might remember that we already included codecs in Visual Studio Code before, so this

01:19:05.481 --> 01:19:10.041
will also be available for us to use in a much easier way.

01:19:10.041 --> 01:19:15.041
Along with this, in Visual Studio Code where everything else is, we will automatically

01:19:15.041 --> 01:19:18.501
include our calculator file.

01:19:18.501 --> 01:19:19.501
Codex is open.

01:19:19.501 --> 01:19:23.521
All our generations and things are available in it.

01:19:23.521 --> 01:19:27.341
Now you will see that our codex file has arrived here.

01:19:27.341 --> 01:19:31.681
In the codex file, all our things are directly included.

01:19:31.681 --> 01:19:36.761
Now you can see that if we want, we can directly open the calculator in the browser, or we

01:19:36.761 --> 01:19:40.581
We can copy its link and go to another browser.

01:19:40.581 --> 01:19:44.641
If we copy its link, we just have to go here.

01:19:44.641 --> 01:19:49.481
When we open it here, the calculator will open in our browser.

01:19:49.481 --> 01:19:52.061
This is a very simple calculator.

01:19:52.061 --> 01:19:57.201
If we want to open it in the internal browser of Codex, that is also possible.

01:19:57.201 --> 01:20:00.081
will load and run our calculator in the Codex browser.

01:20:01.264 --> 01:20:05.904
Here you can see that if we want, we can directly use this file in our VS Code

01:20:05.904 --> 01:20:07.744
from the options.

01:20:07.744 --> 01:20:11.104
We can include annotations. If we want,

01:20:11.104 --> 01:20:15.584
we can save a screenshot here. After saving the screenshot here,

01:20:15.744 --> 01:20:18.744
we can also use it in another browser.

01:20:18.744 --> 01:20:21.744
We can come here and use it here too.

01:20:21.744 --> 01:20:26.744
So, if we want to make any design changes, we can do that directly.

01:20:26.744 --> 01:20:33.744
When working with legacy systems, developers often face challenges such as inconsistent coding styles.

01:20:33.744 --> 01:20:37.744
Here, the coding we have is AI-based coding.

01:20:37.744 --> 01:20:43.744
However, if we talk about legacy systems, they are systems where we manually write all the code.

01:20:43.744 --> 01:20:48.184
We make all the changes and alterations in that code ourselves.

01:20:48.184 --> 01:20:55.504
There, sometimes there are outdated frameworks, poor documentation and tightly coupled components.

01:20:55.504 --> 01:21:02.064
Codex can help developers understand the purpose of existing code before making modifications.

01:21:02.064 --> 01:21:06.544
It does this by analysing the related files and dependencies.

01:21:06.544 --> 01:21:13.504
It can recommend safer refactoring strategies and identify areas where changes may have downstream

01:21:13.504 --> 01:21:20.004
effects. This significantly reduces the time required to understand unfamiliar code bases.

01:21:20.004 --> 01:21:27.224
Despite these advantages, developers should carefully review all refactoring changes before

01:21:27.224 --> 01:21:32.384
merging them into the production branches. Even when functionality appears unchanged,

01:21:32.384 --> 01:21:38.944
modifications can introduce unintended side effects. Now, I will work on our code here.

01:21:38.944 --> 01:21:45.064
I will go to our codex. In codex we will write a prompt that you are working as a

01:21:45.064 --> 01:21:49.744
senior software engineer in this repository. The task is to refactor the

01:21:49.744 --> 01:21:54.264
existing code without changing its functionality. We will improve the code

01:21:54.264 --> 01:21:58.684
readability and maintainability and remove duplicate logic with simple

01:21:58.684 --> 01:22:04.264
complex methods. There is a lot of detail here. The general overview of this

01:22:04.264 --> 01:22:08.344
detail is that we should make our code readability and maintainability better.

01:22:08.344 --> 01:22:13.544
As soon as I improve this, we start getting our response.

01:22:13.544 --> 01:22:15.704
We can directly include this response.

01:22:15.704 --> 01:22:19.164
First, it will look at the current state.

01:22:19.164 --> 01:22:24.984
The main refactor target is that we will slightly change the HTML file.

01:22:24.984 --> 01:22:28.724
First of all, we will include the keyboard handling.

01:22:28.724 --> 01:22:33.324
After that, we will see multiple changes in this HTML file.

01:22:33.324 --> 01:22:37.384
If we want to review it, our changes will automatically appear wherever changes are

01:22:37.384 --> 01:22:43.704
being made in our file. You will see that the refactor is done in one focused pass.

01:22:43.704 --> 01:22:50.024
I am validating both sides now. Python behaviour should still pass, and the HTML script should

01:22:50.024 --> 01:22:54.504
still calculate and respond to the button and keyboard actions. Here our checks have

01:22:54.504 --> 01:23:02.684
passed. Now, if we reload our calculator, many changes will be included in our calculator.

01:23:02.684 --> 01:23:05.764
Now we have another very important thing.

01:23:05.764 --> 01:23:08.564
It is not just doing a simple check.

01:23:08.564 --> 01:23:11.864
It also performed a Python check.

01:23:11.864 --> 01:23:18.984
If I show you the working, after the Python check it also included HTML behaviour checks.

01:23:18.984 --> 01:23:22.444
The refactored HTML is built here.

01:23:22.444 --> 01:23:25.484
It has only 123 lines.

01:23:25.484 --> 01:23:29.704
I can say that our workability is much easier now.

01:23:29.704 --> 01:23:33.944
If we look at the code review, it changed many lines in the code.

01:23:33.944 --> 01:23:40.824
For example, instead of display value 0, it has set the display value to the default value.

01:23:40.824 --> 01:23:44.864
Overall, it showed our functionality in depth.

01:23:44.864 --> 01:23:49.704
It directly changed the error coming in the display into show error.

01:23:49.704 --> 01:23:54.764
Here too, it changed set display error to show error.

01:23:54.764 --> 01:24:01.004
In simple words, it improved our code maintainability and nullified the error-causing paths on a

01:24:01.004 --> 01:24:02.984
large scale.

01:24:02.984 --> 01:24:07.204
It manipulated the errors into the ShowError function.

01:24:07.204 --> 01:24:12.544
Exactly here too, the SetDisplayError was changed to ShowError.

01:24:12.544 --> 01:24:17.644
This means, in simple words, our code maintainability has improved.

01:24:17.644 --> 01:24:21.424
It has removed the paths that cause errors on a large scale.

01:24:21.424 --> 01:24:27.804
we will discuss context windows and scope. Context window is a new topic. People do not

01:24:27.804 --> 01:24:34.824
discuss it much. I will tell you what a context window is. A context window is the maximum

01:24:34.824 --> 01:24:42.284
text an AI model can hold at one time. It works as the AI's memory. Everything inside

01:24:42.284 --> 01:24:49.144
this window, like prompts, history or files, is seen by the model. Before explaining how

01:24:49.144 --> 01:24:55.424
it works, I will give you a simple example. For a simple example, I will go to ChatGPT.

01:24:56.524 --> 01:25:03.784
First, I write a message in ChatGPT. I say, hi, I want to work with AI and HTML.

01:25:04.784 --> 01:25:10.644
If I continue this conversation, it will write the code. This is simple prompting.

01:25:11.164 --> 01:25:18.084
We get our answer through it. But if we do something else, if we give a very long prompt

01:25:18.084 --> 01:25:25.464
again and again. You will see a message. The message says it is too long. Let us see the

01:25:25.464 --> 01:25:32.444
size of the context window in ChatGPT. I will search for the context window of ChatGPT.

01:25:32.444 --> 01:25:40.144
It will show the context window size. Usually the model has a 128,000 token window. This

01:25:40.144 --> 01:25:47.104
This means it takes 96,000 words or 250 to 300 pages of text.

01:25:47.104 --> 01:25:50.704
I will copy this text and paste it many times.

01:25:50.704 --> 01:25:54.044
I will do this until the prompt becomes too long.

01:25:54.044 --> 01:25:58.324
I will copy it and go to a word counter website.

01:25:58.324 --> 01:26:00.584
It is a famous word counter.

01:26:00.584 --> 01:26:05.364
When I paste the words here, you will see the website become slow.

01:26:05.364 --> 01:26:10.604
This is because there are 9,776 words in total.

01:26:10.604 --> 01:26:12.804
We put this in our prompt.

01:26:12.804 --> 01:26:16.184
It has 76,000 characters.

01:26:16.184 --> 01:26:19.124
Now suppose I paste the last text here.

01:26:19.124 --> 01:26:20.984
You will see a message.

01:26:20.984 --> 01:26:24.104
It says the long text is added as a file.

01:26:24.104 --> 01:26:26.324
The text will show up here.

01:26:26.324 --> 01:26:30.324
I will write that if I put this file in the chat it cannot process it.

01:26:30.324 --> 01:26:32.784
The message is too long.

01:26:32.784 --> 01:26:36.664
We want to see the context window size of ChatGPT.

01:26:36.664 --> 01:26:38.424
It will take time.

01:26:38.424 --> 01:26:41.824
You will see that the context window depends on the model.

01:26:41.824 --> 01:26:47.324
OpenAI does not always show the exact limit, but if you see the message it means the text

01:26:47.324 --> 01:26:55.564
is too long for one input, the file is too big, or the user interface has strict limits.

01:26:55.564 --> 01:26:59.564
If we use fewer words, we will get our answer.

01:26:59.564 --> 01:27:03.364
In the same way, when we go to Codex we can see limits.

01:27:03.364 --> 01:27:05.784
In the new chat we have limits.

01:27:05.784 --> 01:27:08.484
Wait a minute, I will open it here.

01:27:08.484 --> 01:27:10.964
We know that Codex has some limits.

01:27:10.964 --> 01:27:16.004
Even if we add many images, files and documents there are still limits.

01:27:16.004 --> 01:27:22.364
In real business projects, apps have thousands of files and millions of lines of code.

01:27:22.364 --> 01:27:26.284
No AI can read all the code at once.

01:27:26.284 --> 01:27:30.504
Devils must help codecs focus on important information.

01:27:30.504 --> 01:27:32.844
Scope sets the limits of a task.

01:27:32.844 --> 01:27:36.784
It includes files, modules and features.

01:27:36.784 --> 01:27:39.744
Setting the right scope stops bad changes.

01:27:39.744 --> 01:27:43.164
It helps codecs focus on the right parts.

01:27:43.164 --> 01:27:45.404
Now I will tell you directly.

01:27:45.404 --> 01:27:47.484
Suppose we get an answer.

01:27:47.484 --> 01:27:49.764
How will a full developer work?

01:27:49.764 --> 01:27:53.444
For example, we will take an e-commerce store.

01:27:53.444 --> 01:27:56.244
In our example we have an e-commerce store.

01:27:56.244 --> 01:27:59.264
A developer wants to add a discount box to a product page.

01:28:02.073 --> 01:28:10.273
Codex. He only shares the product model, service, controller, form and tests. This limits the

01:28:10.273 --> 01:28:15.553
context. Codex can focus on the updates. It will not make bad changes in other

01:28:15.553 --> 01:28:22.873
places. Where do we use this? When we make changes this is very helpful. We can

01:28:22.873 --> 01:28:28.893
modify things easily. You will see two or three options here. We can open it in VS

01:28:28.893 --> 01:28:35.873
code. We have a full MetaBrain's project here. It has all our files. We can run

01:28:35.873 --> 01:28:42.053
the index file here. On the side we have our chat. Our codex is also running

01:28:42.053 --> 01:28:48.413
directly. Besides codex we have an agents option. We can use agents to do

01:28:48.413 --> 01:28:54.953
our work directly. Now we will verify our GitHub account. Do you remember how I did

01:28:54.953 --> 01:29:01.933
GitHub authentication? We will authorize VS code directly. Our workflow and

01:29:01.933 --> 01:29:08.433
personal details will be added here. This works for public and private projects.

01:29:08.433 --> 01:29:13.613
We can include this directly. If I show you the sign in again, authorisation

01:29:13.613 --> 01:29:20.753
comes directly. We can confirm it. Suppose we want to verify using email.

01:29:20.753 --> 01:29:27.033
The email will come automatically. We will confirm the email here. These emails

01:29:27.033 --> 01:29:34.853
run through a base setup. We got the code here. Then we will verify it. Our VS code

01:29:34.853 --> 01:29:42.973
will sign in and connect automatically. After signing in, MetaBrainz connects with our co-pilot.

01:29:42.973 --> 01:29:49.373
We are running many windows. In one place we run the agent. In another place we use

01:29:49.373 --> 01:29:59.253
our IDE. In a third place, we use it as a chatbot. So, we must manage our context carefully.

01:29:59.253 --> 01:30:04.753
Context window and scope management are very important for AI software development. By

01:30:04.753 --> 01:30:11.913
giving the right information and clear boundaries, developers help codecs. It creates accurate,

01:30:11.913 --> 01:30:17.533
good and reliable code. We must look at these important things carefully.

01:30:17.533 --> 01:30:22.233
Now, our discussion is about reviewing our AI-generated code.

01:30:22.233 --> 01:30:27.473
In the AI-generated code, we want to see how we previously used codes like

01:30:27.473 --> 01:30:32.413
CreateCalculator multiple times, as you can see.

01:30:32.413 --> 01:30:39.133
We have created the calculator here, and you can see that all our changes are also available here.

01:30:39.133 --> 01:30:45.413
For these AI-generated changes, we first need to understand two or three things.

01:30:45.413 --> 01:30:51.213
First, in this complete software we are using, whenever there are changes, the red values

01:30:51.213 --> 01:30:56.393
will be all our previous values, and the green values will be our new possible changes that

01:30:56.393 --> 01:30:58.693
we have used here.

01:30:58.693 --> 01:31:05.013
If you look here, you can first see the set display error, but now in our new code, some

01:31:05.013 --> 01:31:07.433
things have expanded.

01:31:07.433 --> 01:31:13.373
Let us suppose I directly include a prompt here saying, I want a scientific calculator.

01:31:13.373 --> 01:31:18.293
Now, a scientific calculator will be created here.

01:31:18.293 --> 01:31:23.053
Usually we have this one code and we can call it version 1.

01:31:23.053 --> 01:31:28.693
Automatically, this version of ours will be applied here, and along with this version,

01:31:28.693 --> 01:31:33.493
if we have any other versions available here, they will be used.

01:31:33.493 --> 01:31:38.173
First of all, it will take some time to think about what things were discussed in the previous

01:31:38.173 --> 01:31:40.013
context.

01:31:40.013 --> 01:31:44.053
It will review what discussions we were having previously.

01:31:44.053 --> 01:31:49.773
After all those discussions, our code will automatically start generating here.

01:31:49.773 --> 01:31:53.193
Alright, it is reconnecting with our work.

01:31:53.193 --> 01:31:58.313
Our connection with the model is being created to see how a complete connection will be generated

01:31:58.313 --> 01:32:01.573
and how our thinking will work on a larger scale.

01:32:01.573 --> 01:32:06.813
Usually, when we are looking at such a code, we have to do validation.

01:32:06.813 --> 01:32:10.273
We can separate our unified difference from here.

01:32:10.273 --> 01:32:14.613
We call this split and we call the other one unified.

01:32:14.613 --> 01:32:20.353
In the split view, our complete previous codebase is on one side and our new code is included

01:32:20.353 --> 01:32:22.293
on the other side.

01:32:22.293 --> 01:32:27.413
In the previous one, you can see the display error and here you can see how much our error

01:32:27.413 --> 01:32:29.813
evaluation is available now.

01:32:29.813 --> 01:32:34.313
Similarly, our if action is also available here.

01:32:34.313 --> 01:32:40.153
We can see how much if action we had previously, and after that, how many evaluations are coming

01:32:40.153 --> 01:32:41.973
in our run action.

01:32:41.973 --> 01:32:47.473
Alright, so all these things are being directly included in our system.

01:32:47.473 --> 01:32:50.253
We are looking at multiple changes here.

01:32:50.253 --> 01:32:54.033
You can see that our connection is being created once again here.

01:32:54.033 --> 01:32:59.453
We can change the model to a very simple one, make the speed fast, and also change the reasoning

01:32:59.453 --> 01:33:00.453
here.

01:33:00.453 --> 01:33:08.033
Now, besides all these things, we have two options available here, Review and Undo.

01:33:08.033 --> 01:33:13.653
In the Review option, we can directly review our code once in the first scenario.

01:33:13.653 --> 01:33:17.633
And Undo works exactly like our version control system.

01:33:17.633 --> 01:33:21.493
It keeps multiple versions in our adopted system.

01:33:21.493 --> 01:33:26.053
Here you can see that our system is now running, and it is telling us that it is upgrading

01:33:26.053 --> 01:33:28.253
the existing HTML.

01:33:28.253 --> 01:33:33.493
Now, let us suppose I take you to this HTML file.

01:33:33.493 --> 01:33:36.273
I will show all the differences here.

01:33:36.273 --> 01:33:40.713
They are here now and we will also enable the rich preview.

01:33:40.713 --> 01:33:44.173
Now you can see that this is our newer file.

01:33:44.173 --> 01:33:49.053
Even after the newer file, when we make changes again, those changes will also be visible

01:33:49.053 --> 01:33:50.473
here.

01:33:50.473 --> 01:33:54.653
You will see plus 32 and minus 21.

01:33:54.653 --> 01:33:59.053
This shows how many lines of code were removed and how many lines of code were added to our

01:33:59.053 --> 01:34:01.153
total system.

01:34:01.153 --> 01:34:06.913
When both these things work together, we automatically start getting our response and work results.

01:34:06.913 --> 01:34:09.173
It shows how we are managing things.

01:34:09.173 --> 01:34:14.453
Alright, so this is our very detailed working process.

01:34:14.453 --> 01:34:17.133
Here you can see all the changes.

01:34:17.133 --> 01:34:23.173
For a simple example, as we are reviewing now, the title was previously Calculator, but now

01:34:23.173 --> 01:34:27.673
Now our new title has become Scientific Calculator.

01:34:27.673 --> 01:34:33.033
Alright, if we look here now, all the design changes of our calculator are shown here with

01:34:33.033 --> 01:34:35.053
plus and minus signs.

01:34:35.053 --> 01:34:41.673
Also, you can see that if we want to add something here, we can directly include a local comment.

01:34:41.673 --> 01:34:45.693
For example, I can say here, I want round buttons.

01:34:45.693 --> 01:34:49.633
Okay, so now we want our round buttons.

01:34:49.633 --> 01:34:53.913
As soon as I post this comment, you can see it is included here.

01:34:53.913 --> 01:34:56.453
Now this comment is added, alright?

01:34:56.453 --> 01:35:01.393
Similarly, if we go here, I will say, I want more buttons.

01:35:01.393 --> 01:35:04.893
I am making very simple changes in front of you.

01:35:04.893 --> 01:35:06.813
I will add the comment.

01:35:06.813 --> 01:35:09.893
Now there are two comments here, alright?

01:35:09.893 --> 01:35:14.153
In the same way, at the end of this file, I will say that we need simpler functionality

01:35:14.153 --> 01:35:15.153
here.

01:35:15.153 --> 01:35:18.953
Okay, I will say, simple functionality please.

01:35:20.293 --> 01:35:22.453
Alright, this comment is added here.

01:35:23.473 --> 01:35:26.813
After that, we can go to the end or just go to the start.

01:35:27.773 --> 01:35:29.973
In the start, I will change our name here.

01:35:30.713 --> 01:35:33.173
Change the name as MetaBrainzCal.

01:35:33.993 --> 01:35:36.013
Okay, MetaBrainzCal.

01:35:37.033 --> 01:35:39.473
Alright, now our comment is added.

01:35:40.413 --> 01:35:43.073
You can see that three or four comments are here now.

01:35:43.073 --> 01:35:50.073
In our calculator, we have a comment in row number 46 and a comment in row number 102.

01:35:50.073 --> 01:35:56.073
After that, there is a comment in row number 200 and then a comment in row number 6.

01:35:57.306 --> 01:36:05.046
Now what we have to do here is I can say make the possible changes asked. Okay what will happen here

01:36:05.046 --> 01:36:10.246
is that based on the changes we included in these comments the changes will happen at those exact

01:36:10.246 --> 01:36:15.366
points. I will only show you this one change that we demanded at the end in the comments.

01:36:16.086 --> 01:36:19.686
We will see how it changes the name of our scientific calculator here,

01:36:20.326 --> 01:36:26.886
and this is a very advanced feature. We are reviewing our complete AI generated changes

01:36:26.886 --> 01:36:31.366
to see how our reviews can be applied on a larger scale and how we can include them.

01:36:32.406 --> 01:36:37.286
It will take some time to think. Obviously you can see that it is thinking here,

01:36:37.286 --> 01:36:41.246
and after that it says, I will apply the review comments directly.

01:36:42.406 --> 01:36:44.946
First of all, our name will be changed to MetaBrainz.

01:36:45.766 --> 01:36:48.326
After that, the calculator buttons will be made circular.

01:36:49.286 --> 01:36:52.066
A few practical scientific buttons will be included.

01:36:53.186 --> 01:36:54.726
Here you can see our calculation.

01:36:55.886 --> 01:36:57.626
MetaBrainzCal is written here.

01:36:58.606 --> 01:37:02.906
After that, we also included a comment here that we want our buttons to be rounded.

01:37:02.906 --> 01:37:09.906
So, you can see that by including height, aspect ratio, border radius and all these things,

01:37:09.906 --> 01:37:13.906
it has provided us with some rounded buttons that we can directly see here.

01:37:13.906 --> 01:37:18.906
Alright, so all these things are greatly included in our working process here.

01:37:18.906 --> 01:37:23.906
And through this, we can include it in our system, and it will work here.

01:37:23.906 --> 01:37:26.906
Now we will get all our changes here.

01:37:26.906 --> 01:37:29.906
You can see that whatever visual changes we have,

01:37:29.906 --> 01:37:34.666
it has included some lines in a file and showed us the changes here.

01:37:34.666 --> 01:37:36.946
We can also open that here.

01:37:36.946 --> 01:37:43.246
OK, after that, for the next changes it makes, you can see our thinking process here.

01:37:43.246 --> 01:37:48.366
In the thinking process, as it is including our constants and other values, these files

01:37:48.366 --> 01:37:51.826
will automatically come here side by side.

01:37:51.826 --> 01:37:54.006
Now it has updated our file.

01:37:54.006 --> 01:37:56.046
We have all the commands here.

01:37:56.046 --> 01:38:01.046
As soon as we open this in our browser, all our discussed changes are here, like Metabrains

01:38:01.046 --> 01:38:02.346
Cal.

01:38:02.346 --> 01:38:04.826
Our buttons have become rounded.

01:38:04.826 --> 01:38:09.686
And now, if we include anything here, that thing will automatically be directly included

01:38:09.686 --> 01:38:10.686
here.

01:38:10.686 --> 01:38:13.026
OK, our error came here.

01:38:13.026 --> 01:38:14.726
We are seeing everything working.

01:38:14.726 --> 01:38:20.066
Alright, if we suppose we need the value of pi here, we get our pi value.

01:38:20.066 --> 01:38:23.986
If we need the value of log8, we can directly input it here.

01:38:23.986 --> 01:38:29.626
Also, you can see that this delete option is working directly here too.

01:38:29.626 --> 01:38:35.186
If we look at all the signs here, every sign that we have is working very easily.

01:38:35.186 --> 01:38:39.066
We can directly enter all our values here.

01:38:39.066 --> 01:38:43.726
If there is no responsiveness, we can go ahead and directly include responsiveness in our

01:38:43.726 --> 01:38:45.786
code later.

01:38:45.786 --> 01:38:50.266
But code review is the main thing that I have discussed with you.

01:38:50.266 --> 01:38:54.426
After this, our next discussion is related to our prompt hints.

01:38:54.426 --> 01:38:58.166
Next we discuss the main usage of a prompt library.

01:38:58.166 --> 01:39:02.786
We will see how we can use it and where more options are included.

01:39:02.786 --> 01:39:04.466
First I come here.

01:39:04.466 --> 01:39:09.946
Instead of using everything, I will search the prompt library in Codex.

01:39:09.946 --> 01:39:12.866
Here you see Codex prompting.

01:39:12.866 --> 01:39:18.366
First I tell you this is a built-in collection of reusable workflows, templates and skills

01:39:18.366 --> 01:39:22.506
in OpenAI Codecs and Agentic CLI.

01:39:22.506 --> 01:39:26.806
When I go to prompting, you see we often use prompts.

01:39:26.806 --> 01:39:31.986
You interact with the codecs by sending prompts that describe what you want.

01:39:31.986 --> 01:39:34.586
Example prompts are shown here.

01:39:34.586 --> 01:39:36.686
Thread is a single session.

01:39:36.686 --> 01:39:41.646
It has your prompt plus the model outputs and tool calls that follow.

01:39:41.646 --> 01:39:44.606
A thread can include multiple prompts.

01:39:44.606 --> 01:39:48.146
We use a chain of process to take things forward.

01:39:48.146 --> 01:39:52.606
I will explain this exact process right here in our codex.

01:39:52.606 --> 01:39:56.706
In codex, we go to our main user settings.

01:39:56.706 --> 01:40:00.486
Inside these settings we have personalization.

01:40:00.486 --> 01:40:05.266
In personalization, our own custom instructions are included.

01:40:05.266 --> 01:40:10.606
We can also switch our AI personality from pragmatic to friendly.

01:40:10.606 --> 01:40:14.086
Both of these personalization options are here.

01:40:14.086 --> 01:40:19.466
In custom instructions, we can include all custom-made, personalised instructions that

01:40:19.466 --> 01:40:21.766
we want in our tool.

01:40:21.766 --> 01:40:25.366
It is quite simple to include our text responses.

01:40:25.366 --> 01:40:31.086
But sometimes, we must see our clear deviation and how we are working on stuff, and how these

01:40:31.086 --> 01:40:33.806
custom instructions work.

01:40:33.806 --> 01:40:39.086
We have our memory, which we can induce right here in our experimental form.

01:40:39.086 --> 01:40:45.386
We see how our things can be included and how we can take our many processes forward.

01:40:45.386 --> 01:40:50.166
Our standard options show how we will best include our own memory.

01:40:50.166 --> 01:40:53.206
First is the main Enable Memories.

01:40:53.206 --> 01:40:56.846
Second is our Good Tool Assisted Memories.

01:40:56.846 --> 01:41:02.146
We can also involve Tool Assisted Memories and involve all our process or workability

01:41:02.146 --> 01:41:04.306
in it.

01:41:04.306 --> 01:41:07.626
Next thing is our own custom prompt libraries.

01:41:07.626 --> 01:41:10.126
What is a good prompt library?

01:41:10.126 --> 01:41:15.566
I will tell you first that our prompt library is a great reusable prompt hub.

01:41:15.566 --> 01:41:19.466
In this we can do our text discussion multiple times.

01:41:19.466 --> 01:41:22.946
We can do multiple workings for our single tool.

01:41:22.946 --> 01:41:26.146
We must see one more thing here.

01:41:26.146 --> 01:41:31.286
From the ChatGPT side, there is no prompt library available here yet.

01:41:31.286 --> 01:41:34.726
We have clear information about basic prompting.

01:41:34.726 --> 01:41:39.186
But if I talk about the Claude code, there is a distinct prompt library available.

01:41:39.186 --> 01:41:45.326
We can go there and see the many prompts are collected from the various Anthropic guides.

01:41:45.326 --> 01:41:50.926
This includes our common workflows and best practices, and how Anthropic teams take Claude

01:41:50.926 --> 01:41:53.386
code forward.

01:41:53.386 --> 01:41:57.966
If I want, we can also see the core understand prompts.

01:41:57.966 --> 01:42:04.486
We see how we can use our own prompts if we need a new prompt for git, release, data,

01:42:04.486 --> 01:42:06.486
automate or product.

01:42:06.486 --> 01:42:11.486
A set number of proper prompts are available for every single thing.

01:42:11.486 --> 01:42:14.486
We can reuse them multiple times over.

01:42:14.486 --> 01:42:19.486
We can utilise multiple variations or our many functions.

01:42:19.486 --> 01:42:23.486
This very same thing is available here in our Claude,

01:42:23.486 --> 01:42:31.486
but if we go to our codex, then until now we do not have these full prompt libraries available.

01:42:31.486 --> 01:42:37.006
We can do one other good thing here. We can come right here and ask a prompt question.

01:42:37.966 --> 01:42:43.006
If we go into ChatGPT and for our codecs we include our own best prompts,

01:42:43.646 --> 01:42:47.326
I can say I want a whole new prompt library for my codecs.

01:42:48.446 --> 01:42:52.926
It will then give a good reusable clean codecs prompt library.

01:42:54.046 --> 01:43:01.326
Inside it we have all our good useful prompts. We have our bug fixes, text test generator,

01:43:01.326 --> 01:43:11.006
code review, refactoring, feature builder, API design, performance optimization and security audit prompt.

01:43:12.046 --> 01:43:14.606
All these things will involve in that exact thing.

01:43:15.886 --> 01:43:22.126
From there we will take and use it well. These various things are included in our entire core

01:43:22.126 --> 01:43:29.166
system on a large scale. We must look at all these many things on a large scale to see how we can

01:43:29.166 --> 01:43:35.646
reuse them. We will copy it and come inside this main system to use all our many prompts.

01:43:36.686 --> 01:43:42.846
We will not use these exact things but besides this we have all our 12 core prompts.

01:43:44.046 --> 01:43:51.406
As we go forward our prompt library will increase even more. From 1 to 12 our many different options

01:43:51.406 --> 01:43:58.366
will be used and we will include them. These things are used very much inside the entire system.

01:43:59.813 --> 01:44:04.053
With this, we have a lot of great automation in our work on a large scale.

01:44:04.753 --> 01:44:06.153
We can use that well.

01:44:07.113 --> 01:44:11.133
I will tell you, we also have cool automations here on the side.

01:44:11.133 --> 01:44:16.673
We can run our day brief, week review or smart project monitor.

01:44:17.873 --> 01:44:22.353
But besides that, if we look at our cool templates, we have very many.

01:44:22.813 --> 01:44:24.953
Now our next discussion relates to integration.

01:44:25.913 --> 01:44:30.053
We will see how to perform AI-enhanced CI slash CD.

01:44:30.993 --> 01:44:35.333
First, I will explain the full definition of CI slash CD.

01:44:36.353 --> 01:44:38.913
CI stands for continuous integration.

01:44:38.913 --> 01:44:43.033
CD stands for continuous delivery and deployment.

01:44:44.333 --> 01:44:49.073
Usually, when enterprise-level workflow loops run, we have multiple projects.

01:44:49.953 --> 01:44:57.553
We have standalone projects, collaborative projects, or autonomous projects connected to multiple companies, industries, and businesses.

01:44:58.413 --> 01:45:01.493
For them, we must look at integration and deployment.

01:45:02.033 --> 01:45:07.613
This is a DevOps methodology that automates building, testing, and releasing software.

01:45:07.613 --> 01:45:10.413
We can discuss this as automation.

01:45:11.413 --> 01:45:17.093
This pipeline allows development teams to ship code updates frequently, safely and reliably,

01:45:17.533 --> 01:45:19.933
while catching bugs early in the development cycle.

01:45:21.113 --> 01:45:26.893
Usually we do CI slash CD at an industrial or enterprise level where we need automation.

01:45:28.013 --> 01:45:30.273
First we have continuous integration.

01:45:31.273 --> 01:45:35.533
It is a practice where developers regularly merge their code into a central repository

01:45:35.533 --> 01:45:42.093
like GitHub or GitLab. Every time code is merged, an automated system builds the application

01:45:42.093 --> 01:45:48.293
and runs tests until the integration finishes. This ensures that the new code does not break

01:45:48.293 --> 01:45:55.793
the existing code base. It allows teams to catch errors instantly. Then we have continuous delivery

01:45:55.793 --> 01:46:04.173
versus continuous deployment. How can we use CI slash CD? First, it gives a faster time to market.

01:46:04.173 --> 01:46:09.733
New features and bug fixes reach users in hours instead of weeks or months.

01:46:10.733 --> 01:46:14.853
There are fewer bugs, easier rollbacks and better developer productivity.

01:46:16.133 --> 01:46:23.773
CI slash CD pipelines can be used in GitHub Actions, GitLab CI, Jenkins and Circle CI.

01:46:24.573 --> 01:46:27.173
I will search for codecs on Google now.

01:46:27.173 --> 01:46:34.633
For example, if I share here that I want this in Codex, then we can also do that, how it becomes possible.

01:46:35.933 --> 01:46:42.973
Integrating the Codex command line into the pipeline enables OpenAI Codex to automatically evaluate build failures.

01:46:43.973 --> 01:46:49.513
It analyses vulnerability scans and proposes minimal changes required to make the tests pass.

01:46:50.133 --> 01:46:52.653
It executes code quality checks directly.

01:46:52.653 --> 01:46:56.633
It also generates remediation patches or pull requests.

01:46:57.173 --> 01:47:03.873
Usually, when we talk about our process, we can perform CI slash CD in multiple forms

01:47:03.873 --> 01:47:06.113
inside our projects.

01:47:06.113 --> 01:47:11.173
Here in this interface and outside it, if I go directly to the terminal, I can run the

01:47:11.173 --> 01:47:14.593
CI slash CD pipeline.

01:47:14.593 --> 01:47:16.053
How can I do this?

01:47:16.053 --> 01:47:20.013
First, I will search for Codex CLI.

01:47:20.013 --> 01:47:24.093
The developer platform will open, which we can access directly.

01:47:24.093 --> 01:47:26.033
Here we must install it.

01:47:26.033 --> 01:47:29.593
I will come here and command the system to install Codex.

01:47:29.593 --> 01:47:32.493
We will copy and paste the required command.

01:47:32.493 --> 01:47:35.693
You will see that Codex is already set up here.

01:47:35.693 --> 01:47:39.053
Because of this, we do not need to install it again.

01:47:39.053 --> 01:47:43.153
We simply type our Codex command and it will start running.

01:47:43.153 --> 01:47:45.233
You have seen this here too.

01:47:45.233 --> 01:47:50.093
Whenever we give a command, we have a terminal option available on the side.

01:47:50.093 --> 01:47:54.493
Inside this, we can automatically initiate our working process.

01:47:54.493 --> 01:47:59.253
We also have a browser option to run CI-cd pipelines.

01:47:59.253 --> 01:48:05.253
Usually, continuous integration and continuous deployment have become a foundation of modern

01:48:05.253 --> 01:48:07.253
software engineering.

01:48:07.253 --> 01:48:14.833
Traditional CI-cd pipelines automate the building, testing and deployment processes.

01:48:14.833 --> 01:48:19.633
This reduces manual effort and ensures consistent software delivery.

01:48:19.633 --> 01:48:27.093
With the introduction of AI-powered development tools like OpenAI, Enhanced CI and CD introduces

01:48:27.093 --> 01:48:31.393
a new layer of intelligence into the software delivery lifecycle.

01:48:31.393 --> 01:48:37.093
Instead of merely reporting failures, AI systems can investigate the root cause.

01:48:37.093 --> 01:48:42.333
They propose correlations and create pull requests containing fixes.

01:48:42.333 --> 01:48:47.133
This dramatically reduces the time developers spend troubleshooting failed builds.

01:48:47.133 --> 01:48:52.073
It allows engineering teams to focus on high value work such as feature development and

01:48:52.073 --> 01:48:54.573
architectural improvement.

01:48:54.573 --> 01:48:57.013
Let me show you a simple example.

01:48:57.013 --> 01:48:59.373
We can take any system here.

01:48:59.373 --> 01:49:03.333
When we give a prompt, you can see our working process begins.

01:49:03.333 --> 01:49:07.233
We get options to debug an issue or review a plan.

01:49:07.233 --> 01:49:12.013
I will select GitHub and ask it to review the newest repository.

01:49:12.013 --> 01:49:13.933
The newest repository will appear.

01:49:13.933 --> 01:49:17.933
Then, I will command it to analyse the latest pull request.

01:49:17.933 --> 01:49:20.933
It must generate unit tests for newly added functions,

01:49:20.933 --> 01:49:23.933
modified business logic and edge cases

01:49:23.933 --> 01:49:26.933
to improve our error handling completely.

01:49:26.933 --> 01:49:28.933
As soon as I include this,

01:49:28.933 --> 01:49:31.933
the error handling scenarios will become much better.

01:49:31.933 --> 01:49:36.933
The other responses will also appear here for us to analyse directly.

01:49:36.933 --> 01:49:39.933
Usually, the GitHub workflow is infused here.

01:49:39.933 --> 01:49:45.933
Inside the GitHub workflow, we can directly use our other generations or processes.

01:49:45.933 --> 01:49:49.933
Our other regions and our understanding will also appear.

01:49:49.933 --> 01:49:52.933
Side by side, I must tell you another thing.

01:49:52.933 --> 01:49:58.933
We usually face a concern about how to check our processes inside out on a larger scale.

01:49:58.933 --> 01:50:01.933
We will see that in a much better form now.

01:50:01.933 --> 01:50:07.933
In the CI slash CD pipeline, you can see the local workspace is empty.

01:50:07.933 --> 01:50:13.133
The GitHub account is authenticated, but Git is not available.

01:50:13.133 --> 01:50:18.773
If we set up these things, we can cross-check our CI slash CD pipelines.

01:50:18.773 --> 01:50:23.853
We prepare a repository and use the CI slash CD pipeline perfectly.

01:50:23.853 --> 01:50:28.013
Here, I will give you the example of a pipeline.

01:50:28.013 --> 01:50:33.053
If you prepare a pipeline of build, which have a request, it has many stage such as

01:50:33.053 --> 01:50:36.413
names and tests will appear here.

01:50:36.413 --> 01:50:41.873
If you connect codecs here, then our AI tasks can work side by side with it.

01:50:41.873 --> 01:50:46.613
Our next topic is putting codecs into our work process.

01:50:46.613 --> 01:50:50.033
This means adding codecs to our build system.

01:50:50.033 --> 01:50:53.933
When we do this, the system helps us find problems.

01:50:53.933 --> 01:50:59.933
If a build stops working or a task breaks, the tool sees the code quality issues.

01:50:59.933 --> 01:51:04.853
Before, people had to look at every single problem by hand.

01:51:04.853 --> 01:51:08.613
Now the system looks at the failures for us.

01:51:08.613 --> 01:51:12.493
It gives ideas to fix them and creates tests.

01:51:12.493 --> 01:51:16.093
It can even make pull requests with good answers.

01:51:16.093 --> 01:51:20.173
In a normal process, a person sends code to GitHub.

01:51:20.173 --> 01:51:24.833
Then our complete system starts running automatically.

01:51:24.833 --> 01:51:27.453
Things begin to work on their own.

01:51:27.453 --> 01:51:30.373
We usually watch these actions in our deployment area.

01:51:30.373 --> 01:51:34.733
For enterprises, this saves a lot of time.

01:51:34.733 --> 01:51:38.793
do not have to fix the same small problems again.

01:51:38.793 --> 01:51:42.473
The Codex Assistant helps keep the work active.

01:51:42.473 --> 01:51:46.173
It understands the whole process of how things run.

01:51:46.173 --> 01:51:49.553
We like having a place without mistakes.

01:51:49.553 --> 01:51:52.613
Now let us look at consistency.

01:51:52.613 --> 01:51:55.973
This is a very important benefit.

01:51:55.973 --> 01:51:59.373
Sometimes working directly with these pipelines can be hard.

01:52:01.754 --> 01:52:08.754
First, I will go to our plugins section. We can see the GitHub plugin here.

01:52:08.754 --> 01:52:13.174
Next, I will search for codecs in the bar.

01:52:13.174 --> 01:52:18.254
We see many results, but I want to find it in the profile settings.

01:52:18.254 --> 01:52:24.994
I look at the list of options like packages, co-pilot, pages and security.

01:52:24.994 --> 01:52:27.674
Here I will search for the codecs.

01:52:27.674 --> 01:52:29.954
And here we have our codecs.

01:52:29.954 --> 01:52:33.754
We can also search in GitHub or settings.

01:52:33.754 --> 01:52:36.474
Then I decide to grant access.

01:52:36.474 --> 01:52:39.714
To do this, I open our repository.

01:52:39.714 --> 01:52:43.234
I click on the code button and copy the link.

01:52:43.234 --> 01:52:48.174
I will ask the chat, do you have access to this project?

01:52:48.174 --> 01:52:53.614
The system will now check if it can reach the repository and provide us with it.

01:52:53.614 --> 01:52:58.334
And how we can initiate our working or a larger scale.

01:52:58.334 --> 01:53:01.234
Sometimes we have to look at these details ourselves.

01:53:01.234 --> 01:53:08.234
Also, we can take a complete process out here and our generation will be completed in that.

01:53:08.234 --> 01:53:11.434
This is usually present at a lesser extent.

01:53:11.434 --> 01:53:15.714
But now we will initiate a full-fledged process here.

01:53:15.714 --> 01:53:20.834
You will see that it has told us here that yes, I can access the repository.

01:53:20.834 --> 01:53:24.714
The access to our repository has also arrived here.

01:53:24.714 --> 01:53:30.914
The second thing it said is that our default branch is main, visibility is public and effective

01:53:30.914 --> 01:53:38.154
permissions in the session are admin, maintain, push, pull and triage. I can

01:53:38.154 --> 01:53:43.534
simply say here that we now have to include an agents.md file inside this.

01:53:43.534 --> 01:53:49.394
This will directly include it and give it to us. But the thing is we cannot

01:53:49.394 --> 01:53:55.174
create things inside this. So right now we will only cross-check our agents.md

01:53:55.174 --> 01:54:00.234
file here to see if it is directly available to us or not. These are our

01:54:00.234 --> 01:54:06.534
things. I will now take our full detailed discussion. You will see that directly

01:54:06.534 --> 01:54:13.474
after just one second our agents.md file has been included here. Inside it, as you

01:54:13.474 --> 01:54:20.814
see, git isn't available. So here, after inspecting, it has directly arrived. I can

01:54:20.814 --> 01:54:25.014
give access here to directly push the code to see how we can improve or

01:54:25.014 --> 01:54:30.474
include things on a large scale. Side by side another very important thing is

01:54:30.474 --> 01:54:36.294
running here. Usually in a base pipeline I could not run git push origin here

01:54:36.294 --> 01:54:41.254
because the directory is not a git repository. Git is not installed in our

01:54:41.254 --> 01:54:48.134
current shell. Let us suppose we want to install git. How can we do that? First of

01:54:48.134 --> 01:54:53.774
all we will open our PowerShell here. We come inside this one. Here I say our

01:54:53.774 --> 01:55:00.354
PowerShell. This is our PowerShell window. Coming directly inside PowerShell, we will

01:55:00.354 --> 01:55:06.774
state our Git version here. You are seeing that the Git version is available to us here.

01:55:06.774 --> 01:55:12.114
Let us suppose we want to install our Git. If we use this directly, you are seeing that

01:55:12.114 --> 01:55:17.934
now we will say we want to install Git with our basic widget. Automatically our widget

01:55:17.934 --> 01:55:23.754
will be installed here. On the basis of that widget, we will take our things inside running.

01:55:23.774 --> 01:55:27.774
Usually these things are not explained to us.

01:55:27.774 --> 01:55:31.774
We are just initiating our production and working on a large scale.

01:55:31.774 --> 01:55:34.774
Here it will take some time to install.

01:55:34.774 --> 01:55:37.774
Until it installs we will wait here.

01:55:37.774 --> 01:55:41.774
Now, due to some issues, our Git is not becoming active.

01:55:41.774 --> 01:55:44.774
I tried a lot to activate our Git.

01:55:44.774 --> 01:55:46.774
You are seeing the prefix.

01:55:46.774 --> 01:55:50.774
Branch prefix is working. Everything is working.

01:55:50.774 --> 01:55:59.774
We usually did not include our commit instructions, but still, it is possible that by opening these things, all these items come into working.

01:56:00.774 --> 01:56:08.774
But still, as a matter of fact, the discussion here is that when integrating codecs, organisations start in non-production environments.

01:56:09.774 --> 01:56:13.774
This allows codecs to analyse failures and generate suggestions.

01:56:13.774 --> 01:56:19.934
Once the team gains confidence in the results, they can gradually introduce more advanced workflows.

01:56:21.334 --> 01:56:26.434
These include automated pull request generations and our AI-assisted bug fixing.

01:56:27.634 --> 01:56:34.154
Overall, Codex acts as an intelligent engineering assistant inside our CI-slash-CD pipeline.

01:56:35.074 --> 01:56:37.754
It will overall help us in building all our things.

01:56:38.274 --> 01:56:41.034
These entire matters have been discussed here.

01:56:41.034 --> 01:56:48.154
An autofix workflow begins the moment a developer pushes code to a repository or submits a pull request for a review.

01:56:49.354 --> 01:57:05.374
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.

01:57:05.374 --> 01:57:11.654
In traditional software development environments, any failure in these checks would require

01:57:11.654 --> 01:57:17.254
a developer to manually investigate logs, identify the source of the issue, and implement

01:57:17.254 --> 01:57:17.794
a fix.

01:57:18.414 --> 01:57:23.994
With codex-powered autofix workflows, the process becomes significantly more efficient.

01:57:25.254 --> 01:57:29.914
Instead of merely reporting that something failed, the workflow can immediately begin

01:57:29.914 --> 01:57:32.994
analysing the problem and preparing a potential solution.

01:57:32.994 --> 01:57:41.454
This transforms CI-CD from a passive validation system into an active participant in software

01:57:41.454 --> 01:57:44.714
maintenance and quality assurance.

01:57:44.714 --> 01:57:50.814
Once a failure is detected, Codex examines all available information related to the problem.

01:57:50.814 --> 01:57:57.934
This includes error messages, build logs, test outputs, recently modified files, project

01:57:57.934 --> 01:58:05.834
documentation, repository instructions and any development guidelines defined in agents.md.

01:58:05.834 --> 01:58:10.354
By reviewing these sources together, Codex gains a much broader understanding of the

01:58:10.354 --> 01:58:14.314
issue than a simple rule-based automation tool.

01:58:14.314 --> 01:58:20.554
For example, if a login-related test starts failing after a recent update, Codex can inspect

01:58:20.554 --> 01:58:27.174
the authentication logic, compare the recent code changes, review the affected test cases

01:58:27.174 --> 01:58:31.434
and determine where the behaviour diverged from expectations.

01:58:31.434 --> 01:58:37.834
This contextual understanding is one of the major advantages of AI-assisted development workflows.

01:58:37.834 --> 01:58:43.514
After gathering the necessary information, Codex performs root cause analysis.

01:58:43.514 --> 01:58:47.734
Rather than attempting random modifications until a test passes,

01:58:47.734 --> 01:58:52.014
it tries to determine why the failure occurred in the first place.

01:58:52.014 --> 01:58:55.314
The underlying issue could be a missing import statement,

01:58:55.314 --> 01:58:58.554
a renamed function that was not updated everywhere,

01:58:58.554 --> 01:59:01.154
a changed API response structure,

01:59:01.154 --> 01:59:03.514
an incorrect configuration value,

01:59:03.514 --> 01:59:07.134
a dependency upgrade that introduced breaking changes,

01:59:07.134 --> 01:59:09.274
or a test case that no longer reflects

01:59:09.274 --> 01:59:12.134
the intended application behaviour.

01:59:12.134 --> 01:59:15.094
By identifying the actual source of the problem,

01:59:15.094 --> 01:59:18.134
codecs can generate fixes that are more accurate,

01:59:18.134 --> 01:59:21.574
maintainable, and less likely to introduce new defects

01:59:21.574 --> 01:59:23.834
elsewhere in the system.

01:59:23.834 --> 01:59:29.394
Once the root cause has been identified, Codex generates a proposed solution.

01:59:29.394 --> 01:59:35.094
A well-designed autofix workflow emphasises minimal and focused changes.

01:59:35.094 --> 01:59:39.514
The goal is not to rewrite large portions of the application, but to make the smallest

01:59:39.514 --> 01:59:43.214
possible modification that resolves the failure.

01:59:43.214 --> 01:59:49.434
This approach reduces risk and makes the resulting changes easier for developers to review.

01:59:49.434 --> 01:59:54.974
For example, if a build fails because of an incorrect import path, codecs should update

01:59:54.974 --> 02:00:00.374
only the affected import statement rather than refactoring multiple unrelated files.

02:00:01.865 --> 02:00:06.565
also provide explicit instructions to guide this process, such as requesting

02:00:06.565 --> 02:00:11.305
that only necessary files be modified, preserving existing coding conventions,

02:00:11.305 --> 02:00:16.285
and updating tests only when required to reflect legitimate behaviour changes.

02:00:17.525 --> 02:00:21.625
Following fixed generation, validation becomes the next critical step.

02:00:22.665 --> 02:00:27.525
The proposed solution is tested using the same pipeline checks that originally detected the problem.

02:00:28.605 --> 02:00:36.045
Automated builds, unit tests, integration tests, linting tools and security scans are executed again

02:00:36.045 --> 02:00:38.905
to confirm that the issue has been resolved successfully.

02:00:38.905 --> 02:00:49.885
If the validation process still detects failures, developers can provide additional context or refined instructions and allow codecs to perform another iteration.

02:00:51.285 --> 02:00:58.145
This feedback loop helps improve solution quality while ensuring that every proposed change is verified before moving forward.

02:00:59.365 --> 02:01:04.985
Even when automated validation succeeds, human review remains an essential part of the workflow.

02:01:04.985 --> 02:01:19.885
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.

02:01:21.025 --> 02:01:32.465
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.

02:01:32.465 --> 02:01:38.865
Once the fix has been approved, the changes can be merged into the main branch and included

02:01:38.865 --> 02:01:41.065
in future deployments.

02:01:41.065 --> 02:01:48.505
Over time, teams can analyse recurring issues and improve their development processes accordingly.

02:01:48.505 --> 02:01:56.205
Repository instructions, testing strategies, agents.md guidelines and CI-CD configurations

02:01:56.205 --> 02:02:02.005
can be updated to help codecs handle similar situations more effectively in the future.

02:02:02.005 --> 02:02:07.505
As a result, autofix workflows not only resolve immediate problems, but also contribute to

02:02:07.505 --> 02:02:12.845
continuous improvement across the software development lifecycle, enabling teams to deliver

02:02:12.845 --> 02:02:18.625
higher quality software faster, while reducing the manual effort required to maintain complex

02:02:18.625 --> 02:02:19.625
systems.

02:02:19.625 --> 02:02:25.045
Now, the discussion we have is related to configuring automated bug resolution.

02:02:25.045 --> 02:02:27.585
We can say this on a large scale.

02:02:27.585 --> 02:02:32.345
In our codecs, along with other things, a discussion was going on.

02:02:32.345 --> 02:02:35.765
This is most valuable for enterprise use cases.

02:02:35.765 --> 02:02:42.725
For OpenAI codecs, instead of developers manually investigating every test field, linting error,

02:02:42.725 --> 02:02:49.085
securing warnings or production defects, codecs can analyse the issue, identify the affected

02:02:49.085 --> 02:02:55.265
files, generate a proposed fix and create a pull request for human review.

02:02:55.265 --> 02:03:00.065
This significantly reduces the time spent on repetitive maintenance tasks, while allowing

02:03:00.065 --> 02:03:05.665
focus for engineers to concentrate on high-level architectural business problems.

02:03:05.665 --> 02:03:13.285
In modern software teams, bugs are often discovered through CI-CD pipelines, monitoring systems,

02:03:13.285 --> 02:03:16.845
issue trackers and security scanners.

02:03:16.845 --> 02:03:21.825
Codecs can integrate into these workflows so that when an issue occurs, the AI automatically

02:03:21.825 --> 02:03:27.905
receives the failure logs, repository context, coding standards, and our project instructions.

02:03:29.105 --> 02:03:35.345
Alright, the critical aspect we have for automated bug resolution is defining clear boundaries.

02:03:36.385 --> 02:03:41.425
Enterprise organisations should never allow AI to directly deploy files into production.

02:03:42.305 --> 02:03:48.465
Instead, codecs should generate code changes, execute tests, and create pull requests that

02:03:48.465 --> 02:03:50.965
that require developer approval.

02:03:50.965 --> 02:03:53.565
This maintains governance and accountability

02:03:53.565 --> 02:03:56.465
while still benefiting from automation.

02:03:56.465 --> 02:03:59.005
Human reviewers can remain fully responsible

02:03:59.005 --> 02:04:01.025
for validating the basic logic.

02:04:01.965 --> 02:04:05.465
Now, let me tell you a very important thing.

02:04:05.465 --> 02:04:09.925
Our agents.md file plays a crucial role in the process.

02:04:09.925 --> 02:04:12.805
What happens is they provide our project specifications

02:04:12.805 --> 02:04:15.725
and instructions that guide Codex's decision making

02:04:15.725 --> 02:04:17.845
during bug resolution.

02:04:17.845 --> 02:04:27.245
These instructions define the coding conventions, testing requirements, security constraints, dependency policies and our architectural patterns.

02:04:28.385 --> 02:04:33.985
The more structured the agents.md file is, the more accurate and reliable the fixes become.

02:04:34.965 --> 02:04:40.605
Organisations must look at another thing alongside agents.md – confidence thresholds.

02:04:40.605 --> 02:04:46.805
For example, codecs may automatically fix linting errors and formatting issues, while

02:04:46.805 --> 02:04:53.745
security vulnerabilities or database-related bugs require a mandatory senior engineer review.

02:04:53.745 --> 02:04:58.905
An example of this is that first of all, we have to do this step by step.

02:04:58.905 --> 02:05:03.985
The first part of our process is to identify our bug trigger resources and define where

02:05:03.985 --> 02:05:06.485
the bug reports originate.

02:05:06.485 --> 02:05:12.545
Usually what happens is we see this in our CI slash CD builds, or we can see this in our

02:05:12.545 --> 02:05:18.665
unit tests we perform, or we can see this in our integration test failures.

02:05:18.665 --> 02:05:24.245
Sometimes issues can arise in GitHub, or our security scans can cause an issue.

02:05:24.245 --> 02:05:29.805
Alright, after that we have to identify the AI and look at the AI's fix permissions.

02:05:29.805 --> 02:05:36.425
If, let's suppose, there's a formatting issue, a linting issue, or a unit test failure,

02:05:36.425 --> 02:05:40.725
We'll automatically look at all of them, and a detailed discussion will take place regarding

02:05:40.725 --> 02:05:43.885
production incidents and everything.

02:05:43.885 --> 02:05:48.205
Agents.md is our most important file which I mentioned here.

02:05:48.205 --> 02:05:53.545
What happens in Agents.md is we can see the automated bug resolution rules.

02:05:53.545 --> 02:05:58.285
Whenever we fix a bug, we should minimize the code changes, we should never modify the

02:05:58.285 --> 02:06:04.325
database schemas, we should preserve the API contracts, add our tests for everyone, and

02:06:04.325 --> 02:06:07.405
run all of the affected test suites.

02:06:07.405 --> 02:06:11.945
We must explain the root cause and also create a pull request summary.

02:06:11.945 --> 02:06:17.205
You can see all of this in agents.md, where we address the bugs, and multiple things are

02:06:17.205 --> 02:06:18.205
included.

02:06:18.205 --> 02:06:25.805
Then, if I, let's suppose, perform proper CI slash CD integration, meaning after identifying

02:06:25.805 --> 02:06:29.525
the trigger sources, we've defined our AI.

02:06:29.525 --> 02:06:34.705
Then if I say we want to configure CI slash CD here, what I'll do first is take you to

02:06:34.705 --> 02:06:36.985
the configuration.

02:06:36.985 --> 02:06:42.165
In the configuration workflow, we first discuss the build failure, then we understand our

02:06:42.165 --> 02:06:48.725
codex investigation, generate the fix, run the tests, create the pull request, develop

02:06:48.725 --> 02:06:52.725
our reviews and also then merge our workings.

02:06:52.725 --> 02:06:54.825
So this will come here.

02:06:54.825 --> 02:07:00.065
Then the next and most important process, which will be discussed in our setup here,

02:07:00.065 --> 02:07:02.845
will be our validation of fixes.

02:07:02.845 --> 02:07:09.705
Here we will require our unit tests, integration tests, security scans, code reviews and our

02:07:09.705 --> 02:07:12.065
build verifications.

02:07:12.065 --> 02:07:15.505
These will directly be used to approve our process.

02:07:15.505 --> 02:07:21.385
Alright, now as an example, if I go into Codex and open a new chat, what will happen in our

02:07:21.385 --> 02:07:25.845
chat is I'll say directly that a GitHub action has failed. We'll include the

02:07:25.845 --> 02:07:30.505
repository name directly. We have our failure logs here and the tasks are

02:07:30.505 --> 02:07:35.545
being discussed the most here. Alright, after that we have our unit test

02:07:35.545 --> 02:07:40.445
failure which we will use. After that, whatever automated bug resolution we

02:07:40.445 --> 02:07:45.565
have directly we will configure it. We will discuss a OneGo project today. We

02:07:45.565 --> 02:07:50.905
will direct a full repository in our OneGo project. First we will create all

02:07:50.905 --> 02:07:56.185
project code and details. After that we will check our iterations and possible

02:07:56.185 --> 02:08:00.827
improvements. Then we will use GitHub and Codex.

02:08:01.827 --> 02:08:05.827
Here is our Codex. We open Codex.

02:08:05.827 --> 02:08:09.827
Inside Codex, we generate a full project before using prompts.

02:08:09.827 --> 02:08:13.827
In Codex, we must include the SetAgents file.

02:08:13.827 --> 02:08:17.227
But we will first exit this project.

02:08:17.227 --> 02:08:20.227
Then we will build a new project here.

02:08:20.227 --> 02:08:23.087
I will close this one.

02:08:23.087 --> 02:08:26.627
We close it and build a new project again.

02:08:26.627 --> 02:08:28.987
You see projects are available here.

02:08:28.987 --> 02:08:32.507
I can organise them or start from scratch.

02:08:32.507 --> 02:08:35.827
We will name our project OneGo.

02:08:35.827 --> 02:08:40.847
In this project we will build a complete application with everything.

02:08:40.847 --> 02:08:43.467
First we will pin this project.

02:08:43.467 --> 02:08:46.967
After pinning, we open it in our Explorer.

02:08:46.967 --> 02:08:50.367
Our Explorer has no file inside.

02:08:50.367 --> 02:08:54.327
Later, all generations will come into this file.

02:08:54.327 --> 02:08:57.387
We have our VS Code and Terminal.

02:08:57.387 --> 02:09:01.547
I told you before we can use codecs in our terminal.

02:09:01.547 --> 02:09:04.927
In VS Code, our cursor is available.

02:09:04.927 --> 02:09:07.287
I will first tell you the plan.

02:09:07.287 --> 02:09:09.967
We will open our plan mode.

02:09:09.967 --> 02:09:12.207
We have no plugins yet.

02:09:12.207 --> 02:09:14.887
We will not use the browser much.

02:09:14.887 --> 02:09:18.847
We will use the 5.4 model in our GPT.

02:09:18.847 --> 02:09:22.367
We will use the medium 5.4 model.

02:09:22.367 --> 02:09:26.267
We will use fast speed here, not default speed.

02:09:26.267 --> 02:09:28.647
It will be used here.

02:09:28.647 --> 02:09:31.427
We will not connect GitHub for now.

02:09:31.427 --> 02:09:34.927
I will say in one go that I am going to make a project

02:09:34.927 --> 02:09:37.667
about a health care application.

02:09:37.667 --> 02:09:40.627
Can you plan a project for me?

02:09:40.627 --> 02:09:42.207
Project planning will start here.

02:09:43.207 --> 02:09:45.347
First, it will settle output resources.

02:09:46.467 --> 02:09:47.767
I will not include them now.

02:09:48.807 --> 02:09:50.587
We look at current workspace.

02:09:51.767 --> 02:09:53.607
You see nothing is there in workspace.

02:09:55.207 --> 02:09:58.707
Who is the primary user for the first version of the healthcare app?

02:09:59.367 --> 02:10:01.267
We have patients and doctors.

02:10:02.167 --> 02:10:05.507
I will say, this application is for patients.

02:10:06.367 --> 02:10:09.027
We want to build an application for our patients.

02:10:09.027 --> 02:10:15.487
What kind of first release do you want to plan? MVP or balanced or ambitious?

02:10:16.367 --> 02:10:23.607
I will choose MVP. What is our delivery target? We want to build a web application here.

02:10:24.167 --> 02:10:28.527
I will not build a mobile application. I will build a web app here.

02:10:29.247 --> 02:10:35.547
The current decision is clear. Patient facing, MVP sized and optimised for a web app.

02:10:35.547 --> 02:10:38.807
I still need to lock the feature set.

02:10:40.067 --> 02:10:41.387
Now we have our feature sets.

02:10:42.147 --> 02:10:44.347
Which feature bundle should define the MVP?

02:10:45.527 --> 02:10:46.567
Booking and records?

02:10:47.327 --> 02:10:49.287
We will use this simple option.

02:10:50.787 --> 02:10:53.947
How should the plan treat healthcare compliance in the first version?

02:10:54.867 --> 02:10:58.167
We will use HIPAA ready design, which is recommended.

02:10:59.167 --> 02:11:03.027
We can also use full compliance track or lightweight prototype.

02:11:03.027 --> 02:11:07.447
How much external integration should the first plan include?

02:11:08.727 --> 02:11:11.207
I will say minimal integration will be included.

02:11:12.147 --> 02:11:13.527
These things are recommended here.

02:11:14.347 --> 02:11:16.527
Through them our entire process comes.

02:11:18.007 --> 02:11:19.347
What will be the delivery timeline?

02:11:20.327 --> 02:11:22.847
What will be the delivery timeline for our project?

02:11:23.967 --> 02:11:26.887
I will say I want it in an urgent manner.

02:11:27.867 --> 02:11:30.987
This is a fourth part where we can include what we want.

02:11:30.987 --> 02:11:33.747
What team should this plan assume?

02:11:35.007 --> 02:11:36.147
Our small team is here.

02:11:37.127 --> 02:11:40.327
Instead of a small team, we can choose Solo Builder.

02:11:41.007 --> 02:11:42.967
Our solo builder is here now.

02:11:44.327 --> 02:11:45.627
What kind of plan do you need?

02:11:46.107 --> 02:11:47.947
Build plan or business build?

02:11:48.727 --> 02:11:51.127
We will work with a simple build plan.

02:11:52.107 --> 02:11:54.667
Now it reduces the project scope and other things.

02:11:55.607 --> 02:11:58.107
You see, multiple questions are asked here.

02:11:58.107 --> 02:12:02.907
For a solo builder, what does urgent mean for the first usable release?

02:12:03.847 --> 02:12:05.427
We will answer one week.

02:12:06.327 --> 02:12:07.947
We will include one week here.

02:12:09.007 --> 02:12:10.447
Our plan will come here.

02:12:11.547 --> 02:12:15.327
Build a patient-facing WebMVP for a solo builder

02:12:15.327 --> 02:12:18.327
optimised for one week urgent prototype

02:12:18.327 --> 02:12:22.107
while keeping the design HIPAA aware and future ready

02:12:22.107 --> 02:12:24.047
for real healthcare data handling.

02:12:24.047 --> 02:12:28.267
I will read the plan once, then we will implement it.

02:12:29.267 --> 02:12:31.447
I am saying that we have the entire process.

02:12:32.647 --> 02:12:35.267
We say our product definition is also happening here.

02:12:36.547 --> 02:12:41.387
After product definition, our recommended MVP features have also arrived here.

02:12:42.687 --> 02:12:45.387
Frontend and backend have come in our technical approach.

02:12:46.307 --> 02:12:50.707
I will tell it that I want just a working frontend and minimal backend.

02:12:50.707 --> 02:12:57.627
Also, it should be just HTML and CSS with JS logics.

02:12:57.627 --> 02:13:00.787
We want our product in a simpler way.

02:13:00.787 --> 02:13:02.927
All these things will come here.

02:13:02.927 --> 02:13:05.387
The stack has arrived.

02:13:05.387 --> 02:13:08.207
What should a minimal backend do?

02:13:08.207 --> 02:13:11.567
We can use a tiny mock API.

02:13:11.567 --> 02:13:14.827
We can use a basic form backend.

02:13:14.827 --> 02:13:18.347
We will not use any real backend.

02:13:18.347 --> 02:13:21.147
How should the frontend be structured?

02:13:21.147 --> 02:13:25.907
I can say a multi-page application will be required here.

02:13:25.907 --> 02:13:29.147
What level of frontend quality is needed?

02:13:29.147 --> 02:13:34.167
I will say we need a portfolio quality user interface.

02:13:34.167 --> 02:13:36.727
Our plan is created.

02:13:36.727 --> 02:13:41.447
You can see we have JSON objects and local storage here.

02:13:41.447 --> 02:13:46.687
Key changes are to reframe the project as a frontend prototype, not a production ready

02:13:46.687 --> 02:13:47.687
option.

02:13:47.687 --> 02:13:50.687
Now we can implement this plan.

02:13:50.687 --> 02:13:53.687
During implementation, it will bring our coding.

02:13:53.687 --> 02:13:56.687
It is checking the workspace shape.

02:13:56.687 --> 02:14:01.687
We will look at static app files and shared styles and JavaScript layers here.

02:14:01.687 --> 02:14:06.687
We will also check the open file to see what things are discussed in it.

02:14:06.687 --> 02:14:10.687
First it took basic index HTML.

02:14:10.687 --> 02:14:13.687
We will open our file explorer.

02:14:13.687 --> 02:14:16.687
We will open 1Go from Documents.

02:14:16.687 --> 02:14:22.187
For the time being, we have no file or format available in one go.

02:14:22.187 --> 02:14:25.387
But later our files will appear.

02:14:25.387 --> 02:14:31.687
It has confirmed our HTML pages and state stylesheet and JS layer.

02:14:31.687 --> 02:14:35.007
In plugins, our GitHub is not installed yet.

02:14:35.007 --> 02:14:39.367
I will go to our codec settings to install GitHub once.

02:14:39.367 --> 02:14:41.407
We will go to our settings.

02:14:41.407 --> 02:14:43.947
You can see our connections here.

02:14:43.947 --> 02:14:47.867
In settings, you can see we have our connections.

02:14:47.867 --> 02:14:53.047
Besides connections, we have our MCP servers here which we can use.

02:14:53.047 --> 02:14:56.587
We also use plugins here which we can connect.

02:14:56.587 --> 02:14:58.907
I will go to our plugins.

02:14:58.907 --> 02:15:01.567
You can see our plugins are available.

02:15:01.567 --> 02:15:06.127
Where all our other details are, we will include our direct option.

02:15:06.127 --> 02:15:09.007
In configuration we have our plugins.

02:15:09.007 --> 02:15:11.827
We can use user configuration.

02:15:11.827 --> 02:15:17.227
We have sandbox settings and current version and everything is working.

02:15:17.227 --> 02:15:20.807
In MCP servers our plugins have arrived.

02:15:20.807 --> 02:15:25.887
We can also see our most used plugin here and how it is discussed.

02:15:25.887 --> 02:15:28.867
Then we have plugins inside our hooks.

02:15:28.867 --> 02:15:33.907
And we have our computer use plugin, so any app and our Google Chrome browser has also

02:15:33.907 --> 02:15:35.787
arrived here.

02:15:35.787 --> 02:15:39.147
I will bring our plugins into our settings search.

02:15:39.147 --> 02:15:41.027
These are our plugins.

02:15:41.027 --> 02:15:43.587
I will use GitHub here.

02:15:43.587 --> 02:15:47.447
When I connect GitHub, you can see all details have arrived here.

02:15:47.447 --> 02:15:51.647
Because we are using the Michael DuPont account, we will bring the same Michael DuPont email

02:15:51.647 --> 02:15:53.187
here.

02:15:53.187 --> 02:15:55.707
We click on Add Plugin.

02:15:55.707 --> 02:15:57.767
Adding GitHub will appear.

02:15:57.767 --> 02:15:59.187
It is approved by our admin.

02:15:59.908 --> 02:16:03.828
We will go to Connect and continue to GitHub.

02:16:03.828 --> 02:16:07.908
We will get our detail in our browser, which we will use.

02:16:07.908 --> 02:16:10.708
You will see that GitHub is now connected.

02:16:10.708 --> 02:16:13.828
We can try it out in the chat too.

02:16:13.828 --> 02:16:19.828
In GitHub, we have our repositories and pull requests, and all things have arrived.

02:16:19.828 --> 02:16:22.828
Our GitHub access is now connected.

02:16:22.828 --> 02:16:26.828
We have our repositories and issues, and pull requests inside it.

02:16:26.828 --> 02:16:32.828
We have 97 actions available in the GitHub app related to Read and Write.

02:16:32.828 --> 02:16:36.828
We can use it for Read and Write functions.

02:16:36.828 --> 02:16:40.828
If we want to try it in the chat, we can do that too.

02:16:40.828 --> 02:16:44.988
After this, we go to our healthcare application.

02:16:44.988 --> 02:16:49.248
You will see that a total of 9 files generated here.

02:16:49.248 --> 02:16:52.768
You can see in these files we have our app.js.

02:16:52.768 --> 02:16:57.648
If I go here and reload it, our file structure is still not very strong.

02:16:57.648 --> 02:17:01.948
But you will see that all our assets are available here.

02:17:01.948 --> 02:17:03.908
Index and records.

02:17:03.908 --> 02:17:07.508
And all these files are generated here overall.

02:17:07.508 --> 02:17:12.508
Now it also told us it found a portability issue in the static assets.

02:17:12.508 --> 02:17:16.548
A few non-ASCII characters slipped into the labels.

02:17:16.548 --> 02:17:18.168
It will run them.

02:17:18.168 --> 02:17:20.328
The command is normalised.

02:17:20.328 --> 02:17:23.408
I am loading the normal browser.

02:17:23.408 --> 02:17:26.948
Now we will connect things in our in-app browser.

02:17:26.948 --> 02:17:29.688
You will see I did not give any prompt.

02:17:29.688 --> 02:17:32.868
I did not give any prompt on a large scale.

02:17:32.868 --> 02:17:36.988
I gave a basic prompt that I need a healthcare application.

02:17:36.988 --> 02:17:42.068
It planned it and took multiple recommendations from me during planning.

02:17:42.068 --> 02:17:46.508
In the end it generated all our assets in one go.

02:17:46.508 --> 02:17:51.948
Appointments and dashboard and doctors and index and record files are generated.

02:17:51.948 --> 02:17:55.188
Now browser automation has also arrived.

02:17:55.188 --> 02:17:59.228
We have all files for implementation and we can run prototypes.

02:17:59.228 --> 02:18:02.368
Here is our documentation.

02:18:02.368 --> 02:18:09.748
Now if I open our file explorer and go to documents and one go, our folder is empty right now.

02:18:09.748 --> 02:18:14.788
But if I look at our index.html here in the file explorer, you will see that we have a

02:18:14.788 --> 02:18:17.028
file available.

02:18:17.028 --> 02:18:21.908
If I open this file in our browser, you will see our project has arrived.

02:18:21.908 --> 02:18:24.788
It is a healthcare app prototype.

02:18:24.788 --> 02:18:29.808
We are accessing healthcare here with appointments and records and reminders.

02:18:29.808 --> 02:18:33.048
When we want to enter a dashboard we sign in here.

02:18:33.048 --> 02:18:35.488
Our doctors have arrived in it.

02:18:35.488 --> 02:18:38.268
After doctors our appointments have arrived.

02:18:38.268 --> 02:18:40.628
And our records have arrived.

02:18:40.628 --> 02:18:43.968
This is our whole process as you can see.

02:18:43.968 --> 02:18:47.768
If we want we can confirm any other appointment too.

02:18:47.768 --> 02:18:50.108
I will confirm an appointment.

02:18:50.108 --> 02:18:52.528
I will say I have a heart pain.

02:18:52.528 --> 02:18:54.688
I will just include a reason.

02:18:54.688 --> 02:18:58.288
When we include this part our second appointment will come.

02:18:58.288 --> 02:19:00.908
This means our page is loading.

02:19:00.908 --> 02:19:07.008
If we go to records we have our medications and allergies and recent visits available.

02:19:07.008 --> 02:19:11.648
If we go to doctors, all doctors we have are listed here.

02:19:11.648 --> 02:19:13.968
Then comes our dashboard.

02:19:13.968 --> 02:19:18.628
Inside this dashboard we have our current summary showing the plan and conditions and

02:19:18.628 --> 02:19:20.548
recent visits.

02:19:20.548 --> 02:19:26.628
Our insurance card and hydration reminder and medication review are all available.

02:19:26.628 --> 02:19:32.148
Members and unwanted things are available here. If we want we can build a new demo

02:19:32.148 --> 02:19:37.848
account instead of demo credentials. I will close this one. I will give a prompt

02:19:37.848 --> 02:19:42.588
here. I liked my first draft and I want to make this an official app for the

02:19:42.588 --> 02:19:48.548
patients. Add some vibrant health-based colors in the website. Also try to make

02:19:48.548 --> 02:19:53.948
it more real. Our prototype is very much liked. In the prototype our login and

02:19:53.948 --> 02:19:59.388
doctors are very real. But this dashboard has some issues. When I bring it to the phone

02:19:59.388 --> 02:20:05.368
view it does not look special. It has many issues. This dashboard does not go higher

02:20:05.368 --> 02:20:11.808
from here. The second thing is our login panel goes too far back. If we go to our network

02:20:11.808 --> 02:20:18.788
inside the console, nothing special is loading. This means we have no back end. It created

02:20:18.788 --> 02:20:25.208
a working front end for us. I have given a prompt to update our prototype. You see we

02:20:25.208 --> 02:20:31.368
have our browser available in plugins. Due to this we can use it. It says I am updating

02:20:31.368 --> 02:20:37.708
the prototype. It is updating the prototype towards a more launch-oriented Alaska patient

02:20:37.708 --> 02:20:44.148
app. First I am verifying the current front end structure. Then I will replace the mock

02:20:44.148 --> 02:20:50.148
positioning with real Alaska provider data. It will shift the design towards a premium

02:20:50.148 --> 02:20:55.868
Apple adjacent aesthetic without copying Apple owned logos or icons, because we cannot

02:20:55.868 --> 02:21:02.348
copy the icons. But if we want, we can copy aesthetics based on an ecosystem. And we are

02:21:02.348 --> 02:21:08.828
going to do the same thing here. This thing will be induced here. In styles you see we

02:21:08.828 --> 02:21:14.328
we have many changes. It is performing enhancements in our file overall.

02:21:14.328 --> 02:21:21.328
I have included one thing in the OneGo project. I want to run the Apple ecosystem here.

02:21:21.328 --> 02:21:27.708
Apple ecosystem means the user interface enhancements in our MacBook or iPhones. I want to adapt

02:21:27.708 --> 02:21:34.328
them in our project. All those things are happening here. You see what it is doing first.

02:21:34.328 --> 02:21:37.028
I gave this information here.

02:21:37.028 --> 02:21:40.168
Use real doctor information from Alaska.

02:21:40.168 --> 02:21:42.408
I want to launch it there.

02:21:42.408 --> 02:21:45.568
It is taking Alaska doctor profiles from the list.

02:21:45.568 --> 02:21:48.968
First, it read all our files.

02:21:48.968 --> 02:21:52.308
Then it understood index.js file.

02:21:52.308 --> 02:21:56.128
Then it understood all files in data.js.

02:21:56.128 --> 02:21:59.868
After that it is carrying on our research purpose.

02:21:59.868 --> 02:22:04.288
When these things are included, our final website version will come in a better form

02:22:04.288 --> 02:22:12.288
Let me tell you an important thing. In Codex, whatever things are happening now, you can see them all here.

02:22:12.288 --> 02:22:20.288
If we have any output, we can see it too. If we have any source, we can see which source it is utilising here.

02:22:20.288 --> 02:22:25.288
Like here, from a regional hospital list, it is retrieving doctors.

02:22:25.288 --> 02:22:33.288
First, it makes concrete changes, replacing generic healthcare content with Alaska-specific facility and care context.

02:22:33.288 --> 02:22:39.968
Second, it is rebuilding the visual system into a brighter, premium look that feels native

02:22:39.968 --> 02:22:46.088
on iPhone and Mac without copying Apple trademarks or proprietary icon sets.

02:22:46.088 --> 02:22:49.648
All these changes are being created right now here.

02:22:49.648 --> 02:22:54.568
In the Styles section, you can see that we have many changes appearing.

02:22:54.568 --> 02:22:59.248
We are experiencing many changes because it is performing complete enhancements in our

02:22:59.248 --> 02:23:01.368
file overall.

02:23:01.368 --> 02:23:06.468
All the styling updates are being processed to match the ecosystem we requested.

02:23:06.468 --> 02:23:09.208
Our project design is improving to look professional.

02:23:09.208 --> 02:23:13.308
The software implementation has reached the required final stages.

02:23:13.308 --> 02:23:15.228
All web files were edited.

02:23:15.228 --> 02:23:17.788
The main index file is now running.

02:23:17.788 --> 02:23:20.888
The visual brand appears much better now.

02:23:20.888 --> 02:23:24.248
Demo logging credentials exist in the database.

02:23:24.248 --> 02:23:28.048
Entering the main dashboard shows AuroraCare Alaska.

02:23:28.048 --> 02:23:33.888
Navigating to care teams displays available health and vascular care, internal medicine

02:23:33.888 --> 02:23:36.368
and real-time schedules.

02:23:36.368 --> 02:23:42.108
Alaska Regional Cardiology and Providence Primary Care Access Details are visible with exact

02:23:42.108 --> 02:23:45.568
addresses and contact access details.

02:23:45.568 --> 02:23:47.768
We can book a medical appointment here.

02:23:47.768 --> 02:23:52.788
For example, a normal check-up for a child can be scheduled at 10.15.

02:23:52.788 --> 02:23:57.088
A new medical appointment request is submitted for 1.30.

02:23:57.088 --> 02:23:58.928
The system updates the patient schedule.

02:23:59.819 --> 02:24:01.939
The active list shows scheduled visits.

02:24:02.839 --> 02:24:05.139
We can cancel any booked visit from the records.

02:24:06.179 --> 02:24:10.299
Previous health records display current patient medications and known allergies.

02:24:10.299 --> 02:24:14.499
Recent clinical visits and lab reviews are also listed.

02:24:14.499 --> 02:24:19.299
All recommended system features are implemented in this application version.

02:24:19.299 --> 02:24:23.299
All these recommended software features are now complete.

02:24:23.299 --> 02:24:27.299
Next, a brand new change will be adopted.

02:24:27.299 --> 02:24:30.299
A new user profile feature is needed.

02:24:30.299 --> 02:24:37.299
The end user should create a new account, add personal details and access a personalized dashboard.

02:24:37.299 --> 02:24:42.799
Logging out of the current active session brings us to the main screen.

02:24:42.799 --> 02:24:46.299
Clicking on Create a Demo Account opens a new form.

02:24:46.299 --> 02:24:49.299
A new name, Alex, is entered.

02:24:49.299 --> 02:24:53.299
The email address, alex at gmail dot com, is provided.

02:24:53.299 --> 02:24:57.299
A secure password is created for this new account.

02:24:57.299 --> 02:25:00.299
The brand new demo account is accessed.

02:25:00.299 --> 02:25:03.299
Looking at the health records for this new user,

02:25:03.299 --> 02:25:06.899
previous medications and known allergies are still visible.

02:25:06.899 --> 02:25:10.379
The recent clinical visit data is also showing

02:25:10.379 --> 02:25:15.499
old information. This problem happens because synthetic mock data is used.

02:25:15.499 --> 02:25:20.999
When a new user account is created, all personal details should start fresh.

02:25:20.999 --> 02:25:25.539
We need to include actual user inputs instead of synthetic data.

02:25:25.539 --> 02:25:29.079
Even if previous scheduled appointments are cancelled

02:25:29.079 --> 02:25:32.359
they remain in the application database for the new patient.

02:25:32.359 --> 02:25:36.759
This behaviour applies to every new patient profile created.

02:25:36.759 --> 02:25:40.259
New data is not available yet in the interface.

02:25:40.259 --> 02:25:44.859
To solve this issue, new code logic must be introduced.

02:25:44.859 --> 02:25:48.659
A text prompt is written to update the application logic.

02:25:48.659 --> 02:25:51.759
The missing profile fields need to be added

02:25:51.759 --> 02:25:56.639
and displayed on the main dashboard. The user account creation flow must be

02:25:56.639 --> 02:25:57.399
complete from

02:25:57.399 --> 02:26:01.459
end to end. The new user must feel personalized

02:26:01.459 --> 02:26:05.019
without falling back to generic demo data.

02:26:05.019 --> 02:26:08.019
The core application logic is updating.

02:26:08.019 --> 02:26:12.179
Five project files are being edited to implement the changes.

02:26:12.179 --> 02:26:19.299
These code items include data, HTML, dashboard, index and records files.

02:26:19.299 --> 02:26:22.739
More software changes are expected to arrive soon.

02:26:22.739 --> 02:26:25.619
The main project goal is defined now.

02:26:25.619 --> 02:26:30.179
A new created user account must feel custom and personalized.

02:26:30.179 --> 02:26:33.179
It should not fall back to generic demo data.

02:26:33.179 --> 02:26:37.179
The user profile flow is implemented in the source code.

02:26:37.179 --> 02:26:41.179
Syntax checks are running to verify the software changes.

02:26:41.179 --> 02:26:45.179
The main index file now includes a complete sign-up form.

02:26:45.179 --> 02:26:50.179
Logging out again allows us to test the updated demo account creation.

02:26:50.179 --> 02:26:54.179
The new registration form requires comprehensive user details.

02:26:54.179 --> 02:27:03.179
Full name, email, phone number, date of birth, blood type, address and medical insurance information must be provided.

02:27:03.179 --> 02:27:07.179
Emergency contact details are also required to complete the setup.

02:27:07.179 --> 02:27:11.179
These user details will be stored across the application assets.

02:27:11.179 --> 02:27:16.179
The new account registration form is filled with specific user data.

02:27:16.179 --> 02:27:20.179
The first name, Alex, is entered along with the email address.

02:27:20.179 --> 02:27:22.179
A random phone number is provided.

02:27:22.179 --> 02:27:27.579
The proper date of birth is set. The blood type is selected as A positive.

02:27:28.579 --> 02:27:37.919
The user city is entered as Alaska. The geographic region is specified as USA, region, state, Alaska.

02:27:38.959 --> 02:27:42.939
An insurance plan named Master Insure Pro is added.

02:27:44.019 --> 02:27:46.259
An emergency contact number is also provided.

02:27:46.859 --> 02:27:51.179
In the end, a secure password is created to finalise the account.

02:27:52.179 --> 02:27:55.179
The new user account is created.

02:27:55.179 --> 02:28:00.179
Navigating to the medical records section shows the updated patient identity.

02:28:00.179 --> 02:28:05.179
All personal details provided during sign-up are displayed here.

02:28:05.179 --> 02:28:09.179
The scheduled appointments section is now empty and ready for new bookings.

02:28:09.179 --> 02:28:14.179
The care team section reflects the correct operational details.

02:28:14.179 --> 02:28:17.179
The personalised user dashboard is functional.

02:28:17.179 --> 02:28:21.399
Multiple future system changes can be integrated as the project evolves.

02:28:22.619 --> 02:28:24.979
All main project details are configured.

02:28:26.019 --> 02:28:28.919
The next crucial step is to upload the project code.

02:28:30.019 --> 02:28:34.359
A command request is made to push all files into a remote GitHub repository.

02:28:35.599 --> 02:28:40.239
The operating system checks available GitHub capabilities within the active workspace.

02:28:41.219 --> 02:28:44.159
A local system Git installation is not found.

02:28:44.159 --> 02:28:49.159
The active folder is not recognised as a valid Git repository.

02:28:49.159 --> 02:28:54.159
Two concrete system blockers prevent the code push process.

02:28:54.159 --> 02:28:58.159
First, the Git software is not installed on the machine.

02:28:58.159 --> 02:29:03.159
Second, there is no connected remote GitHub repository available.

02:29:03.159 --> 02:29:08.159
Suggested options are provided to resolve these software issues.

02:29:08.159 --> 02:29:12.159
A new public code repository must be created first.

02:29:12.159 --> 02:29:17.159
The main GitHub website is open to create a new online repository.

02:29:17.159 --> 02:29:20.159
The user login credentials are saved.

02:29:20.159 --> 02:29:25.159
A new repository named OneGoProjectHealthcare is created.

02:29:25.159 --> 02:29:28.159
The access visibility is set to public.

02:29:28.159 --> 02:29:31.159
The repository creation process completes.

02:29:31.159 --> 02:29:35.159
The Internet repository link is now available for connection.

02:29:35.159 --> 02:29:40.159
The required remote repository link is copied from GitHub.

02:29:40.159 --> 02:29:46.659
This specific link is pasted into the system prompt to initiate the web connection.

02:29:46.659 --> 02:29:51.659
The active system processes the target online repository URL.

02:29:51.659 --> 02:29:56.999
It checks whether the main GitHub connector has the necessary account access.

02:29:56.999 --> 02:29:59.779
The code push access is verified.

02:29:59.779 --> 02:30:03.499
The current local project files are being read in order.

02:30:03.499 --> 02:30:07.879
The development plan is to publish them into the main code branch.

02:30:07.879 --> 02:30:11.879
This action is done through the built-in GitHub connector.

02:30:11.879 --> 02:30:16.379
The raw text content of all project files is extracted.

02:30:16.379 --> 02:30:19.819
The public code files are prepared for web publishing.

02:30:19.819 --> 02:30:24.739
A small project readme file is also generated for the repository.

02:30:24.739 --> 02:30:28.499
At this moment, the online repository is empty.

02:30:28.499 --> 02:30:33.879
Refreshing the web GitHub page confirms no files are uploaded yet.

02:30:33.879 --> 02:30:37.859
The background publishing application is running the pull request.

02:30:37.859 --> 02:30:43.539
Once the upload process is approved, the new content will be available online.

02:30:43.539 --> 02:30:48.219
The computer system waits for the background publishing process to execute.

02:30:48.219 --> 02:30:51.339
A new approval prompt appears on the screen.

02:30:51.339 --> 02:30:56.339
It requests security permission to allow GitHub to run the file creation tool.

02:30:56.339 --> 02:31:00.979
The required permission is granted by selecting the Allow option.

02:31:00.979 --> 02:31:07.179
This choice ensures automatic file creation without repetitive manual user approvals.

02:31:07.179 --> 02:31:11.639
A subsequent system request asks to create code git blobs.

02:31:11.639 --> 02:31:15.199
This security permission is also allowed to proceed.

02:31:15.199 --> 02:31:21.739
These technical steps are necessary to transfer the local workspace files to the remote web environment.

02:31:21.739 --> 02:31:27.059
If the source code is left in the local workspace, it cannot be shared or deployed.

02:31:27.059 --> 02:31:32.099
Moving it to the online repository ensures the system is integrated.

02:31:32.099 --> 02:31:35.419
Two separate system blockers are identified again.

02:31:35.419 --> 02:31:39.859
the local machine still lacks a local software Git installation.

02:31:39.859 --> 02:31:45.279
The web GitHub integration can read files, but write operations are blocked.

02:31:45.279 --> 02:31:50.799
This problem happens because the integration cannot access the necessary developer tools.

02:31:50.799 --> 02:31:55.979
To resolve this exact issue, a local system installation is required.

02:31:55.979 --> 02:31:57.979
A new internet browser tab is opened.

02:31:59.827 --> 02:32:05.727
install git is executed. The official git software installation page is accessed.

02:32:05.727 --> 02:32:11.187
The Windows desktop operating system option is selected. The standalone

02:32:11.187 --> 02:32:15.947
software installer for Windows is downloaded. The software download process

02:32:15.947 --> 02:32:21.147
will take some time to finish. The installation setup will be executed soon.

02:32:21.147 --> 02:32:27.087
The main git installer file is saved to the computer desktop. The file download

02:32:27.087 --> 02:32:32.027
continues in the background. In the meantime the computer system provides a

02:32:32.027 --> 02:32:36.627
text list of terminal commands. These commands are required to push the

02:32:36.627 --> 02:32:42.327
source code by hand. Before executing them, remote repository permissions must

02:32:42.327 --> 02:32:47.667
be verified. The main GitHub settings page is opened to ensure proper developer

02:32:47.667 --> 02:32:53.907
access rights. The account security and variables section is examined. The account

02:32:53.907 --> 02:32:58.707
moderation options are also visible. Navigating to the repository security

02:32:58.707 --> 02:33:04.227
permissions is necessary to allow new code uploads. The active pull request

02:33:04.227 --> 02:33:08.967
settings are reviewed. The code merge commits and squash merging options are

02:33:08.967 --> 02:33:13.547
enabled by default. The version commit settings and archive features are

02:33:13.547 --> 02:33:18.327
checked. The critical danger zone is avoided to prevent accidental project

02:33:18.327 --> 02:33:23.627
deletion. Everything appears to be configured in a proper state. The git

02:33:23.627 --> 02:33:28.187
software installer download is now complete. The application setup file will

02:33:28.187 --> 02:33:33.047
be executed next to install the software on the computer. The downloaded git

02:33:33.047 --> 02:33:38.147
software installer is executed from the computer desktop. The application setup

02:33:38.147 --> 02:33:42.727
wizard appears on the screen. The standard default installation options are

02:33:42.727 --> 02:33:47.727
selected by clicking the next button multiple times. The default components

02:33:47.727 --> 02:33:52.607
are chosen for the system installation. The default code editor is maintained.

02:33:52.607 --> 02:33:56.727
The initial project branch name configuration is left as a default

02:33:56.727 --> 02:34:02.927
choice. The system path environment is updated. The software installation process

02:34:02.927 --> 02:34:08.447
begins extracting core files. The visual progress bar indicates the current

02:34:08.447 --> 02:34:13.487
installation status. The program installation is completed without errors.

02:34:13.487 --> 02:34:19.847
The active current terminal window is closed. A fresh new terminal session is

02:34:19.847 --> 02:34:24.947
launched to apply the updated installation paths. The specific git

02:34:24.947 --> 02:34:31.007
initialize command is executed again. The operating system initializes an empty

02:34:31.007 --> 02:34:37.087
local git repository. The local development project folder is now tracked by the git tool.

02:34:38.207 --> 02:34:41.567
The next required command is copied from the text instructions.

02:34:42.767 --> 02:34:46.687
The project branch is renamed to main using the active terminal.

02:34:47.887 --> 02:34:50.847
The text command executes without any prompt errors.

02:34:51.967 --> 02:34:58.207
The remote origin target command is copied next. This specific command links the local code

02:34:58.207 --> 02:35:04.567
repository to the new created online GitHub repository. The web link is pasted

02:35:04.567 --> 02:35:09.267
into the terminal and executed. The internet connection is established

02:35:09.267 --> 02:35:14.947
without issues. The next development step requires adding all project files to the

02:35:14.947 --> 02:35:21.247
code staging area. The standard git add command is prepared. An error prompt

02:35:21.247 --> 02:35:26.947
occurs stating access permission is denied. The operating system cannot open

02:35:26.947 --> 02:35:30.567
a distinct application data directory.

02:35:30.567 --> 02:35:33.947
This file access issue must be resolved.

02:35:33.947 --> 02:35:38.307
The access permission denied error halts the running process.

02:35:38.307 --> 02:35:43.327
The operating system attempts to add developer files from the root user directory instead

02:35:43.327 --> 02:35:45.607
of the project folder.

02:35:45.607 --> 02:35:48.467
This behaviour is a crucial mistake.

02:35:48.467 --> 02:35:53.067
The code terminal is operating in the wrong system directory path.

02:35:53.067 --> 02:35:59.707
A new Terminal Application tab must be opened within the exact correct project folder.

02:35:59.707 --> 02:36:03.267
The root user terminal is closed without delay.

02:36:03.267 --> 02:36:09.547
The new command terminal now displays the correct document path for the software project.

02:36:09.547 --> 02:36:14.847
The standard git initialize command is executed again in the right folder.

02:36:14.847 --> 02:36:20.067
An empty code repository is initialized here without any issues.

02:36:20.067 --> 02:36:25.627
The Branch Rename Text command is executed to set the main branch.

02:36:25.627 --> 02:36:32.407
The Remote Origin command is pasted and executed to link the online GitHub repository.

02:36:32.407 --> 02:36:36.167
The correct project folder is now connected.

02:36:36.167 --> 02:36:41.107
The next workflow step is to add all files to the staging area.

02:36:41.107 --> 02:36:46.167
The simple Git Add command is executed without errors this time.

02:36:46.167 --> 02:36:50.767
All main project files are added to the code staging area.

02:36:50.767 --> 02:36:56.267
The standard git commit command is executed with a descriptive message.

02:36:56.267 --> 02:37:01.507
The operating system returns an author identity unknown error.

02:37:01.507 --> 02:37:06.487
The code commit cannot proceed without proper user identification.

02:37:06.487 --> 02:37:11.507
The global user configuration commands must be executed first.

02:37:11.507 --> 02:37:15.687
The terminal command to set the user email is copied.

02:37:15.687 --> 02:37:21.887
The account email address is updated to match the online GitHub account credentials.

02:37:21.887 --> 02:37:25.787
The command is executed without any system errors.

02:37:25.787 --> 02:37:30.387
The terminal command to set the username is copied next.

02:37:30.387 --> 02:37:35.487
The developer username is retrieved from the Web GitHub profile page.

02:37:35.487 --> 02:37:40.387
The target username is pasted into the terminal command line.

02:37:40.387 --> 02:37:44.687
The system configuration is updated without issues.

02:37:44.687 --> 02:37:48.667
The required author identity is now established.

02:37:48.667 --> 02:37:53.367
The standard git commit command is executed once again.

02:37:53.367 --> 02:37:57.507
This specific time, the code commit is a success.

02:37:57.507 --> 02:38:01.887
All modified files are recorded in the local repository.

02:38:01.887 --> 02:38:05.527
The source code is ready for the final push.

02:38:05.527 --> 02:38:12.447
The main commit process includes all necessary application files, the design assets, HTML

02:38:12.447 --> 02:38:17.007
web pages and application data files are secured.

02:38:17.007 --> 02:38:21.707
The final terminal command to push the source code is executed.

02:38:21.707 --> 02:38:28.287
The command terminal requests user authentication to access the remote GitHub repository.

02:38:28.287 --> 02:38:33.267
A new internet browser window opens for the user login process.

02:38:33.267 --> 02:38:37.407
The Sign in with internet browser option is selected.

02:38:37.407 --> 02:38:43.167
The existing active session credentials are used to authorise the upload transaction.

02:38:43.167 --> 02:38:46.907
The access authorisation succeeds without delay.

02:38:46.907 --> 02:38:52.547
Returning to the command terminal confirms the code push process is active.

02:38:52.547 --> 02:38:57.027
The data objects are compressed and written to the remote web server.

02:38:57.027 --> 02:39:01.867
The main code branch is set up to track the remote origin point.

02:39:01.867 --> 02:39:05.447
The entire application project is uploaded.

02:39:05.447 --> 02:39:10.827
The online GitHub repository page is refreshed in the internet browser.

02:39:10.827 --> 02:39:14.807
All local project files are now visible online.

02:39:14.807 --> 02:39:19.667
The assets folder and HTML text documents are listed.

02:39:19.667 --> 02:39:23.927
The code upload process is verified and a success.

02:39:23.927 --> 02:39:30.427
The uploaded index document file is opened on GitHub to verify its code contents.

02:39:30.427 --> 02:39:35.607
The online code matches the local computer version without flaws.

02:39:35.607 --> 02:39:39.527
The source blame and file history options are functional.

02:39:39.527 --> 02:39:43.287
The raw text code can be accessed any time.

02:39:43.287 --> 02:39:46.947
The entire upload process is now concluded.

02:39:46.947 --> 02:39:52.507
The initial project objective was to build a medical healthcare application project.

02:39:52.507 --> 02:39:55.307
A detailed development plan was formulated first.

02:39:58.331 --> 02:40:04.851
basic minimum viable product. The database backend requirements were later removed to

02:40:04.851 --> 02:40:08.471
to focus on the user front-end interface.

02:40:08.471 --> 02:40:15.131
The HTML and CSS design structures were developed with minimal JavaScript logic.

02:40:15.131 --> 02:40:21.771
Various design iterations improved the visual page aesthetics and user experience.

02:40:21.771 --> 02:40:26.851
The personalized user profile creation feature was integrated.

02:40:26.851 --> 02:40:32.351
In the end, the local source code was pushed to a public code repository.

02:40:32.351 --> 02:40:36.571
The application project is stored and accessible.

02:40:36.571 --> 02:40:41.171
Future code modifications can be implemented and tracked through this version repository

02:40:41.171 --> 02:40:43.871
system without effort.

02:40:43.871 --> 02:40:49.031
The detailed software implementation plan proved effective in practice.

02:40:49.031 --> 02:40:55.611
We established a strong code foundation using standard modern web technologies.

02:40:55.611 --> 02:41:02.111
The front-end user interface provides a seamless, smooth experience for clinical patients managing

02:41:02.111 --> 02:41:04.551
their healthcare needs.

02:41:04.551 --> 02:41:11.851
The synthetic mock data limitations were overcome by implementing dynamic user input handling.

02:41:11.851 --> 02:41:17.211
The medical appointment scheduling and user cancellation workflows operate without any

02:41:17.211 --> 02:41:19.351
system errors.

02:41:19.351 --> 02:41:25.831
Essential patient medical records remain accessible on the personalised user dashboard.

02:41:25.831 --> 02:41:31.731
By utilising the Git version control system, the main source code remains protected against

02:41:31.731 --> 02:41:38.591
accidental data loss. The open public repository allows other software developers to review

02:41:38.591 --> 02:41:44.971
the application project structure. This developer workflow demonstrates a practical approach

02:41:44.971 --> 02:41:51.491
to rapid web application development and code deployment. The initial system setup challenges

02:41:51.491 --> 02:41:58.111
regarding local machine software requirements were resolved with great speed. The comprehensive

02:41:58.111 --> 02:42:04.771
command terminal instructions ensured execution of necessary developer commands.

02:42:04.771 --> 02:42:12.571
The final software outcome is a functional, well-documented and versioned front-end application.

02:42:12.571 --> 02:42:15.211
The established project goals are fulfilled.

02:42:15.211 --> 02:42:19.831
The discussion relates to possible iterations we can include here.

02:42:19.831 --> 02:42:25.691
In our use cases, we create projects multiple times, requiring iterations.

02:42:25.691 --> 02:42:30.031
We can include these iterations to see what is possible.

02:42:30.031 --> 02:42:31.831
Iterations start from the beginning.

02:42:31.831 --> 02:42:35.151
We include project details and formats.

02:42:35.151 --> 02:42:38.731
Another option is available after project creation.

02:42:38.731 --> 02:42:42.451
Moving to the end, our index was complete at this step.

02:42:42.451 --> 02:42:49.531
Here, in frontend, backend, appointments and records, our option has arrived.

02:42:49.531 --> 02:42:51.471
Changes are never small.

02:42:51.471 --> 02:42:55.971
For changes, we will include details multiple times.

02:42:55.971 --> 02:43:01.311
Another important thing is working in an environment requiring code changes.

02:43:01.311 --> 02:43:03.591
Iterations become version-based.

02:43:03.591 --> 02:43:07.911
The first website version was quite different from the current version.

02:43:07.911 --> 02:43:12.651
We must understand version histories to see which was more compatible.

02:43:12.651 --> 02:43:16.891
Sometimes we include specific things from a specific version.

02:43:16.891 --> 02:43:20.691
Going into our project, this was the final version.

02:43:20.691 --> 02:43:26.571
Looking at this project, considering the whole use case, the logo is incorrect.

02:43:26.571 --> 02:43:28.571
We can change the logo.

02:43:28.571 --> 02:43:32.851
The dashboard should be a sliding dashboard, not a consistent one.

02:43:32.851 --> 02:43:37.191
Instead of this, some analytics should be involved here.

02:43:37.191 --> 02:43:42.691
Looking here, the card distance and the empty space in the website should be minimal.

02:43:42.691 --> 02:43:45.931
We should fill such spaces beforehand.

02:43:45.931 --> 02:43:51.051
In our website text, search engine optimization is not involved.

02:43:51.051 --> 02:43:53.891
The colors involved here are quite dull.

02:43:53.891 --> 02:43:58.311
We can improve all these things just by giving it some prompts.

02:43:58.311 --> 02:44:01.151
Our iteration will start happening now.

02:44:01.151 --> 02:44:07.951
Alongside iteration, another important thing is making large scale improvements via prompts.

02:44:07.951 --> 02:44:13.451
Since this tool is based on our prompts, any new improvement will be based on prompts.

02:44:13.451 --> 02:44:16.911
there is no other way to improve our stuff.

02:44:16.911 --> 02:44:20.491
These things will be induced here with our ongoing time.

02:44:20.491 --> 02:44:23.851
As our time increases, we must iterate these things

02:44:23.851 --> 02:44:26.891
and see how we are taking them forward.

02:44:26.891 --> 02:44:29.571
Along with this, another important thing

02:44:29.571 --> 02:44:32.571
is that when making improvements based on prompts,

02:44:32.571 --> 02:44:34.891
error chances increase.

02:44:34.891 --> 02:44:38.551
Therefore, we should review our code first.

02:44:38.551 --> 02:44:41.091
After reviewing the code, we should take things

02:44:41.091 --> 02:44:44.651
towards our other generations and discussions.

02:44:44.651 --> 02:44:47.471
Sometimes, within our code itself,

02:44:47.471 --> 02:44:50.971
there are multiple errors we spend time correcting.

02:44:50.971 --> 02:44:54.271
We are focusing on making the dashboard intuitive.

02:44:54.271 --> 02:44:56.931
The layout needs adjustments so upcoming visits

02:44:56.931 --> 02:44:59.331
and active reminders are visible to the user.

02:45:00.351 --> 02:45:02.271
Care teams and appointment sections

02:45:02.271 --> 02:45:04.751
must be integrated together.

02:45:04.751 --> 02:45:07.531
This ensures the entire application functions

02:45:07.531 --> 02:45:11.331
without visual or technical interruptions.

02:45:11.331 --> 02:45:15.851
This completes our entire discussion related to our iteration.

02:45:15.851 --> 02:45:19.291
Along with the iteration, we covered possible improvements

02:45:19.291 --> 02:45:21.691
that needed to be discussed.

02:45:21.691 --> 02:45:25.111
Looking at the bottom section, the reminders and profile

02:45:25.111 --> 02:45:28.691
loaded cards have gaps needing fixes.

02:45:28.691 --> 02:45:32.331
The design should feel premium and responsive.

02:45:32.331 --> 02:45:34.811
The patient readiness items must be tracked

02:45:34.811 --> 02:45:37.631
on one premium dashboard.

02:45:37.631 --> 02:45:40.311
When looking at source options for medical centres,

02:45:40.311 --> 02:45:43.791
like Providence Alaska Medical Centre or Alaska Native Medical

02:45:43.791 --> 02:45:47.851
Centre, information must be displayed.

02:45:47.851 --> 02:45:50.611
The layout structure lacks proper alignment,

02:45:50.611 --> 02:45:53.571
and text blocks feel disconnected.

02:45:53.571 --> 02:45:58.451
We will use specific commands to refine these interface elements.

02:45:58.451 --> 02:46:01.411
Once we apply new styles, the final product

02:46:01.411 --> 02:46:03.811
will look more professional.

02:46:03.811 --> 02:46:11.131
Everything will be committed to the repository, ensuring all changes are saved and tracked for future updates and continuous development.

02:46:11.651 --> 02:46:12.891
Now comes the last part.

02:46:13.791 --> 02:46:16.631
At the end of this course, you saw one main thing.

02:46:17.351 --> 02:46:19.351
It was our GitHub and Codex tools.

02:46:20.211 --> 02:46:21.511
We tried to connect GitHub.

02:46:22.311 --> 02:46:23.971
Then we got many tech issues.

02:46:24.491 --> 02:46:27.771
I will say here I will use our plugin of GitHub now.

02:46:28.431 --> 02:46:31.291
I will start a discussion with the GitHub plugin tool.

02:46:31.291 --> 02:46:35.551
I will ask, can you check if GitHub plugin is working?

02:46:36.451 --> 02:46:38.291
This will test our plugin once.

02:46:38.951 --> 02:46:41.491
We will see if our plugin works in any user case.

02:46:42.111 --> 02:46:45.111
If our plugin is not available, we can check it.

02:46:45.851 --> 02:46:47.971
You can see we have verification now.

02:46:48.871 --> 02:46:50.551
You can see that I have verified it.

02:46:51.331 --> 02:46:53.111
This login account Robert is here.

02:46:53.911 --> 02:46:55.711
You will remember our main account here.

02:46:56.111 --> 02:46:57.291
That is connected here.

02:46:58.191 --> 02:47:00.031
Its user ID has also come.

02:47:00.031 --> 02:47:04.771
that confirm that the plugin is installed, reachable and authenticated.

02:47:05.771 --> 02:47:08.251
Now I can say, what can I do with this?

02:47:08.931 --> 02:47:10.911
This will start giving us a response.

02:47:11.711 --> 02:47:13.751
It will tell us where we can use this plugin.

02:47:14.831 --> 02:47:17.211
This tool is not available on a weak level,

02:47:17.971 --> 02:47:20.551
but still we have to see how our tool can work here.

02:47:21.151 --> 02:47:25.411
You will see here it says you can ask it to read multiple actions.

02:47:26.491 --> 02:47:28.591
In this we also get more recommendations.

02:47:28.591 --> 02:47:32.591
I will suggest to you that we should use multiple plugins.

02:47:32.591 --> 02:47:36.591
Like right now, you are seeing that we can use our windows.

02:47:36.591 --> 02:47:40.591
We have our Chrome and data analytics and product design.

02:47:40.591 --> 02:47:46.591
We also have Apollo and Atio and Carter CRM and Clay and Circleback.

02:47:46.591 --> 02:47:50.591
We have Granola and Otter and Canva.

02:47:50.591 --> 02:47:52.591
We can use all these plugins.

02:47:53.431 --> 02:47:54.811
We have many options.

02:47:55.651 --> 02:47:58.631
If we bring any of these in here, we can use it out.

02:47:59.291 --> 02:48:02.431
For every niche, we have separate options available for us.

02:48:03.031 --> 02:48:07.571
Like for our education and research, we also have options available right here.

02:48:07.571 --> 02:48:10.531
We have our Dow Jones Factiva here.

02:48:10.951 --> 02:48:14.651
We have our GovTribe and we have Life Science Research.

02:48:15.551 --> 02:48:18.691
For finance, we have multiple softwares available right here.

02:48:19.751 --> 02:48:24.411
So what Codex does is on a large scale it gives us multiple plugins to use.

02:48:25.331 --> 02:48:29.691
From these, the used plugin on our developer side is our GitHub plugin.

02:48:30.691 --> 02:48:35.851
But if we want to use multiple plugins on our whole enterprise level, we can do that too.

02:48:35.851 --> 02:48:38.851
With that, our price will increase.

02:48:38.851 --> 02:48:42.851
Our usage cost will also become a cost that is quite high.

02:48:45.851 --> 02:48:50.851
The OpenAI ecosystem is a collection of tools, models and platforms

02:48:50.851 --> 02:48:56.851
that help individuals and organisations use artificial intelligence in practical workflows.

02:48:57.851 --> 02:49:02.851
In this diagram, OpenAI ecosystem is the central idea

02:49:02.851 --> 02:49:06.451
and the main branches show the important parts connected to it.

02:49:07.831 --> 02:49:11.131
ChatGPT is one of the most familiar parts of the ecosystem.

02:49:12.271 --> 02:49:16.611
It helps users write content, explain concepts, solve problems,

02:49:17.251 --> 02:49:19.951
summarise information and support daily work.

02:49:20.771 --> 02:49:25.751
In software development, ChatGPT can help developers understand errors,

02:49:26.331 --> 02:49:31.911
write documentation, plan features and improve prompts before using them with coding tools.

02:49:32.851 --> 02:49:40.451
The OpenAI API allows developers to connect OpenAI models directly into their own applications.

02:49:40.451 --> 02:49:52.411
For example, a company can build a chatbot, document assistant, coding assistant, customer support tool or automation system using the API.

02:49:53.971 --> 02:49:58.351
This makes AI usable inside real business products and enterprise systems.

02:49:59.811 --> 02:50:02.011
Codex is focused on software development.

02:50:02.851 --> 02:50:12.851
It helps developers generate code, refactor files, explain existing code, create tests, debug issues, and work with repositories.

02:50:13.851 --> 02:50:22.851
In an Enterprise course, Codex is important because it shows how AI can support real development workflows instead of only answering questions.

02:50:23.851 --> 02:50:27.851
The Models branch represents the AI models behind the ecosystem.

02:50:27.851 --> 02:50:34.391
These models can work with text, code, images and other types of input depending on the

02:50:34.391 --> 02:50:37.471
product or configuration.

02:50:37.471 --> 02:50:42.351
Better models usually mean better reasoning, better code understanding and more accurate

02:50:42.351 --> 02:50:44.351
responses.

02:50:44.351 --> 02:50:49.651
Finally, enterprise tools are important for organisations.

02:50:49.651 --> 02:50:57.491
Enterprises need security, governance, permissions, auditing and control over how AI is used.

02:50:57.491 --> 02:51:03.511
These tools help companies adopt AI safely while protecting data, managing access and

02:51:03.511 --> 02:51:05.991
following internal policies.

02:51:05.991 --> 02:51:13.131
Overall, the diagram shows that the OpenAI ecosystem is not just one product.

02:51:13.131 --> 02:51:20.631
It includes user-facing tools, developer APIs, coding assistance, advanced models and enterprise

02:51:20.631 --> 02:51:22.131
controls.

02:51:22.131 --> 02:51:28.991
Together, these parts help teams build, automate, learn and develop software more efficiently.

02:51:32.891 --> 02:51:40.411
This conclusion mind map summarises the key lessons learned throughout the OpenAI Codex Enterprise Development course.

02:51:41.191 --> 02:51:48.131
The central idea is that AI-assisted development is becoming an important part of modern software engineering

02:51:48.131 --> 02:51:57.751
and organisations that learn to use these tools effectively can significantly improve productivity, software quality and development speed.

02:51:58.611 --> 02:52:02.511
The first branch focuses on OpenAI Codex itself.

02:52:03.591 --> 02:52:16.091
Throughout the course, learners discovered how Codex helps developers generate code, analyse repositories, refactor applications, create tests and automate repetitive development tasks.

02:52:16.091 --> 02:52:24.571
Rather than replacing developers, Codex acts as an intelligent development assistant that helps teams work more efficiently.

02:52:25.471 --> 02:52:28.791
The next branch highlights the development workflow.

02:52:30.091 --> 02:52:36.171
One of the most important lessons from the course is that AI can support every stage of software development.

02:52:37.391 --> 02:52:44.951
Developers can use Codex during planning, implementation, testing, debugging and deployment preparation.

02:52:46.091 --> 02:52:49.771
Instead of viewing AI as a tool used only for coding,

02:52:49.771 --> 02:52:55.691
organisations can integrate it into the complete software development lifecycle.

02:52:55.691 --> 02:53:01.291
The Enterprise Adoption section emphasises that successful AI implementation

02:53:01.291 --> 02:53:04.651
requires more than technical capability.

02:53:04.651 --> 02:53:07.931
Organisations must establish governance frameworks,

02:53:07.931 --> 02:53:13.611
security controls, compliance processes and collaboration standards.

02:53:13.611 --> 02:53:23.491
Enterprise teams need visibility into how AI is used and must ensure that generated code meets organisational policies and quality requirements.

02:53:24.791 --> 02:53:30.291
The best practices branch represents the habits that produce the best results when working with codecs.

02:53:31.371 --> 02:53:35.311
Effective prompt engineering helps developers communicate requirements clearly.

02:53:36.451 --> 02:53:39.931
Code reviews ensure generated code is maintainable and secure.

02:53:39.931 --> 02:53:46.931
Validation and testing confirm that AI-generated features satisfy business requirements.

02:53:46.931 --> 02:53:51.931
These practices help maximise the value of AI-assisted development.

02:53:51.931 --> 02:53:55.931
Another important area is operational excellence.

02:53:55.931 --> 02:54:04.931
As AI adoption grows, organisations must monitor usage, manage costs, optimise resources and measure performance.

02:54:04.931 --> 02:54:16.311
Understanding token consumption, tracking productivity improvements and evaluating return on investment help organisations scale AI responsibly and efficiently.

02:54:17.271 --> 02:54:22.971
The continuous learning branch reminds learners that AI technologies evolve rapidly.

02:54:24.111 --> 02:54:33.371
Developers should stay informed about new codex capabilities, open AI platform updates, community best practices and industry trends.

02:54:33.371 --> 02:54:41.051
Teams that continuously learn and adapt will gain the greatest long-term benefits from AI-assisted development.

02:54:42.091 --> 02:54:46.451
The Future of Development section looks ahead to emerging trends.

02:54:47.611 --> 02:54:56.831
AI assistants will become more capable, agent-based workflows will become more common, and human-AI collaboration will continue to evolve.

02:54:56.831 --> 02:55:04.831
Developers will increasingly focus on architecture, business logic and strategic decision making,

02:55:04.831 --> 02:55:07.831
while AI handles more implementation tasks.

02:55:07.831 --> 02:55:14.831
Finally, the most important takeaway is that AI augments developers rather than replacing them.

02:55:14.831 --> 02:55:19.831
Human expertise remains essential for understanding business requirements,

02:55:19.831 --> 02:55:28.771
making architectural decisions, reviewing code quality, managing risk and ensuring software meets organisational goals.

02:55:29.951 --> 02:55:38.951
When used effectively, Codex enables developers to deliver better software faster while maintaining quality, security and reliability.

02:55:38.951 --> 02:55:46.531
In summary, the course demonstrates that successful enterprise AI adoption requires a combination

02:55:46.531 --> 02:55:52.571
of technical skills, governance practices, continuous learning, and thoughtful collaboration

02:55:52.571 --> 02:55:54.591
between humans and AI systems.