Hi everyone

and a very warm welcome to this course on codeex.

Really excited to have you here today

and hope to learn a lot of things together.

We will learn how to use codeex for enterprise

how to use codeex for enterprise development.

We will see how it works as a coding assistant

and its many functions in different situations.

Codeex is a tool made by openai.

You might know their famous tool called chat GPT.

OpenAI is the main company behind chat GPT

and they handle all the AI generation and work.

First I will show you the OpenAI website.

On their website they say their research will lead to artificial general intelligence

which is a system that can solve human problems.

In the product section

you can see tools like chat GPT

codeex

atlas

and prism.

Chat GPT is a very large tool

that includes images,

deep research

and GPTs,

codecs,

multiple applications

and libraries.

If we talk about apps,

we have multiple apps connection.

You can connect it with popular apps like Adobe,

Air Table,

Booking.com,

Canva,

Spotify and more.

Now let us look at OpenAI codeex.

Codeex is an AI software engineering agent.

It helps developers write, understand, change, test, and ship code easily.

It is not just a simple chatbot

that only answers questions.

It works directly with your project files

and helps with the whole repository structure

and can make the changes,

run commands,

and assists with development cycles.

It gives developers real engineering results.

Codeex is also inside chat GPT,

so you can use it directly.

There is a specific app for codeex

and you can download it for Windows.

We will see how codeex makes real engineering work faster

from planning and building the features

to fixing and releases

and cross-checking.

There is also a command line interface or CLI on GitHub for codecs.

CLI means command line interface.

It is a textbased interface used to talk to software and computers.

Instead of clicking buttons with a mouse on visual icons,

you type text commands

and the textbased user interface used to interact with the software operating system

and on your keyboard instead of using a mouse to click on visual items

and press enter to make them work.

We will learn how to use this CLI.

Codeex helps what a developer wants to do and turns it into engineering output.

You can describe a bug or a new feature, test environment, documentation, task in natural language.

Codeex can analyze the database, identifying files, propose changes and generate limitation steps.

This makes it useful not only for the writer but also for navigating unfamiliar systemd.

Here we have codeex discussion.

In this course,

we will talk about daily development,

prompting,

making agents

and using codecs for a long time.

We will cover all of these important topics

will cover all of these important topics together.

So moving on,

the next critical discussion

is primarily related to exactly how we are going to securely install codeex on our machine.

first well before actually installing it anywhere else.

We will practically use the standard command line interface to get things started.

But right before that specific step,

we can smoothly download the dedicated version specifically meant for Windows operating systems.

Now I already have the necessary codeex installer fully ready to go here.

I simply open up the main system downloads folder right now.

Then I firmly run the executable installer directly as a system administrator.

The core software

immediately starts

to install itself

smoothly.

Simultaneously,

the Microsoft Store seamlessly begins its essential download

seamlessly begins its essential download process.

Finally,

when the entire download completely finishes,

codeex will successfully run.

Interestingly, we can certainly also manage to install it safely

across multiple different computer systems.

As we smoothly scroll further down the main page,

you will clearly see three distinct setup options presented.

The very first one is the standard standalone app.

If we really want to use a code editor,

we can install it directly within our preferred IDE.

Fortunately, we already have Visual Studio Code fully set up

right inside VS Code.

A highly helpful AI is fully available.

It is completely automated

and we can easily use various models right here.

To successfully add this to our daily workflow,

we simply need to install it in VS Code.

We securely click allow in VS Code

and Codeex will seamlessly open.

Essentially, it is OpenAI's powerful coding agent

that constantly works with you.

It is fully included in chat GPT plus pro,

business, education, and enterprise plans.

First and foremost,

we absolutely must carefully check our specific chat GPT subscription plan.

I will officially open up the chat GPT interface

right open up the chat GPT interface right now.

As you can clearly see,

we currently have the plus version fully activated.

Looking closely in the dedicated upgrade plan section,

you clearly see our active billing plan.

It is indeed the standard plus plan.

This essentially means all our ongoing coding work

is completely safe and secure.

Codeex is fully available to use today.

The strictly required language model is situated right here.

Moving back into VS Code,

we will effectively start the complete software

effectively start the complete software installation.

It securely installs just like a standard web extension.

First, we smoothly pair it directly with

First, we smoothly pair it directly with codeex.

We basically add codeex as a dedicated side panel within VS Code

to seamlessly chat,

intuitively edit,

and carefully check all our changes.

Then we can confidently use Codeex directly in the cloud,

sending massive jobs straight to it.

Moving gracefully to the very next step,

we simply need to safely sign in using our primary chat GPT account credentials.

Once fully authenticated,

our main application will automatically install directly into the workspace.

Now the third available setup option is to actually install this directly inside our system terminal.

For this specific method,

just look closely at the keep going in the terminal prompt section.

We carefully copy this exact command string

to our copy this exact command string to our clipboard.

Following that,

we explicitly open up the system command prompt,

making sure to run it strictly as an administrator.

The Windows PowerShell interface naturally opens up within PowerShell itself.

We formally install the OpenAI codeex tool

utilizing the npm package manager.

Naturally, it will definitely take a little bit of time

to fully install properly.

The underlying system will sequentially gather necessary data

in a much better way.

Codeex is actively installing

and we have our app ready.

Now we go to settings.

We purposefully open the main application settings

directly from the main dashboard.

Once inside the comprehensive settings menu,

there are actually many different customizable options available.

I specifically navigate over to the appearance tab

in order to make some visual interface changes.

First, I completely change the overall display theme

to a comfortable dark display theme

to a comfortable dark mode.

Next, I noticeably increase the base system UI size

for better visibility.

We then carefully choose our preferred font style

and slightly adjust the visual contrast.

Initially, I confidently write in 32

for the primary font size.

However, upon seeing it,

32 is admittedly just a bit too big for my screen.

So, I quickly change it down

to exactly 24.

Honestly, 24 is a genuinely comfortable size

for long coding sessions.

For the dedicated code font,

we firmly use size 20.

Moving on,

we strategically turn off the reduce motion option.

We ensure we use standard pointer cursors

and gently lower the screen cursors

and gently lower the screen contrast.

Everything is working well.

Honestly, the overall reading experience

is just so much better right now.

Before we made those crucial visual tweaks,

the default text font was incredibly small

and honestly hard to read.

We absolutely had to step in

and make the font significantly bigger

for basic clarity.

I truly believe that 24 and 20

are excellent, highly optimized sizes

for our daily coding tasks.

Now, if we quickly navigate over to the general configuration settings menu,

we can clearly see multiple distinct operational modes

available to choose from.

I promise that I will carefully explain all of these specific working modes

in much greater detail

a little bit later on.

Right now,

all our required system packages are successfully installed.

The powerful Open AI codeex itself is completely installed.

Now we just essentially need to forcefully run it one more time.

I smoothly tab back over to the chat GPT window.

I explicitly type out and clearly ask.

I have basically run this command in the terminal.

What do I do next to start it?

We will now officially start the require process right here within our local system terminal.

The entire background installation procedure is completely finished.

It successfully managed to add two vital software packages in just about 36 seconds total.

The software carefully checks the current MPM installation status alongside the available AI models.

First and foremost, we must verify the active codeex version.

I simply type MPM codeex directly into the prompt.

The resulting Codeex CLI version currently shows up as Codeex CLI version currently shows up as 0.139.0.

Next, we actively run Codeex, so we can finally start to code.

We type codeex right into the system environment.

A brand new security message suddenly appears on the screen.

It clearly asks,

"Do you currently trust the exact contents of this specific directory?"

Working directly with untrusted contents definitely carries inherent security risks

or potential prompt injections.

Trusting that directory directly

allows for reading local configuration settings.

I confidently click yes

and smoothly continue.

After successfully getting that required yes confirmation,

we now finally have our direct working option ready to go.

We have the full power of the open AI codeex

at our fingertips.

Our specifically selected AI model is currently GPT 5.5.

Our active working directory is listed safely as system 32.

We can comfortably make direct code changes right here in this space.

If I quickly send over a very simple introductory message,

it impressively replies back almost automatically.

I simply write out,

"Can you explicitly help me in generating some basic HTML

help me in generating some basic HTML code?"

It quickly gives a remarkably short,

concise response.

It plainly says,

"Yes, concise response.

It plainly says,

"Yes, absolutely.

Just tell me exactly what you want

the final HTML page to do

or what you want it to look like.

Paste any existing code snippets

you might already have.

If you happen to start entirely from scratch,

I can easily create a simple HTML framework for you.

Our coding journey begins.

I press Ctrl C to pause.

It shows the response.

The interface clearly displays our complete token usage statistics

right on the screen.

The grand total comes out to exactly

The grand total comes out to exactly 7,939 tokens used.

The initial input strictly accounted for

7,881 accounted for 7,881 tokens.

Meanwhile, the generated output was a remarkably short

58 tokens.

To seamlessly continue this exact same chat session,

we carefully copy the provided resume command.

I smoothly paste that specific command right back in here.

Instantly, the previous conversation thread beautifully continues

right where we left off.

If I suddenly decide that I want to completely change

the underlying AI model,

we currently have three distinct options available.

First is GPT 5.5,

which is essentially the Frontier model

specifically built for complex coding tasks.

Next is GPT 5.4,

the strongest overall model

strictly meant for everyday standard coding.

Finally, we have the incredibly lightweight

GPT 5.4 Mini.

We also have very handy slash commands

completely ready to use.

we will clearly show exactly how to effectively use them

moving forward.

Let's use slash commands.

When I proactively type out a forward slash,

codeex immediately shows a complete, highly detailed working menu

of commands.

First and foremost, we can fully configure

how codeex strictly operates.

We have the primary model selection option available.

We also have the specific fast option explicitly listed.

We have the IDE integration

to easily include currently open files

and broader include currently open files and broader context.

We actively have detailed permissions

to precisely choose exactly what codecs can or cannot do safely.

We have dedicated key maps

specifically designed for setting custom keyboard

designed for setting custom keyboard shortcuts.

We have Vim mode

strictly intended for our main code composer.

We logically have the sandbox add to directory feature ready.

Finally, we have the experimental feature section.

I intentionally select the very first configuration option

to explore the available models.

I ultimately choose the GPT 5.4 mini

I ultimately choose the GPT 5.4 mini variant.

Now we selectively choose the preferred reasoning level.

We specifically select low reasoning instead of the standard low reasoning instead of the standard medium.

We can carefully view current IDE sessions and files.

Next,

we review permissions.

There are several highly specific model permissions

carefully listed here.

The readonly setting strictly means that Codeex can only safely read active files located within the current workspace environment.

It absolutely requires your direct manual approval

before it can ever attempt to edit files

or directly access the live internet.

The ask for approval setting actually serves as the standard default mode

where Codeex can seamlessly run, read, or even edit files inside the current workspace

and fully read the active command prompt.

Still, explicit manual approval is completely required

to permanently edit files

or access the internet.

Approve for me intelligently only asks for explicit permission

when it encounters potentially unsafe system encounters potentially unsafe system actions.

Full access simply means Codeex can freely edit files far outside the designated workspace

and easily access the internet

without ever asking for prior approval.

Exercise extreme caution

and ask vital questions when using this.

I explicitly choose the approve for me

I explicitly choose the approve for me setting.

Our updated permissions are cleanly applied.

I press enter

and transition to the key map configuration.

In keymap, we have our transcript, external editor, clear terminal, and more options.

We practically have multiple distinct configuration options readily available right here

alongside some incredibly useful direct operational options.

What we can actually do here

is utilize the basic left and right keyboard arrow keys

to smoothly navigate

and group items.

We firmly use the enter key

whenever we strictly need to modify

or edit an existing shortcut.

We smartly use the star symbol strictly for creating completely custom shortcuts,

the dash symbol to quickly unbind an active key,

and the escape key to easily close out the menu entirely.

I simply press escape right now to smoothly go back to the previous screen.

Right after successfully configuring our system permissions,

we logically have our custom key maps fully sorted out.

Next up,

we carefully review our active system approvals.

You can transparently see absolutely all the recent system changes

we manually made right here.

We actually changed our primary AI model twice today.

We closely reviewed the IDE context

We closely reviewed the IDE context settings.

We officially updated our security permissions

to approve for me.

Finally,

I press Ctrl C.

Executing that specific command

officially closes out the active chat session entirely.

It is crucial to note

that this specific underlying configuration

genuinely remains the exact same

across every single linked application environment.

Thankfully,

the powerful codeex tool

is readily available

right here, too.

We can practically

do so many different

amazing things with it.

If we smartly decide

to switch over

to the exclusive

pre-release software version,

absolutely all

the newest experimental features

become instantly available.

I am going to intentionally open up a brand new dedicated project folder

officially named Metabrains for our officially named Metabrains for our work.

We carefully select this exact folder directory

and smoothly open up our fresh chat interface.

I explicitly confirm that I fully trust the verified authors

operating in this specific environment.

I smoothly close this secondary pop-up window.

I promptly open up a brand new code file

appropriately named code file appropriately named index.html.

You can distinctly see the familiar codeex logo

right inside this document.

We can now finally start to actively write out our core underlying code

write out our core underlying code snippets.

The generated codeex AI response will seamlessly appear right here on

the seamlessly appear right here on the interface.

We will be able to clearly see our active IDE connection,

the linked source repository,

the comprehensive onboarding bug log,

and of course our preferred dark mode visual theme.

we will consistently get highly accurate direct

responses moving forward.

Now, we need to take a very close look at our overall system usage metrics.

I purposefully navigate back over to the main settings page.

The exact same user account is actively being used uniformly everywhere.

We can easily modify our deeper codec software settings right here.

You clearly see broad configurations,

custom personalization,

advanced MCP servers,

web hook integrations,

system usage,

and active integrations,

system usage,

and active billing.

We absolutely need to check these panels timely and consistently

to perfectly know exactly how we are efficiently carrying all these things forward.

We can chat and utilize commands.

We can switch models and connect apps.

Inside the primary settings menu,

we prominently have the visual appearance and core system configuration tabs.

Right at the top,

we absolutely also have detailed personalization settings,

custom keyboard shortcuts,

active usage limits,

and standard billing limits,

and standard billing information.

The general designated application usage limit strictly caps out at exactly 5

limit strictly caps out at exactly 5 hours.

Currently, we happily have a massive 99% of that time left available.

The broader weekly limit currently shows 100% completely left over.

We have successfully expanded our overall codeex usage capabilities

alongside the powerful GPT 5.5 deep thinking mode.

We can effortlessly purchase an additional credit balance whenever needed.

Supported system integrations proudly include seamless browser connections,

broad computer use permissions,

and robust MCP servers.

The core coding section beautifully includes active web hooks,

secure remote connections,

complete git source control,

safe isolated environments,

and managed work trees.

Our foundational setup phase is now entirely complete.

The highly anticipated direct usage strictly begins right now.

We will now efficiently set up

highly secure cloud-based development environments

right here in this specific environments

right here in this specific module.

You probably remember that we previously ran our codeex agent directly here on the local machine.

Absolutely all of our core operational functions were safely contained directly inside it.

Now,

however,

we will purposefully run

our advanced cloud-based development environment

securely integrated

directly within

our main codec setup.

First things first,

I will quickly navigate back over to the main settings panel

and intentionally make the system font slightly smaller

for better font slightly smaller for better viewing.

We gracefully go over to the visual appearance tab

and actively change the primary text size down from 24

to precisely 20.

Now,

the overall tech size is just so much better

and more manageable.

I will clearly explain to you generally

what these advanced cloud-based development environments actually are.

We will deeply understand this entire concept right here today.

You absolutely should know right up front

that this is essentially a preconfigured,

entirely remotely hosted software workspace.

It actively contains your preferred IDE

alongside all your necessary background

alongside all your necessary background tools.

Modern developers can effortlessly code,

rigorously test,

and smoothly deploy complex software

straight from the web

complex software straight from the web browser.

The acronym CDE specifically stands for

cloud development environment.

It effectively solves that highly frustrating

age-old problem

when a specific piece of code

miraculously only works on one specific person's local

works on one specific person's local computer.

Brand new software engineers can easily start

actively coding

in mere minutes.

This is our dedicated cloud system.

Now let's take a moment to talk about codeex itself.

Codeex fundamentally has some massive, undeniably big advantages here.

Codeex genuinely works absolute best when it can safely access the entire full code repository.

It impressively also has powerful built-in deployment tools.

A cloud environment safely lets codec seamlessly talk directly to remote code talk directly to remote code repositories.

It can reliably run terminal commands,

execute unit tests,

and thoroughly check execute unit tests,

and thoroughly check projects.

It safely makes automated code changes.

The biggest overall benefit is undeniable absolute consistency.

In significantly older traditional local development environments,

various developers constantly use completely different underlying operating systems

and vastly different local machine

and vastly different local machine settings.

This inherently creates the infamous frustrating

well it perfectly works on my machine problem.

Modern streamlined cloud environments completely remove

these highly annoying problems entirely.

Absolutely everything that we actively do right here.

For example, the previously pinned chat log specifically

about making a functional calculator

about making a functional calculator application.

Absolutely all our deep technical discussions are safely stored

permanently in this robust cloud system.

We can effortlessly and rapidly review our collective past work right here at any given time.

Other incredibly massive benefits strictly include nearly instant team on boarding,

highly consistent underlying tool setups,

absolute hardware independence,

and reliable long-term session persistence.

Now moving forward,

we will thoughtfully choose a specific cloud development platform to use.

I will happily show you some excellent real world examples

some excellent real world examples shortly.

First and foremost,

we will take a very close look at GitHub code spaces today.

It is a remarkably secure,

highly robust cloud development environment used by cloud development environment used by many.

If we genuinely do not want to use this specific one,

we can alternatively utilize gitpod.

We actually use the git pod platform quite a lot in our daily workflows.

It is a fantastic strictly ondemand,

highly scalable development environment.

For massively big enterprise companies,

we consistently have the AWS Cloud9 infrastructure safely available.

We can seamlessly use it directly for our larger,

more complex coding tasks.

It is basically a fully complete cloud-based integration development environment from Amazon.

It is truly a complete fully featured IDE right in your browser.

We can effortlessly write smoothly run and quickly fix our complex code directly inside it.

These are a few older very solid

These are a few older very solid examples.

Now I will explicitly search the web to see if Codeex itself is officially classified as a cloud-based development

classified as a cloud-based development environment.

It confidently says yes.

Codeex created by OpenAI is officially a cloud-based AI software engineering

cloud-based AI software engineering agent.

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.

This essentially means that the powerful tool we are actively utilizing right now

acts almost exactly like a completely standalone,

fully robust cloud-based development environment in itself.

I strongly suggest that we consistently use this incredible tool

to intentionally make a highly secure,

deeply isolated remote workspace.

There are honestly quite a lot of highly technical backend things actively running here.

I will quickly hop back and change the UI font size once again

because it simply does not look visually right on this display.

I will purposefully make it just a little bit bigger

strictly for the sake of our video course clarity.

Now we simply go straight back into our main codeex application.

Everything visually looks exceptionally good.

Now we have our advanced reasoning engine and other vital backend things running.

We will take a complete comprehensive look at this.

Nextly shows how we put things into a complete cloud-based setup.

Now moving smoothly forward,

our very next crucial task

is to securely connect

our remote GitHub repositories directly.

We absolutely need to establish

a solid link to our GitHub account

directly within the main codec system

inside our primary GitHub platform.

A tremendous amount of distinct configurable options are always readily configurable options are always readily available.

You can clearly see the active status regarding the connection with GitHub right here on the interface.

If I cautiously go over to the main settings panel,

specifically looking closely in the connections option area,

there is currently absolutely no active connection established.

The standard SSH and secure git credential options similarly show that

there are simply no active connections

there are simply no active connections present.

Furthermore,

down in the remote servers and local browser tab,

there is similarly no connection.

In the computer use section,

we can alternatively use the Google Chrome browser extension.

So,

our primary GitHub repository profile is clearly not effectively connected to the system just yet.

I will intentionally just type out the specific query.

Is GitHub firmly connected to codeex right now?

to quickly see if we actually get a reassuring green verification tick.

This built-in diagnostic tool will thoroughly check the backend systems

and explicitly tell us if our GitHub account is successfully connected or not.

Simultaneously, I will efficiently search for the precise phrasing GitHub

and official codeex integration securely and official codeex integration securely online.

This highly powerful system connection can miraculously be added directly

without any significant friction.

It prominently includes highly advanced automated pull request code reviews,

a dedicated co-pilot AI coding agent,

and deeply integrated GitHub workflow deeply integrated GitHub workflow actions.

We will comprehensively discuss absolutely all of these incredible back-end setup options

in extreme back-end setup options in extreme detail.

The diagnostic system now clearly shows that the official GitHub integration plugin

is indeed fully available directly within the primary codeex plug-in section.

But unfortunately, this specific local workspace folder is actually not initialized

as a valid Git repository right now.

A brand new Git tracking folder is quickly being created in the background.

Now, if we explicitly click the prominent plus button on the user interface,

we can clearly see the GitHub icon safely listed in the available plugins directory.

But we critically want to verify exactly which specific user account

is currently connected directly to our active GitHub plug-in extension.

We currently cannot seem to find our primary GitHub profile.

So, we will manually initiate a deep search for it.

When we effectively run the search, the official GitHub authentication app finally appears.

The application safely requests broad permission to actively access repositories,

track software issues, and manage pull requests.

But we have simply not fully connected it just yet.

So we will proceed to log securely into our main GitHub account.

This is our dedicated primary account explicitly named Metabrains-dell.

It undeniably has many repositories and we have done a lot of work here.

We will now meticulously connect this specific GitHub account directly

to our active codec system workspace.

When I confidently click the connect button, it explicitly asks for final permission

to securely connect to GitHub permission to securely connect to GitHub servers.

It safely allows the underlying chat GPT engine to carefully read our previous chats

and stored memories to consistently give significantly better contextaware answers.

It clearly states that your deep personal privacy permissions are heavily respected

and you are always completely in control.

It does warn that external connectors may possibly introduce some slight security risk.

I will boldly open up our direct GitHub developer

up our direct GitHub developer dashboard.

You can visually see that the secure GitHub app

authorization connection is actively starting

in the background.

Absolutely all our ongoing critical development

work is safely housed right here.

We will press firmly to continue onward to GitHub

so we can comfortably go straight to our main

profile account.

It will naturally take a little bit of processing

time to fully connect.

A basic connection will form.

You can see it is connected.

I open plugins again.

Now you will actively see that our dedicated

GitHub plugin is finally working precisely

as intended.

It smoothly works specifically because it is

successfully connected to the back end.

If it is ever mysteriously not connected,

we can easily check our credentials again

to see if we can actively reconnect it.

We currently have our active user login,

but unfortunately adding the specific external link

just adding the specific external link just failed.

Why exactly did it suddenly fail here?

We must remember that this is our specific

chat GPT plus tier account.

You absolutely must remember this vital detail

because it impacts our detail

because it impacts our permissions.

Now we will purposefully open up the completely

alternative chat GPT account

completely alternative chat GPT account instead.

We will securely bring our dedicated Michael Deont

user account right here into the active workspace

to try again.

Our premium chat GPT plus subscription tier

is fully available right here.

Now we will carefully attempt to securely connect

the integration system once again.

It will systematically connect our main chat GPT

interface to the

our main chat GPT interface to the repository.

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.

We obviously also have the standard option

to immediately disconnect the authorization

any time.

We will gracefully proceed straight directly

over to the main GitHub authorization

over to the main GitHub authorization portal.

Now it will successfully build the required connection directly in our correct targeted application.

It strictly demands highly secure multiffactor user authentication.

We will comfortably utilize the standard authenticator mobile app to handle this.

The mobile authenticator app will swiftly finish processing our deep security verification.

Now you can clearly see that our primary GitHub profile is finally directly connected perfectly.

I will quickly pivot back over to our main codeex interface.

You can clearly see that our secure software link is now fully established and solidly connected.

If we carefully look directly at our active system plugins list right now,

absolutely all our relevant GitHub integration tasks have delightfully started showing up directly in there.

We will smoothly navigate back over to our main chat terminal interface.

You can very clearly see

our dedicated GitHub functionality

is directly added

and fully available right there.

We will quickly go back over to the plugins tab

and our GitHub features

will be permanently included

in the active workflow loop.

It will effortlessly come directly

into our daily software development work.

Ultimately, we have incredibly successfully added

our robust codeex AI tool

to perfectly sync with our remote GitHub code repositories.

Moving logically to the very next crucial step,

we will thoroughly talk about

the highly specific agents.mmd configuration file.

This incredibly important file

is primarily used for organizing

massively big software development projects.

We specifically utilize it

whenever we happen to have

many complex automated tasks

or a full highly detailed business use case

to carefully look at.

I will intentionally open it up

right here on the screen

so you can clearly see

exactly where these vital agent configuration files naturally come from

and exactly where to easily find them.

It will reliably give us

the system response

directly and accurately.

The dedicated agents.mmd file

immensely helps us

to deeply inspect

and standardize our overall project

standardize our overall project architecture.

You can clearly see it actively looking deep inside our raw project files.

Here it explicitly states that the active workspace is entirely empty right now.

There is absolutely no agents.mmd file found.

It checked the temporary scratch space and verified there is no file.

To successfully create one from scratch, we absolutely must make a brand new correctly formatted agents.mmd file.

I will manually go ahead and create a brand new foundational file right here for you.

This incredibly efficient way,

we can consistently see

absolutely all the necessary

high-level production details

firmly embedded safely

within this specific file.

First,

the core structured agents file

is quickly drafted out.

Right after that initial phase,

we can comfortably make far more highly nuanced text changes

to this preliminary draft.

In this specific advanced technical setup,

we usually really need to carefully check

if our highly specific basic operational rules

or distinct business use cases

are actually working

business use cases are actually working properly.

It successfully and directly created an excellent base foundational agent file right here for us.

If we carefully review the generated file, we can clearly see its intended core purpose.

Besides the purpose, there is a clear project overview.

We also see a working agreement, a layout, and editing rules.

We can actively cross-check all of these fundamental operational rules precisely here in the document.

I will also make sure to explicitly tell you

exactly where this specialized configuration file

is typically used.

We consistently use the specialized agents.mmd file

to effectively establish strict working boundaries

and core rules for literally any AI agent

operating in the workspace.

There are basically no other bizarre tasks

or unrelated work explicitly meant for it.

Sometimes, unfortunately,

we literally have to go deep down into our underlying operating system

just to manually set up the complex agents.mmd file perfectly.

This tedious manual process admittedly takes quite a lot of valuable development time.

We essentially have to carefully look at so many different distinct things

like our strict project requirements,

core team work ethics,

and several other highly detailed technical several other highly detailed technical options.

We absolutely need to fully know how to properly handle these nuance things.

But for massively big projects,

we only deliberately include our basic setup requirements here.

Moving right along.

Next,

we will deeply discuss

exactly how to effectively use

this incredibly vital agents.md file

in standard practice.

Deeply understanding

this specific core concept

is an undeniably very important

foundational part

of the entire development process.

We absolutely need to fully know exactly how to actively create the underlying file directly from absolute scratch.

Now we purposefully transition

and move seamlessly right over

to the very next important part.

We will fundamentally learn

exactly how to appropriately handle

highly complex things

and deeply understand them

right after actively creating

the foundational

after actively creating

the foundational file.

This is fundamentally a highly special

deeply vital system instruction file.

It consistently provides invaluable deep guidance

and much needed environmental context

directly for our automated work.

It can absolutely also be used incredibly effectively,

exactly like a traditional readme developer file.

You might vividly remember that standard software developers

constantly use structured readme files.

In the exact same way,

we can use this file.

I have created a basic agents.mmd file,

but incredibly we can undoubtedly also meticulously make

a highly reusable foundational agents.mmd configuration template

right here in the workspace.

We can comfortably and securely include

absolutely all of our strict foundational base development requirements

firmly inside it.

This proactive step will flawlessly kickstart

our broader automation work immediately.

I will gladly proceed to show you

an excellent highly structured example.

Right now

I will purposely open up

Microsoft Word

or a standard blank dock text document.

I am deliberately using a blank doc right now

strictly so we can comfortably start a fresh

entirely new empty start a fresh

entirely new empty document.

Here you can very clearly see

exactly what critical structural things

are highly recommended and available.

First, we logically have

the high-level project overview section.

This clearly tells us

exactly what core deliverables

we strictly need

in the project.

Next,

we definitely have the strict team coding standards

that we must absolutely coding standards

that we must absolutely follow.

After that,

we discuss repository structures,

testing requirements,

security rules,

and large scale systems.

We will practically use

a fully functional,

highly complete overarching working system here.

Our strictly prohibited,

highly restricted system areas

will absolutely also be

meticulously explicitly listed

right here for immense safety.

Then our highly nuanced,

deeply specific primary AI

operational instructions

will be thoroughly included next.

Right after all the

comprehensive AI baseline

instructions, we will

seamlessly have all our

broader full feature

architectural options

carefully feature

architectural options

carefully documented.

This is essentially exactly

what we traditionally call

a comprehensive well

ststructured readme file

in standard ststructured

readme file in standard

development.

It practically has all our

complete strict baseline

instructions deeply

hardcoded and built

directly right into it.

After this section is

successfully completed,

the very next essential

technical thing dynamically

available is dealing with

our sensitive backend

environment variables.

We will deeply see precisely

how we can effectively

securely manage these

highly critical system

environment variables.

Now our next incredibly

critical technical discussion

is primarily about handling

robust backend environment

handling robust backend

environment variables.

These are essentially highly dynamic configurable key values

operating in the background.

We can actively store them either directly or indirectly

deep within our underlying operating system

within our underlying operating system infrastructure.

we can comfortably and securely utilize them later

for absolutely all of our other automated complex coding tasks.

Usually we deeply involve our complete highly systematic overall workflow process

directly here

to explicitly see exactly how a full robust software system is successfully constructed.

These are highly dynamic backend key values

that are stored strictly and directly inside the native operating system,

kept entirely safely outside of our vulnerable raw source code files.

They heavily detect and dictate precisely how the running process fundamentally behaves.

This brilliant system effortlessly allows developers to incredibly safely store highly sensitive security

store highly sensitive security credentials.

What exactly are sensitive credentials?

It is highly vital to see this clearly.

If we fail to understand this, our work

If we fail to understand this, our work suffers.

Sometimes developers are understandably incredibly afraid

that their highly sensitive personal or corporate information

will eventually accidentally leak to the dangerous public internet.

Why exactly does this enormous fear

Why exactly does this enormous fear exist?

basically because our complete interconnected development environment inherently has some deeply guarded

inherently has some deeply guarded secrets.

These highly confidential items definitely include things like private API keys,

secure admin account usernames,

and highly encrypted user usernames,

and highly encrypted user passwords.

We absolutely have to carefully look closely at them

and protect them.

Now we officially pivot to selectively talk about the massive overarching enterprise operational level.

What exactly inherently happens

operating at the massive enterprise scale level?

Let us quickly intentionally open up a brand new fresh isolated chat window

at the highest enterprise level.

Actively managing profound structural secrets properly is absolutely critical

for safely protecting tremendously sensitive proprietary information.

Secrets routinely may include remote cloud access keys,

massive database passwords,

complex encryption keys,

vital third-party API credentials,

and various access authentication tokens.

Handling environment variables securely with codecs is important.

These specific crucial security items are undeniably very important

to actively manage appropriately right here.

Usually wildly different distinct deployment environments

inherently fundamentally require completely different sets of unique configuration

different sets of unique configuration values.

We can intelligently deploy and actively utilize them safely over there.

Let me clearly tell you

whenever I actively try to perform a direct system search for standard environment variables,

you immediately see our primary system environment variables are visibly available precisely right here.

You will undeniably see that absolutely all of our current environment variables

are entirely accessible and available literally right now.

Sometimes it happens to merely be the static number of active system

static number of active system processes.

Sometimes it is a highly confidential external API key.

We can smoothly dive deep directly right into the backend system variables menu

carefully enter the specific custom variable name

and its corresponding strict value directly

and permanently safely store it.

So the next time we run a use case,

all variables are automatically set

variables are automatically set perfectly.

How exactly is this properly handled

inside a secure underlying database

inside a secure underlying database architecture?

As you can visibly observe precisely here,

located deep inside the primary configuration interface,

we purposely actively include a dedicated corporate company database link.

If there happens to clearly be a specific network port required,

we firmly include it.

If there explicitly is an overarching master application configuration requirement,

we safely add the core app environment variable

alongside the specific designated app

alongside the specific designated app port.

Secure, highly confidential API credentials will absolutely come directly right here.

For one clear example,

if we genuinely want to safely utilize an external OpenAI API authentication key,

we securely do it precisely here.

We can undoubtedly also clearly see secure encrypted payment gateway keys stored right here.

Then there are massive authentication backend settings designed purely to store multiple dynamic secrets.

These environment variables brilliantly enable large organizations to safely manage app configurations.

It prevents leaking sensitive

It prevents leaking sensitive information.

Codeex handles keys safely too

without hard coding.

I will definitively also sincerely tell you that

strict environment variables frankly

may not initially actively seem incredibly very important right now

when we merely successfully create basic simple software absolutely

like a fundamental

basic calculator or standard normal terminal tools.

However,

the exact moment when we actively rigorously try to fundamentally change our massive software architecture

or alter major things safely on a significantly much larger,

incredibly massive corporate scale,

literally many

distinct individual things

wildly realistically

start changing

aggressively side by side

aggressively side by side

simultaneously.

We immediately rapidly actively see

literally multiple deep cascading

fundamental code structural changes

fundamental code structural changes

happening now

moving confidently right forward

seamlessly.

We will deeply actively rigorously

explicitly discuss

all of these major systematic

fundamental software changes

and deeply integrated

highly complex AI functions

directly later.

We will explore this

in the next sections

perfectly.

Authentication and

access configuration is a critical part of using open AI codecs in an enterprise development codecs in an enterprise development environment.

Authentication verifies the identity of the user or system attempting to use codecs

while access configuration defines what that user or system is allowed to do.

Together,

these controls ensure that

only authorized developers,

teams,

and automation tools

can interact with repositories,

environments,

APIs,

and sensitive project resources.

In enterprise software development,

codeex usually works with cloud-based development environments,

GitHub repositories,

CI/CD pipelines,

and internal tools.

Because these systems may contain confidential source code,

credentials,

customer data,

and deployment customer data,

and deployment configurations,

access must be carefully managed.

A weak authentication setup can expose the organization to unauthorized code access,

accidental changes,

or security access,

accidental changes,

or security breaches.

Therefore,

enterprises commonly rely on identity providers,

single sign on,

role-based access control,

and audit role-based access control,

and audit logging.

The authentication process normally begins

when a developer signs in

using an approved identity provider.

This may include enterprise login systems

such as SSO, OOTH, or multiffactor authentication.

Once the user identity is confirmed,

the system checks whether the user has permission

to access codeex,

the development workspace

and the connected development workspace

and the connected repositories.

This ensures that codeex activities are tied

to a verified user

and can be tracked for accountability.

Access configuration determines

the scope of codeex's permissions.

For example, codecs may be allowed

to read a repository,

analyze code,

create a branch,

run tests,

or open a pull a branch,

run tests,

or open a pull request.

In some cases,

it may not be allowed

to directly merge code

or access production directly merge code

or access production secrets.

These permissions should follow the principle of least privilege,

meaning codecs and users should receive only the access required

to complete their assigned tasks.

Repository access is especially important.

Codecex must often inspect project files,

understand dependencies,

and modify code.

However, not every repository should be accessible to every user or AI workflow.

Enterprises should configure repository permissions based on teams,

projects,

and business sensitivity.

For example, a front-end developer may receive access to UI repositories,

but not to payment infrastructure or identity management services.

Environment variables and secrets also require strict control.

Codeex may need to understand variable names,

configuration patterns,

or runtime requirements,

but it should not expose or hardcode secret values.

Sensitive credentials should be stored in secure secret managers

and injected only when required.

This prevents accidental leakage of API keys,

tokens,

database passwords or cloud credentials into source code.

Auditability is another major requirement in enterprise access requirement in enterprise access configuration.

Organizations should be able to review who accessed codecs,

which repositories were used,

what tasks were performed,

and what changes were generated.

Audit logs help security teams investigate incidents,

enforce governance policies,

and demonstrate compliance with internal or regulatory compliance with internal or regulatory standards.

A well-designed authentication and access configuration model

allows enterprises to use codec safely

and enterprises to use codec safely

and efficiently.

It protects sensitive assets

while still enabling developers to benefit from AI assisted coding.

By combining strong identity verification,

scoped permissions,

secure secret handling,

and continuous monitoring,

organizations can create a controlled environment

where codeex improves productivity

without increasing operational risk.

We discuss codeex workflows.

Now we want to see how codeex uses large workflows.

We look at complete software solutions

and complete software solutions

and workability.

Sometimes we must see how the whole process grows over time.

For this we change and improve code on a large scale.

After these changes we check the overall process understanding.

I will tell you about codeex workflows.

Codeex helps developers in the software development life cycle.

It does repeating tasks.

It makes the coding environment fast.

It helps us understand how to fix different problems.

It helps us understand different work processes.

The most important discussion is how we use codecs.

We start with a prompt.

We can add details in the prompt.

This helps software work well.

We use prompts to make software processes easy, fast.

We start with the prompt.

We can add details in the prompt.

The important thing in the prompt is a defined objective.

We must have a defined objective.

We must have a defined objective.

We bring this objective into our software and working process.

First, we take the generation process.

We understand the process on a large scale.

We see how we generate scale.

We see how we generate everything.

We have one big question.

The question is how to define the objective.

We look at things to define it.

We will see how these things work together.

This is a very strong and important point.

We must know how to set up objectives for large generation.

After we set the objective, we look at the next steps.

The next step is feature development.

Feature development is a process in our pipeline.

After development, the next thing is software defect identification.

We must make this defect identification process strong.

After we find defects, we move to next steps.

The next steps are refactoring and optimization.

First, we must define a task.

We must have a clear task definition.

After we define the task, we provide background context.

We provide this context on a large scale.

I will explain this process to you.

I will use a flow diagram to show how things work.

First, we have the task definition.

Next, we have task context.

We must know how to add the context.

After the context, we need a detailed prompt.

Then, we connect our main prompt.

Then, we connect our main codeex.

We connect codeex with our own code bases.

We connect codeex with our code bases

to show complete analysis.

After analysis, we must have solution

After analysis, we must have solution generation.

Solution generation must be available.

After solution generation, the next step is review.

I tell you we need these things in our prompt.

When we have these things, our prompt starts.

Inside this prompt, our solution generation process starts.

Here we have our solution generation.

After we generate the solution, we review it.

We check everything in the review step.

After the review, another process starts.

We call this new process starts.

We call this new process testing.

Testing is very important here.

In testing, we include debugging.

Both testing and debugging must happen together.

We need both in our workflow.

They help us find and fix problems.

These steps make the software better and ready for final stages.

Both testing and debugging must be present.

The last step available here is refinement.

We call this refinement process iteration.

We do refinement to make software better.

After the refinement step, we commit changes.

We save all the changes we made.

This is the complete process.

At the end, our workflow closes.

It closes at the deployment stage.

We go to closes at the deployment stage.

We go to deployment.

We deploy our project into our system.

These steps are helpful on a large scale.

They help us create a better score.

They help us create a better decision tree for work.

This is how the complete workflow operates from start to finish.

We follow these simple rules to make good software.

Every step is important for the final product.

Deployment is the final goal of this journey.

Our next talk is about codecs.

We will learn about our projects in codecs.

Project navigation is a very important AI skill in modern software development.

In big business places, developers work with big repositories.

Often these repositories have thousands of files.

We can see our multiple services directly.

It also sees big documentation,

complex dependencies,

and multiple servers.

Understanding these projects by hand needs much time and effort.

Codeex helps developers understand the project structures well.

It finds correct files,

traces dependencies,

and locates our implementation details.

I go to the project menu directly.

I click start from scratch.

I name the new project Metabrains.

I start one project directly here.

I save it.

Now we have a new project.

There is no chat available yet in the project.

You see our explorer and object project.

You see our explorer and object options.

If we turn on the explorer,

our file opens automatically.

You can see we have no document available yet.

With time we will make many additions and changes.

Automatically our response and style will change.

I will start from the beginning.

We will look at all the changes we make from start to now.

Along with changes,

we will also see the time.

We will see how much time one full cycle takes.

We can look at the complete process directly.

Sometimes we must approve things directly to understand them.

I will tell you.

I will type what things should be in our project.

I write create an agent MD file.

We will create the agent.mmd file here.

This makes our agent work in a much better way.

I type because this is a corporate sales manager and content creator project.

It will do the first step of our project here.

First of all,

we give it the context and our details.

We are making the employee do these things here.

We will include this directly for our approval.

I tell you that a complete process discussion is very important here.

In this we have to involve all our details.

We must involve our full working process.

Here you can see it will take some time.

Obviously it is working in our exact folder.

If I refresh our folder here you will see the agent ND file is created.

We can directly review it here.

It created the agent.mmd file with a tailored operating brief.

This is for the corporate sales manager and content the corporate sales manager and content project.

The agent.md file is made here.

You can see our exact source code and other things are available.

We can open it directly in our VS code.

We can open it in the default application.

We can also open it in our terminal.

These things are much better here.

We have a complete system environment.

Automatically we see all divisions and working ability here.

Sometimes this working ability or complete process causes problems.

It causes problems on a big scale.

We see many issues in our big scale.

We see many issues in our work.

We usually create our complete empty MD file at the very start of the project setup.

So on a big scale if any issue happens later we can understand it early.

We can do things early according to our system.

This is a basic discussion.

Now we see how complete generation happens.

We see how we take a complete process or understanding with us.

After the agent MD file we will directly look at our project structure.

I will go into the exact same folder.

I will include a new folder here.

This is from a previously created section.

You can see our portfolios are available here.

I will do all the portfolio discussion here.

I will now analyze our discussion here.

I will now analyze our repository.

I write analyze this repository and provide a comprehensive overview of the project structure.

It includes the main purpose of the application.

Then we have highlevel architecture.

Then we have important directories.

Then we have all options for important directories on a big scale.

After major frameworks, we have entry points.

After entry points, we have configuration files.

Then we have deployment related files.

Then we have deployment related files.

Then we have testing structure.

Then it says present the information in a structured format suitable for onboarding a new developer.

We can take our things directly in developer onboarding too.

We can involve them.

This is a complete structured repository layout that we use here.

Sometimes we must see some changes in this too.

In this we also involve multiple repositories and options multiple repositories and options directly.

When I enter this it will directly go to our folder.

The index file is inside.

You can see this is like our index file.

When the index file opens,

a complete portfolio website is available.

Now we will see how to enhance

and understand this portfolio website on a big scale.

This will happen in our codeex here.

It understood the child item here.

After that it showed our files.

It has shown the key pattern too.

We have one HTML document.

We have one stylesheet.

We have one script bundle.

Then we have some static assets.

We also have all other things available to use directly.

Now I will take our details.

I will see how our process runs.

I will see how all direct discussions and details run.

With this we will take our setup.

Usually this needs a lot of time if we take these things in another environment.

But here our things are much simpler now.

We can include much better things and accounts here.

I will look at our direct use case now.

It read out our whole folder here.

After that it told us there are no platform specific deployment manifests checked into the repository.

The deployment guidance is document

The deployment guidance is document only.

After that we have a testing structure.

Then all other things have come.

Now we have gone inside our project.

We have seen how we will include our system.

Now I will see what entry points are available there.

I will write to find the entry points.

If we want to look at something other than entry points,

we will involve all user authentication features.

Here we will see how we can look at them.

Along with this,

we will get a direct response from the complete system.

We will see how we take things directly in our system.

First I will type to locate and explain the implementation of the user authentication feature.

I will identify all the components involved here.

Then I will look at the authentication flow.

Then I will look at the authentication

Then I will look at the authentication middleware.

Then I will look at password handling.

Then I will look at the token generation

Then I will look at the token generation process.

Then I will look at the session or token

Then I will look at the session or token management.

Then I will provide a step-by-step explanation of how the application

explanation of how the application starts.

Then I will process the requests from login to successful authentication.

These things bring all our details here.

All our handling has come here.

Now generating code from requirements

is one of the most practical uses

of OpenAI codeex in everyday development.

Instead of translating every single business requirement

into working code by hand,

developers can provide codecs with a vast amount of information

or context.

We can include clear instructions,

behaviors,

and context.

We have multiple forms of languages

available to use.

Let me open Excaladraw here.

As you can see, we have some business languages.

For example, we can allow users to export reports as CSV

or involve RO based access control,

also known as RBAC.

Codeex helps bridge the gap between these requirements and implementations

by identifying relevant files,

suggesting changes,

creating new components,

updating APIs,

and adding tests where needed.

However, codeex works best when the requirements are very specific in nature.

Let me show you how to include basics in codeex right from the start.

Suppose you want a plan mode

and after that you want to pursue a goal.

Then you might want to create a document.

After document creation,

you might want to include photos.

You have multiple plugins

that you can use side by side.

Even if you need a browser plugin,

you can use that one too.

If you have specific content to use,

that can be utilized as well.

For instance,

we can go to documents or downloads,

select an available document

and use it.

After that,

we select our model.

This latency is quite important.

Therefore,

I will use a latest model here.

With that latest model,

we can increase speed

and manage latency.

Well, after this,

our prompt should contain very detailed options.

First of all,

a well- set prompt has some specific elements available within it.

I will explain these elements to you.

A good prompt includes all these necessary components.

The very first thing is context

followed by the role details

and then the requirements.

When discussing requirements,

it is a crucial point

because codeex works better

when the requirements are specific.

A vague prompt may produce incomplete or misaligned code.

A strong prompt includes the feature goal,

affected users,

input and output behavior,

files or modules to consider,

coding standards,

test expectations,

and what our codec should avoid changing.

Developers should treat the codeex generated code as a first draft

so we get a complete response right from the very start of it.

Next, after the requirements,

we need to establish our acceptance criteria.

This defines the standard our response must maintain

when we receive it.

At the end,

we sometimes use a negative prompt.

In a negative prompt,

we specify the things

that we do not need.

In the rest of the prompt,

we list all the necessary things

that we want.

However,

in a negative prompt,

we mention all those exact things

that are not required

for our output at all.

For example,

let me show you a sample prompt

right here in this section.

We can go into codeex

and type out our prompt.

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.

This defines our role.

The complete task is outlined in plain words.

After the task,

you can see our functional requirements are discussed

such as adding an export CSV button near the reports table.

Towards the end,

all the detailed steps we need to perform are available.

This is our acceptance criteria.

The export button appears on the report page.

Clicking the button downloads a valid CSV file

and the CSV contains the same rows displayed on the table.

It will take data straight from the browser.

Commit the repository in GitHub

and provide the response in document form.

Generating code from requirements with codeex improves overall development speed.

When our prompts are better,

the final results we get will also be much better,

which we can then utilize today.

Clear requirements,

a defined scope,

and strong acceptance criteria help codeex produce code

that is easier to review,

test,

and merge in big enterprise teams.

We are discussing how big enterprise teams can incorporate these modern features on a larger scale.

Today our next discussion will be related to editing and refactoring existing code bases.

We have generated this exact code as an example project where we are utilizing all these core elements in real time.

Now suppose our initial code is generated and ready.

To demonstrate this point,

well,

I will show you a custom calculator code

from our older previous calculator code

from our older previous generations.

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.

Now,

we will discuss editing

or refactoring the code.

Here you can see that

we asked to create a calculator code.

It took a quick look

and made a plan for us.

After making the plan,

it implemented the calculator

in the calculator.py file.

This is our calculator.

Everything in it is functional

from start to finish.

If we want to run it,

we will see that the verification passed

using the bundled Python runtime.

Note that Python and py

are not on our system path.

So if we want to use it in our environment,

we need all these our environment,

we need all these requirements.

I will open PowerShell here

or I will just open the command prompt.

In the command prompt,

we will give this command.

When I press enter,

you will see that

we have a complete response included here.

Now,

I will include it here.

There is an issue

in the first line of our code.

So,

we will run it from here to here.

I will copy this.

After copying,

I will go back to the command prompt.

Here is the command prompt.

Now we will include it in the command

Now we will include it in the command prompt.

When we include it,

you can see that

because this file is very old,

our file is not available here.

But we can still run it in our browser.

Now we will look at our editing and refactoring here.

Usually this is the most valuable capability

of our OpenAI codeex for enterprise software

codeex for enterprise software development.

While generating new code is useful,

developers spend a lot of time

improving,

maintaining,

and modernizing existing applications.

Codeex can analyze the current code base.

It can understand relationships between files,

identify code smells,

and suggest improvements for better suggest improvements for better readability.

First, I will explain the first thing.

This is what we call refactoring code.

This is a process of restructuring the existing code.

It improves readability,

maintainability and internal design without changing its external behavior.

We primarily involve this in our code review.

If I go to Excaladraw,

I can tell you that after refactoring,

the next thing is restructuring or editing.

That is very simple.

It is simple because we can come into our code include any line here

and include things by giving a local comment

or if we want to do overall refactoring

I can say to make this into an HTML file that I can run in VS code

here you can

see that now it will directly take our prompt

the code was previously available

now it will connect our Python calculator into a browserfriendly HTML calculator

into a browserfriendly HTML version.

Alternatively,

I will open our VS Code.

You might remember that we already included codecs in Visual Studio Code before.

So,

this will also be available for us to use in a much easier way.

Along with this,

in Visual Studio Code,

where everything else is,

we will automatically include our calculator

automatically include our calculator file.

Codeex is open.

All our generations and things are available in it.

Now you will see that our codeex file has arrived here in the codeex file.

All our things are directly included.

Now you can see that if we want

we can directly open the calculator in the browser

or we can copy its link and go to another browser.

If we copy its link

we just have to go

If we copy its link we just have to go here.

When we open it here

the calculator will open in our browser.

This is a very simple calculator.

If we want to open it in the internal browser of codeex,

that is also possible.

It will load and run our calculator in the codeex browser.

Here you can see that if we want

we can directly use this file in our VS code from the options.

We can include from the options.

We can include annotations.

If we want we can save a screenshot

If we want we can save a screenshot here.

After saving the screenshot here,

we can also use it in another browser.

We can come here and use it here too.

So if we want to make any design changes,

we can do that directly.

When working with legacy systems,

developers often face challenges such as inconsistent coding styles.

Here the coding we have is AI based coding.

However, if we talk about legacy systems,

they are systems where we manually write all the code.

We make all the changes and alterations in that code

the changes and alterations in that code ourselves.

there.

Sometimes there are outdated frameworks,

poor documentation,

and tightly coupled components.

Codeex can help developers understand the purpose of existing code before making modifications.

It does this by analyzing the related files and dependencies.

It can recommend safer refactoring strategies

and identify areas where changes may have downstream effects.

This significantly reduces the time required to understand unfamiliar code

required to understand unfamiliar code bases.

Despite these advantages,

developers should carefully review all refactoring changes

before merging them into the production branches.

Even when functionality appears unchanged,

modifications can introduce unintended side effects.

Now I will work on our code here.

I will go to our codeex.

In codeex,

we will write a prompt

that you are working as a senior software engineer in this repository.

The task is to refactor the existing code

without changing its functionality.

We will improve the code readability and maintainability

and remove duplicate logic with simple complex methods.

There is a lot of detail here.

The general overview of this detail is

that we should make our code readability and maintainability better.

As soon as I improve this,

we start getting our response.

We can directly include this response.

First,

it will look at the current state.

The main refactor target is

that we will slightly change the HTML file.

First of all,

we will include the keyboard handling.

After that,

we will see multiple changes in this HTML file.

If we want to review it,

our changes will automatically appear

wherever changes are being made

in our file.

You will see that the refactor is done

in one focused pass.

I am validating both sides.

Now, Python behavior should still pass

and the HTML script should still calculate

and respond to the button and keyboard actions.

Here, our checks have passed.

Now, if we reload our calculator,

many changes will be included

in our calculator.

Now, we have another very important thing.

It is not just doing a simple check.

It also performed a Python check.

If I show you the working after the Python check,

it also included HTML behavior checks.

The refactored HTML is built here.

It has only 123 lines.

I can say that our workability is much easier.

Now, if we look at the code review,

it changed many lines in the code.

For example, instead of display value zero,

it has set the display value to the default value.

Overall, it showed our functionality in depth.

It directly changed the error coming in the display

into show error.

Here too, it changed set display error to show error.

In simple words, it improved our code maintainability

and nullified the error-causing paths on a large scale.

It manipulated the errors into the show error function.

Exactly here too the set display error was changed to show error.

This means in simple words our code maintainability has improved.

It has removed the paths that cause errors on a large scale.

Next we will discuss context windows and scope.

Context window is a new topic.

People do not discuss it much.

I will tell you what a context window is.

A context window is the maximum text an AI model can hold at one time.

It works as the AI's memory.

Everything inside this window like prompts, history or files is seen by the model.

Before explaining how it works,

I will give you a simple example.

For a simple example, I will go to chat

For a simple example, I will go to chat GPT.

First, I write a message in chat GPT.

I say hi, I want to work with AI and HTML.

If I continue this conversation, it will write the code.

This is simple prompting.

We get our answer through it.

But if we do something else,

if we give a very long prompt again and again,

you will see a message.

The message says it is too long.

Let us see the size of the context window in chat GPT.

I will search for the context window of chat GPT.

It will show the context window size.

Usually the model has a 128,000 token window.

This means it takes 96,000 words or 250 to 300 pages of text.

I will copy this text and paste it many times.

I will do this until the prompt becomes too long.

I will copy it and go to a word counter website.

It is a famous word counter.

When I paste the words here,

you will see the website becomes slow.

This is because there are 9,776 words in total.

We put this in our prompt.

It has 76,000 characters.

Now suppose I paste the last text here.

You will see a message.

It says the long text is added as a file.

The text will show up here.

I will write that if I put this file in the chat,

it cannot process it.

The message is too long.

We want to see the context window size of chat GPT.

It will take time.

You will see that the context window depends on the model.

Open AI does not always show the exact limit.

But if you see the message,

it means the text is too long for one input,

the file is too big,

or the user interface has strict limits.

If we use fewer words,

we will get our

If we use fewer words,

we will get our answer.

In the same way,

when we go to codeex,

we can see limits.

In the new chat,

we have limits.

Wait a minute.

I will open it here.

We know that codeex has some limits.

Even if we add many images,

files,

and documents,

there are still limits.

In real business projects,

apps have thousands of files and millions of lines of code.

No AI can read all the code at once.

Developers must help codecs focus on important information.

Scope sets the limits of a task.

It includes files,

modules,

and features.

Setting the right scope stops bad changes.

It helps codeex focus on the right parts.

Now I will tell you directly.

Suppose we get an answer.

How will a full developer work?

For example,

we will take an e-commerce store.

In our example,

we have an e-commerce store.

A developer wants to add a discount box to a product page.

The developer does not share all the code with Codeex.

He only shares the product model,

service,

controller,

form,

and tests.

This limits the context.

Codeex can focus on the updates.

It will not make bad changes in other places.

Where do we use this?

When we make changes,

this is very helpful.

We can modify things easily.

You will see two or three options here.

We can open it in VS Code.

We have a full Metabrains project.

Here it has all our files.

We can run the index file.

Here on the side,

we have our chat.

Our codeex is also running directly.

Besides codeex,

we have an agents option.

We can use agents to do our work option.

We can use agents to do our work directly.

Now we will verify our GitHub account.

Do you remember how I did GitHub

Do you remember how I did GitHub authentication?

We will authorize VS Code directly.

Our workflow and personal details will be added here.

This works for public and private projects.

We can include this directly.

If I show you the signin again,

authorization comes directly.

We can confirm it.

Suppose we want to verify using email.

The email will come using email.

The email will come automatically.

We will confirm the email here.

These emails run through a base setup.

We got the code here.

Then we will verify it.

Our VS Code will sign in and connect

Our VS Code will sign in and connect automatically.

After signing in,

Metabrains connects with our co-pilot.

We are running many windows.

In one place,

we run the agent.

In another place,

we use our IDE.

In a third place,

we use it as a

In a third place,

we use it as a chatbot.

So,

we must manage our context

So,

we must manage our context carefully.

Context window and scope management are very important for AI software

very important for AI software development.

By giving the right information and clear boundaries,

developers help clear boundaries,

developers help codeex.

It creates accurate,

good and reliable code.

We must look at these important things carefully.

Now,

our discussion is about reviewing our AI generated code.

In the AI generated code,

we want to see how we previously used codes like create calculator multiple times.

As you can see,

we have created the calculator here

and you can see that all our changes are also available here.

For these AI generated changes,

we first need to understand two or three things.

First,

in this complete software we are using,

whenever there are changes,

the red values will be all our previous values

and the green values will be our new possible changes

that we have used new possible changes that we have used here.

If you look here,

you can first see the set display error.

But now in our new code,

some things have expanded.

Let us suppose I directly include a prompt here

saying I want a scientific prompt here

saying I want a scientific calculator.

Now a scientific calculator will be created here.

Usually we had this one code

and we can call it version one.

Automatically this version of ours will be applied here.

And along with this version,

if we have any other versions available here,

they will be used.

First of all,

it will take some time to think about what things were discussed in the previous context.

It will review what discussions we were having previously.

After all those discussions,

our code will automatically start generating

will automatically start generating here.

All right,

it is reconnecting with our work.

Our connection with the model is being created

to see how a complete connection will be generated

and how our thinking will work on a larger scale.

Usually when we are looking at such a code

we have to do validation.

We can separate our unified difference from here.

We call this split

and we call the other one unified.

In the split view

our complete previous code base is on one side

and our new code is included on the other side.

In the previous one

you can see the display error

and here you can see how much our error evaluation is available now.

Similarly our if action is also available here.

We can see how much if action we had previously

and after that

how many evaluations are coming in our run action.

All right.

So all these things are being directly included in our system.

We are looking at multiple changes here.

You can see that our connection is being created once again.

Here we can change the model to a very simple one.

Make the speed fast

and also change the reasoning here.

Now besides all these things,

we have two options available here.

Review and undo.

In the review option,

we can directly review our code once in the first scenario.

And undo works exactly like our version control system.

It keeps multiple versions in our adopted system.

Here you can see that our system is now running

and it is telling us that it is upgrading the existing HTML.

Now let us suppose I take you to this HTML file.

I will show all the differences here.

They are here now

and we will also enable the rich preview.

Now you can see that this is our newer file.

Even after the newer file when we make changes again

those changes will also be visible here.

You will see plus 32

and minus 21.

This shows how many lines of code were removed

and how many lines of code were added to our total system.

When both these things work together

we automatically start getting our response

and work results.

It shows how we are managing things.

All right.

So this is our very detailed working process.

Here you can see all the changes.

For a simple example as we are reviewing now

the title was previously calculator

but now our new title has become scientific

now our new title has become scientific calculator.

All right.

If we look here now

all the design changes of our calculator are shown here

with plus and minus signs.

Also you can see that if we want to add something here

we can directly include a local comment.

For example I can say here

I want round buttons.

Okay.

So now we want our round buttons.

As soon as I post this comment

you can see it is included here.

Now this comment is added.

All right.

Similarly if we go here

I will say I want more buttons.

I am making very simple changes

in front of you.

I will add the comment.

Now there are two comments here.

All right.

In the same way at the end of this file

I will say that we need simpler functionality here.

Okay.

I will say simple functionality please.

All right.

This comment is added here.

After that we can go to the end

or just go to the start.

In the start I will change our name here.

Change the name as metabrains cal.

Okay.

Metabrains cal.

All right.

Now our comment is added.

You can see that three or four comments are here.

Now in our calculator we have a comment in row number 46

and a comment in row number 102.

After that there is a comment in row number 200

and then a comment in row number six.

Now what we have to do here is I can say make the possible changes asked.

Okay.

What will happen here is that based on the changes we included in these comments,

the changes will happen at those exact points.

I will only show you this one change that we demanded at the end in the comments.

We will see how it changes the name of our scientific calculator here.

And this is a very advanced feature.

We are reviewing our complete AI generated changes to see how our reviews can be applied on a larger scale

and how we can include them.

It will take some time to think.

Obviously you can see that it is thinking here

and after that it says I will apply the review comments directly.

First of all our name will be changed to First of all our name will be changed to metabrains.

After that the calculator buttons will be made circular.

A few practical scientific buttons will be included.

Here you can see our calculation.

Metabrains cal is written here.

After that we also included a comment here

that we want our buttons to be rounded.

So you can see that

by including height,

aspect ratio,

border radius

and all these things.

It has provided us

with some rounded buttons

that we can directly see here.

All right.

So all these things are greatly included in our working process here

and through this we can include it in our system

and it will work here.

Now we will get all our changes here.

You can see that whatever visual changes we have

it has included some lines in a file

and showed us the changes here.

We can also open that here.

Okay.

After that for the next changes it makes you can see our thinking process here.

In the thinking process as it is including our constants and other values

these files will automatically come here side by side.

Now it has updated our file.

We have all the commands here.

As soon as we open this in our browser

all our discussed changes are here

like metabrains cal

our buttons have become rounded

and now if we include anything here

that thing will automatically be directly included here.

Okay, our error came here.

We are seeing everything working.

All right.

If we suppose we need the value of pi here,

we get our pi value.

If we need the value of log 8,

we can directly input it here.

Also, you can see that this delete option is working directly here too.

If we look at all the signs here,

every sign that we have is working very easily.

We can directly enter all our values here.

If there is no responsiveness,

we can go ahead and directly include responsiveness in our code later.

But code review is the main thing that I have discussed with you.

After this, our next discussion is related to our prompt hints.

Next, we discuss the main usage of a prompt library.

We will see how we can use it

and where more options are can use it

and where more options are included.

First, I come here.

Instead of using everything,

I will search the prompt library in codeex.

Here you see codeex prompting.

First, I tell you this is a built-in collection of reusable workflows,

templates, and skills in OpenAI codeex and Agentic CLI.

When I go to prompting,

you see we often use prompts.

You interact with the codeex by sending prompts that describe what you want.

Example prompts are shown here.

Thread is a single session.

It has your prompt plus the model outputs and tool calls that follow.

A thread can include multiple prompts.

We use a chain of process to take things forward.

I will explain this exact process right here in our codeex.

In codeex, we go to our main user

In codeex, we go to our main user settings.

Inside these settings, we have

Inside these settings, we have personalization.

In personalization, our own custom instructions are included.

We can also switch our AI personality from pragmatic to friendly.

Both of these personalization options are here.

In custom instructions,

we can include all custommade personalized instructions that we want in our tool.

It is quite simple to include our text

It is quite simple to include our text

responses.

But sometimes we must see our clear deviation

and how we are working on stuff

and how these custom instructions work.

We have our memory which we can induce

right here in our experimental

induce right here in our experimental

form.

We see how our things can be included

and how we can take our many processes

and how we can take our many processes

forward.

Our standard options show how we will best

include our own memory.

First is the main enable memories.

Second is our good tool assisted

Second is our good tool assisted

memories.

We can also involve tool assisted memories

and involve all our process

or workability in it.

Next thing is our own custom prompt

Next thing is our own custom prompt

libraries.

What is a good prompt library?

I will tell you first that our prompt library

is a great reusable prompt hub.

In this we can do our text discussion

multiple times.

We can do multiple workings

for our single tool.

We must see one more thing here

from the chat GPT side.

There is no prompt library available here yet.

We have clear information about basic prompting.

But if I talk about the claude code,

there is a distinct prompt library available.

We can go there and see

the many prompts are collected

from the various anthropic guides.

This includes our common workflows

and best practices

and how anthropic teams take clawed code forward.

If I want, we can also see

the core understand prompts.

We see how we can use our own prompts

if we need a new prompt for git,

release, data, automate or product.

A set number of proper prompts are available

for every single thing.

we can reuse them multiple times over.

We can utilize multiple variations

or our many utilize multiple variations

or our many functions.

This very same thing is available here

in our claude.

But if we go to our codeex

then until now we do not have

these full prompt libraries available.

We can do one other good thing here.

We can come right here and ask a prompt question.

If we go into chat GPT

and for our codeex we include our own best prompts.

I can say I want a whole new prompt library

for my codeex.

It will then give a good reusable clean codeex prompt library.

Inside it we have all our good useful prompts.

We have our bug fixes,

text test generator,

code review,

refactoring,

feature builder,

API design,

performance optimization and security audit prompt.

All these things will involve in that exact thing.

From there we will take and use it well.

These various things are included in our entire core system on a large scale.

We must look at all these many things on a large scale to see how we can reuse them.

We will copy it and come inside this main system to use all our many this main system to use all our many prompts.

We will not use these exact things.

But besides this, we have all our 12 core besides this, we have all our 12 core prompts.

As we go forward, our prompt library will increase even more.

From 1 to 12 are many different options will be used and we will include them.

These things are used very much inside the entire are used very much inside the entire system with this.

We have a lot of great automation in our work on a large scale.

We can use that well.

I will tell you

we also have cool automations here on the side.

We can run our day brief,

week review

or smart project monitor.

But besides that

if we look at our cool templates

we have very many.

Now our next discussion relates to integration

we will see how to perform AI enhanced

we will see how to perform AI enhanced CI/CD.

First I will explain the full definition of CI/CD.

CI stands for continuous integration.

CD stands for continuous delivery

and CD stands for continuous delivery

and deployment.

Usually when enterprise level workflow loops run,

we have multiple projects.

We have standalone projects,

collaborative projects

or autonomous projects connected to multiple companies,

industries and businesses.

For them,

we must look at integration

and deployment.

This is a DevOps methodology

that automates building,

testing and releasing software.

We can discuss this as automation.

This pipeline allows development teams

to ship code updates frequently,

safely,

and reliably

while catching bugs early

in the development cycle.

Usually, we do CI/CD at an industrial or enterprise level

where we need automation.

First, we have continuous integration.

It is a practice where developers regularly merge their code

into a central repository like GitHub or GitLab.

Every time code is merged, an automated system builds the application

and runs tests until the integration

and runs tests until the integration finishes.

This ensures that the new code does not break the existing code base.

It allows teams to catch errors instantly.

Then we have continuous delivery versus continuous deployment.

How can we use continuous deployment.

How can we use CI/CD?

First, it gives a faster time to market.

New features and bug fixes reach users in hours instead of weeks or months.

There are fewer bugs, easier rollbacks, and better developer productivity.

CI/CD pipelines can be used in GitHub actions,

GitLab CI,

Jenkins,

and actions,

GitLab CI,

Jenkins,

and CircleCI.

I will search for codeex on Google.

Now,

for example,

if I share here that I want this in codeex,

then we can also do that.

how it becomes possible.

Integrating the codeex command line into the pipeline

enables open AI codeex to automatically evaluate build failures.

It analyzes vulnerability scans

and proposes minimal changes required to make the tests pass.

It executes code quality checks directly.

It also generates remediation patches

or pull generates remediation patches

or pull requests.

Usually when we talk about our process,

we can perform CI/CD in multiple forms inside our projects.

Here in this interface

and outside it,

if I go directly to the terminal,

I can run the CI/CD pipeline.

How can I do this?

First, I will search for codeex CLI.

The developer platform will open

which we can access directly.

Here we must install it.

I will come here

and command the system to install codeex.

We will copy and paste the required command.

You will see that codeex is already set up here.

Because of this,

we do not need to install it again.

We simply type our codeex command

and it will start running.

You have seen this here too.

Whenever we give a command,

we have a terminal option available on the side.

Inside this,

we can automatically initiate our working process.

We also have a browser option to run CI/CD

have a browser option to run CI/CD pipelines.

Usually,

continuous integration and continuous deployment

have become a foundation of modern software engineering.

Traditional CI/CD pipelines

automate the building,

testing,

and deployment processes.

This reduces manual effort

and ensures consistent software delivery.

With the introduction of AI powered development tools like Open AI,

enhanced CI and CD

introduces a new layer of intelligence

into the software delivery life cycle.

Instead of merely reporting failures,

AI systems can investigate the root cause.

They propose correlations

and create pull requests containing fixes.

This dramatically reduces the time developers spend troubleshooting failed builds.

It allows engineering teams to focus on high value work

such as feature development

and architectural as feature development

and architectural improvement.

Let me show you a simple example.

We can take any system here.

When we give a prompt,

you can see our working process begins.

We get options to debug an issue or review a plan.

I will select GitHub and ask it to review the newest and ask it to review the newest repository.

The newest repository will appear.

Then I will command it to analyze the latest pull request.

It must generate unit tests for newly added functions,

modified business logic and edge cases

to improve our error handling

to improve our error handling completely.

As soon as I include this,

the error handling scenarios will become much better.

The other responses will also appear here

for us to analyze directly.

Usually the GitHub workflow is infused here.

Inside the GitHub workflow, we can directly use our other generations

or directly use our other generations or processes.

Our other regions and our understanding will also appear side by side.

I must tell you another thing.

We usually face a concern about how to check our processes inside out

on a larger scale.

We will see that in a much better form.

Now in the CI/CD pipeline, you can see the local workspace is empty.

The GitHub account is authenticated

but git is not available.

If we set up these things,

we can cross-check our CI/CD pipelines.

We prepare a repository

and use the CI/CD pipeline perfectly.

Here I will give you the example of a pipeline.

If you prepare a pipeline of build which have a request,

it has many stage such as names

and tests will appear here.

If you connect codecs here,

then our AI tasks can work side by side with it.

Our next topic is putting codeex into our work process.

This means adding codecs to our build system.

When we do this,

the system helps us find problems.

If a build stops working

or a task breaks,

the tool sees the code quality issues.

Before, people had to look at every single problem by hand.

Now the system looks at the failures for us.

It gives ideas to fix them

and creates tests.

It can even make pull requests with good answers.

In a normal process,

a person sends code to GitHub.

Then our complete system starts running

Then our complete system starts running automatically.

Things begin to work on their own.

We usually watch these actions in our deployment area.

For enterprises,

this saves a lot of time.

People do not have to fix the same small problems again.

The codeex assistant helps keep the work active.

It understands the whole process of how things run.

We like having a place without mistakes.

Now let us look at consistency.

This is a very important benefit.

Sometimes working directly with these pipelines can be hard.

The steps become difficult to manage.

First I will go to our plug-in section.

We can see the GitHub plugin here.

Next I will search for codeex in the bar.

We see many results

but I want to find it in the profile settings.

I look at the list of options like packages

copilot

pages

and security.

Here I will search for the codeex.

And here we have our codeex.

We can also search in GitHub

or settings.

Then I decide to grant access.

To do this, I open our repository.

I click on the code button

and copy the link.

I will ask the chat, do you have access to this project?

The system will now check if it can reach the repository

and provide us with it

and how we can initiate our working

or a larger scale.

Sometimes we have to look at these details ourselves also.

We can take a complete process out here and our generation will be completed in that.

This is usually present at a lesser extent.

But now we will initiate a full-fledged process here.

You will see that it has told us here that yes, I can access the repository.

The access to our repository has also arrived here.

The second thing it said is that our default branch is main.

Visibility is public and effective permissions in the session are admin, maintain, push, pull and triage.

I can simply say here that we now have to include an agents.md file inside this.

This will directly include it and give it to us.

But the thing is we cannot create things inside this.

So right now we will only cross-ch checkck our agents.mmd file here to see if it is directly available to us or not.

These are our things.

I will now take our full detailed discussion.

You will see that directly after just 1 second our agents.md file has been included here inside it.

As you see git isn't available.

So here after inspecting it has directly arrived.

I can give access here to directly push the code to see how we can improve or include things on a large scale side by side.

Another very important thing is running here.

Usually in a base pipeline I could not run git push origin here because the directory is not a git repository.

Git is not installed in our current shell.

Let us suppose we want to install git.

How can we do that?

First of all, we will open our PowerShell.

Here we come inside this one.

Here I say our PowerShell.

This is our PowerShell window.

Coming directly inside PowerShell, we will state our git version.

Here you are seeing that the git version is available to us here.

Let us suppose we want to install our git.

If we use this directly, you are seeing that now we will say we want to install git with our basic widget.

Automatically our widget will be installed here.

On the basis of that widget, we will take our things inside running.

Usually these things are not explained to us.

We are just initiating our production and working on a large scale.

Here it will take some time to scale.

Here it will take some time to install.

Until it installs,

we will wait here.

Now due to some issues

our git is not becoming active.

I tried a lot to activate our git.

You are seeing the prefix branch prefix is working.

Everything is working.

We usually did not include our commit instructions.

But still it is possible that by opening these things

all these items come into these things

all these items come into working.

But still,

as a matter of fact,

the discussion here is that when integrating codeex,

organizations start in non-production environments.

This allows codeex to analyze failures

and generate suggestions.

Once the team gains confidence in the results,

they can gradually introduce more advanced workflows.

These include automated pull request generations

and our AI assisted bug fixing.

Overall, codeex acts as an intelligent engineering assistant

inside our CI/CD pipeline.

It will overall help us in building all our things.

These entire matters have been discussed here.

An autofix workflow begins the moment a developer pushes code to a repository

or submits a pull request for review.

The CI/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.

In traditional software development environments,

any failure in these checks would require a developer to manually investigate logs,

identify the source of the issue,

and implement a source of the issue,

and implement a fix.

With codeex powered autofix workflows,

the process becomes significantly more efficient.

Instead of merely reporting that something failed,

the workflow can immediately begin analyzing the problem

and preparing a potential solution.

This transforms CI/CD from a passive validation system

into an active participant in software maintenance and quality assurance.

Once a failure is detected,

Codeex examines all available information related to the problem.

This includes error messages,

build logs,

test outputs,

recently modified files,

project documentation,

repository instructions,

and any development guidelines defined in agents.mmd.

By reviewing these sources together,

Codeex gains a much broader understanding of the issue than a simple rule-based automation tool.

For example,

if a login related test starts failing after a recent update,

Codeex can inspect the authentication logic,

compare the recent code changes,

review the affected test cases,

and determine where the behavior diverged

from expectations.

This contextual understanding is one of the major advantages of AI assisted development workflows.

After gathering the necessary information,

Codeex performs root cause information,

Codeex performs root cause analysis.

Rather than attempting random modifications until a test passes,

it tries to determine why the failure occurred in the first place.

The underlying issue could be a missing import statement,

a renamed function that was not updated everywhere,

a changed API response structure,

an incorrect configuration value,

a dependency upgrade that introduced breaking changes,

or a test case that no

longer reflects the intended application longer reflects the intended application behavior.

By identifying the actual source of the problem,

codecs can generate fixes that are more accurate,

maintainable,

and less likely to introduce new defects elsewhere in the system.

Once the root cause has been identified,

Codeex generates a proposed solution.

A well-designed autofix workflow emphasizes minimal and focused changes.

The goal is not to rewrite large portions of the application,

but to make the smallest possible modification that resolves the failure.

This approach reduces risk

and makes the resulting changes easier for developers to review.

For example,

if a build fails because of an incorrect import path,

codec should update only the affected import statement rather than refactoring multiple unrelated files.

Developers can also provide explicit instructions to guide this process,

such as requesting that only necessary files be modified,

preserving existing coding conventions,

and updating tests only when required to reflect legitimate behavior changes.

Following fix generation,

validation becomes the next critical step.

The proposed solution is tested using the same pipeline checks that originally detected the problem.

Automated builds,

unit tests,

integration tests,

linting tools,

and security scans are executed again to confirm that the issue has been resolved successfully.

If the validation process still detects failures,

developers can provide additional context or refined instructions

and allow codeex to perform another iteration.

This feedback loop helps improve solution quality

while ensuring that every proposed change is verified before moving forward.

Even when automated validation succeeds,

human review remains an essential part of the workflow.

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.

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.

Once the fix has been approved,

the changes can be merged into the main branch

and included in future branch

and included in future deployments.

Over time, teams can analyze recurring issues

and improve their development processes accordingly.

Repository instructions,

testing strategies,

agents.mmd guidelines,

and CI/CD configurations

can be updated to help codeex handle similar situations

more effectively in the future.

As a result, autofix workflows not only resolve immediate problems,

but also contribute to continuous improvement

across the software development [clears throat] life cycle,

enabling teams to deliver higher quality software

faster while reducing the manual effort required to maintain complex systems.

Now the discussion we have is related to configuring automated bug resolution.

We can say this on a large scale in our codeex along with other things.

a discussion was going on.

This is most valuable for enterprise use cases for open AI codecs.

Instead of developers manually investigating every test field,

linting error,

securing warnings,

or production defects,

codeex can analyze the issue,

identify the affected files,

generate a proposed fix,

and create a pull request for human review.

This significantly reduces the time spent on repetitive maintenance tasks

while allowing focus for engineers to concentrate on high-level architectural business problems.

In modern software teams,

bugs are often discovered through CI/CD pipelines,

monitoring systems,

issue trackers,

and security scanners.

Codeex can integrate into these workflows

so that when an issue occurs,

the AI automatically receives the failure logs,

repository context,

coding standards,

and our project instructions.

All right.

The critical aspect we have for automated bug resolution is defining clear boundaries.

Enterprise organizations should never allow AI to directly deploy files into production.

Instead,

codec should generate code changes,

execute tests,

and create pull requests

that require developer approval.

This maintains governance

and accountability

while still benefiting from automation.

Human reviewers can remain fully responsible

for validating the basic

responsible for validating the basic logic.

Now,

let me tell you

a very important thing.

Our agents.mmd file

plays a crucial role

in the process.

What happens is they provide our project specifications

and instructions that guide codeex's decision-making

during bug resolution.

These instructions define the coding conventions,

testing requirements,

security constraints,

dependency policies,

and our architectural patterns.

The more structured the agents.mmd file is,

the more accurate and reliable the fixes become.

Organizations must look at another thing alongside agents.mmd confidence thresholds.

For example, codecs may automatically fix linting errors and formatting issues

while security vulnerabilities or database related bugs require a mandatory senior engineer review.

An example of this is that first of all we have to do this step by step.

The first part of our process is to identify our bug trigger resources and define where the bug reports originate.

Usually what happens is we see this in our CI/CD builds

or we can see this in our unit tests we perform

or we can see this in our integration test failures.

Sometimes issues can arise in GitHub

or our security scans can cause an issue.

All right.

After that, we have to identify the AI

and look at the AI's fix permissions.

If let's suppose there's a formatting issue,

a linting issue or a unit test failure,

we'll automatically look at all of them

and a detailed discussion will take place

regarding production incidents and everything.

Agents.md is our most important file

which I mentioned here.

What happens in agents.md

is we can see the automated bug resolution rules.

Whenever we fix a bug,

we should minimize the code changes.

We should never modify the database schemas.

We should preserve the API contracts,

add our tests for everyone,

and run all of the affected test suites.

We must explain the root cause

and also create a pull request summary.

You can see all of this in summary.

You can see all of this in agents.md

where we address the bugs

and multiple things are included.

Then if I let's suppose perform proper CI/CD integration

meaning after identifying the trigger sources

we've defined our AI

then if I say we want to configure CI/CD here

what I'll do first is take you to the

I'll do first is take you to the configuration

in the configuration workflow we first discuss the build failure

then we understand our codeex investigation

generate the fix

run the tests

create the pull request

test develop our reviews

and also then merge our workings.