Claude Code for Beginners: Step-by-Step Guide & Transcript

[00:00] Let me start with a simple question. How many times have you used AI to write a piece of code? Only to realize that you still have to figure out where that code belongs.

[00:15] How to run it, what other files need to change and what to do when something breaks. That's exactly where Cloud Code changes the way we work. Most of us are already comfortable using AI through a chat window. We ask a question, we get an answer and then take that answer back to our project.

[00:30] Now, Cloud Code takes this step further. It's an agentic coding tool that can understand your project, read your files, make changes across multiple files, run commands, execute tests and help you move from an idea to a working application.

[00:45] And this isn't just a theoretical shift. Entropic analyzed around 4 lakh Cloud Code sessions involving about 2,35,000 people between October 2025 and April 2026. This is research reporting cloud code users were spending an average of 20 hours per week.

[01:00] So, we are moving from AI that write code to AI that can actually work with your database. But if you are completely new to cloud code, don't worry. You don't need to be an expert developer to begin understanding it.

[01:12] In this course, we are going to start from the absolute basics. We'll create a project, understand how cloud code sees and interacts with that project, learn the interface and important commands, write your first proper prompt,

[01:24] explore plan mode and then let cloud code build the first version of a real application by the end of this course you won't just know what cloud code is you will understand how to start working with it confidently now before we move on let me share something exciting with you

[01:39] guys if you're interested in understanding how generative ai agentic ai and technologies like multi-agent system are transforming the way we work there is an opportunity to take your learning to the next level with the advanced executive program in applied generative ai in collaboration

[01:53] that's a big one. This program is designed to help you build a strong foundation in generating AI concepts, explore agentic AI workflow, understand large-tangent models, work with frameworks like MCP and multi-agent systems.

[02:05] You will also get exposure to popular AI tools, build real-world applications, and learn how AI systems can be designed to solve practical business problems. Whether you're a developer looking to build AI applications, a professional planning to transition into AI,

[02:18] or someone who wants to understand how AI can improve everyday workflow, this program helps you gain practical skill and confidence to work with modern AI technology. Learn more about advanced executive program in Applied Generative AI in collaboration

[02:31] with SintiLearn here. So without any further ado, let's get started. Let me start with a simple question. How many times have you used AI to write a piece of code only to realize that you still

[02:46] have to figure out where that code belongs? How to run it, what other files need to change and what do we do when something breaks. That is exactly where Cloud Code changes the way we work. Most of us are already comfortable using AI through a chat window.

[03:02] We ask a question, get an answer and then take that answer back to our project to handle the actual implementation. Cloud Code takes this a step further. It is an agentic coding tool that can understand your project, read your files, make changes across multiple files,

[03:17] run command, execute tests, and help you move from an idea to a working application. And this isn't just a theoretical shift. Anthropic analyzed around 4 lakh cloud code sessions involving about 2,35,000 people between October 25 to April 2026.

[03:36] With its research reporting that cloud code users were spending an average of 20 hours per week using the tool. So we are moving from AI that writes code to AI that can actually work with our databases.

[03:49] But if you're completely new to Cloud Code, don't worry. You don't need to be an expert developer to begin understanding. In this module, we are going to start from the absolute basics. We will create a project, understand how Cloud Code sees and interacts with that project.

[04:05] Learn the interface and important commands. write our first proper prompt, explore plan mode, and then let Claude code build the first version of a real application. So by the end of this module, you won't just know what Claude code is.

[04:20] You will understand how to start working with it confidently. So without wasting any time, let's get started. By the end of this module, you will understand the basic Claude code workflow and how to use it as an AI coding partner rather than simply a tool.

[04:33] You will know how Cloud can work with project files, create and edit code, run commands, identify problems, and support you throughout the development process. Most importantly, you will understand how to communicate with Cloud, use plan mode when

[04:47] needed, and confidently start experimenting with Cloud code on your projects. Most of us are already familiar with using AI through a normal chat window.

[04:59] You type a question, the AI gives you an answer and if you ask it to write some code, it gives you that code inside that conversation. But then the next part is usually still your responsibility. You need to figure out where that code should go, which file needs to be changed, how to run the application and what to do if something breaks.

[05:16] And this is exactly where Cloud Code changes the workflow. Instead of only talking about your project, Cloud Code can actually work with the project itself. It can then look through your project files, understand how they are connected,

[05:28] create new files, edit existing files, run commands, find problems, and healthy moves of idea to a working project. And it's completely new to coding a cloud code that's completely fine because we are going to start from the very beginning.

[05:40] In this particular lesson, we will understand what cloud code is, how it differs from cloud chat, how the project workspace works, what cloud models and permission mode means, how plan mode works, how to write a good prompt, how to review cloud's plan,

[05:55] plan and finally how an approved plan moves towards a working application. By the end, you should understand the basic cloud code workflow well enough to start experimenting on your own. Now, before we go further, let us first understand what cloud code actually is.

[06:09] Cloud code is an AI coding tool from InfoPix, but I don't want you to think it as just another tool for writing code. The key idea is that cloud code can work directly with your actual project. Instead of simply answering question or generating code in a chat, it can understand the files and

[06:24] structure of the project you're working on. For example, imagine you have a project folder with several files. One file might control the homepage, another file might handle the design and styling, another might contain the application logic, another might store configuration or project

[06:39] settings. With a normal AI chart, you would typically need to copy code from these files, paste it into the conversation, explain what you're working on, and then manually take the AI's response and add it back to your project.

[06:52] Cloud Code provides a different workflow because it can inspect the project and work with the relevant file directory. So if you want to understand why a particular button isn't working, add a new feature, fix an issue or understand how different parts of the

[07:05] project are connected, Cloud Code can examine the project context and help you work through it. This makes the interaction much more closer to working with a coding assistant inside your actual development environment

[07:17] rather than simply having a conversation about the code. So, in a very simple term, normal code mainly helps you talk about the work, understand concept, and generate idea or code. While cloud code helps you work on the actual project, move those ideas towards the working application. Now, let us make the difference

[07:33] even clearer. If I open Omni Cloud Chat and ask you to create a learning tracker application, cloud can definitely help by suggesting the layout, generating HTML, JS, and explaining how the application should work. However, the output still needs to be taken from the

[07:47] conversations and turn into a real project by us. This is where Cloud Code works differently. Now, instead of simply giving us the code or instruction, Cloud Code can work much closer to the actual project. If our application requires five different files, Cloud Code can create those

[08:02] files and organize the project accordingly. If we need to make changes later, it can inspect the files, understand the current structure, and modify the relevant part instead of starting from the It can also help run the command required to build, test or work with the project.

[08:18] At the same time, this doesn't mean we should be blindly let the AI make every decision. Throughout this course, we will focus on understanding what cloud is doing and keeping ourselves in control of the development process through demonstration.

[08:31] The biggest shift is to remember instead of only asking cloud questions and receiving answers, we are giving cloud a workspace where it can understand and work within the actual project. Now let us talk about the project workspace. A project workspace is essentially the environment where your project lives and where your cloud code can work with the different files that make up your application.

[08:54] Now you can think of a project folder that contains everything your application needs, such as source code, configuration files, assets, dependencies, and other resources. We will also understand this with the demonstration once we are done with the training.

[09:07] When Cloud Code works inside this workspace, it can inspect this file and understand how different parts of the project are connected. This is important because modern applications are rarely built using just one file.

[09:19] You might have one file responsible for the user interface, another that contains the application's logic, and other that manage configuration dependencies or supporting the code. Now instead of manually copying information from each of these files into a strat and explaining how they relate to one another,

[09:36] Cloud Code can work with the project directly and use that existing context while helping you build or modify the application. This means that when you ask Cloud to add a feature, fix an issue or make a change, it can consider the existing project structure rather than treating your request as an isolated piece of code.

[09:53] The key idea here is simple Cloud Code doesn generate standalone code snippets it works within the context of your project and helps you build on what already exists The next thing we need to understand is the model

[10:05] Depending on your Clod setup, you may see different Clod model available, including model families such as Haiku, Sonnet and Opus. While the exact model version you may change over time. You need to memorize every model name or version.

[10:19] What matters is understanding the basic idea behind choosing the right model. for a particular task. Now different model can offer different balances of speed, capability and usage so that the best choice often depends on how complex your task is. For example, if I have a very

[10:34] small task such as reading a short file and explaining what it contains, I may not need the most powerful model available and a faster model may be enough. But if I'm working on a feature that requires plot to understand multiple files, consider several requirements. Make changes and

[10:48] test the result. I may want a more capable model and when I'm dealing with a difficult debugging, application architecture or a large multi-step problem, a model with stronger reasoning capabilities can become more useful. Now as a beginner though, I wouldn't recommend spending

[11:03] too much time switching between models for every small task. Start with the models you are recommending for general coding work. Focus first on understanding the workflow and as you gain experience, you will naturally become better at recognizing when a task requires more capability.

[11:20] At the end of the day, you can think of the model as the engine that powers the work Cloud Code is helping you perform. The next setting we need to understand is permissions. And this is especially important because Cloud Code can do more than simply just returning

[11:34] text. It can interact with your project by editing files and running commands. So, you need to decide how much control you want to get. Depending on your cloud code interface, you may see models such as manual, accept, edit, plan, auto or similar options.

[11:47] The name may vary slightly as the product evolves, but the basic concepts remain the same. A more manual mode means cloud will ask for your approval more often before taking an action. This can seem a little slower, but when you are learning, it can actually be very helpful

[12:02] because you get to see what cloud wants to do before it happens. An edit-friendly mode allows Flord to make changes to your project with fewer interruptions, which can be more convenient once you're comfortable with the workflow.

[12:15] The important thing here is to remember the permission determines how much freedom Flord has to interact with your project. Since FlordCode can potentially modify files and execute commands, you should understand what you're allowing before approving an action.

[12:29] Don't develop the habit of simply approving every request. Whenever cloud asks to perform an action, take a moment to consider what it is trying to do and whether that action makes sense for your project. You don't need to understand every character or a terminal command to work safely, but you should have a basic understanding of why cloud wants to perform that action.

[12:49] When you're starting out, understanding what's happening and staying aware of the changes cloud is making is more valuable than simply trying to remove every confirmation dialog. Now let us talk about one of the most useful concept in cloud code which is plan mode.

[13:02] Plan mode is basically us setting cloud, don't start changing my project yet. First understand what I want to think about the best way to do it and show me your plan. This is extremely useful for beginners because one of the easiest mistakes with AI coding tool is

[13:17] giving one last prompt and immediately allowing the AI to build everything. The AI may technically produce a working result but that doesn't necessarily mean if the result you actually wanted. Plan mode gives us a checkbox.

[13:30] First, Lord understand request. Then it creates a plan. We review the plan, make the direction as needed and only then we allow plot to start building. So basic workflow becomes prompt, plan, review, approve, build.

[13:44] This approach gives you more control over the development process because instead of following plot, we immediately make changes because understand what it intends to do. And if something doesn't look right, you can correct the direction before implementation begins.

[13:59] Now let's talk about prompts. And when I say proper prompts, I don't mean some huge technical specification for lost coding vocabulary. You can still use very simple English. The important thing is to give Claude enough information to understand

[14:12] what you are trying to achieve. A good build prompt usually contains a few simple things. First, tell Claude the goal. What are we building? Second, tell it about the user. Who is the application for? Third, describe the features.

[14:24] what should the application actually do and fourth give it a basic design structure and finally mention any constraints should the product remain simple or other features and dependencies cloud should avoid so we think of a good prompt using five simple components goal user feature design

[14:43] and constraint if you provide these five pieces clearly cloud usually has a much better starting point than you simply type build me an app the goal isn't to write the longest possible prompt The goal here is to provide enough context for Claude to understand the outcome you want.

[14:58] Now, once Claude creates a plan, don't immediately approve it. Take a moment to review it. If you are a complete beginner, don't panic if you see a few technical words here. You do not need to understand every single term before moving forward.

[15:10] At this stage, I want you to check four simple things. First, does Claude understand the application we are trying to build? Second, are the features correct? Third, has Claude added something we never asked for?

[15:22] And fourth, does the plan seem much more complicated than our small projects need to be? Now, these four checks alone can prevent a lot of unnecessary problems. For example, imagine that Claude proposed user authentication cloud database, payment processing, email notification, admin accounts, and 15 different pages.

[15:41] All of those things may be useful in some projects, but they could be completely unnecessary for a simple version. Our goal here is not to create a most impressive feature list possible. Our goal here is to create the simplest working version of the idea.

[15:56] So when Claude gives you a plan, don't be afraid to remove things or change the direction. You are still directing the project. This is one of the most important ideas to understand when working with AI coding tools.

[16:08] The AI can suggest an approach but you decide whether that approach actually makes sense for your project or not. Once you have reviewed the plan and you are happy with the direction, you are ready to move from planning into implementation. This is where Cloud Code begins turning the approved plan into an actual project.

[16:23] Cloud Link creates project files, write application code, install the basic dependencies that are required and run commands to prepare the project. The important thing here is that implementation is now based on a plan that you have already reviewed.

[16:36] You started with an idea, explained what you wanted, Cloud created a plan and you reviewed the plan and made corrections as necessary. Only after approving the plan did you allow plot to begin building. But even after plot finishes the implementation, don't immediately assume that everything works.

[16:52] One of the most important habits in AI-assisted development is to verify the result yourself. A completed message from cloud doesn't automatically mean that the application behaves exactly as expected.

[17:04] You should test the importing workflow and confirm the results contradict what you originally requested. requested. This gives us a much better development cycle. Define, plan, review, approve, build, test and improve. And this is also where Cloud

[17:17] Code become really useful after the first build. Suppose the application technically works but you don't like one part of the interface. You don't necessarily need to restart the entire project. You can continue the conversation

[17:29] and describe the specific improvement you want. Try to describe the scope of changes. If you simply tell Cloud make everything better, Cloud has to guess what better means and merely redesign parts of the application that you already like.

[17:43] But if you explain exactly what should change and what should remain unchanged, you would have given Claude a much clearer boundary. Small precise iterations are usually easier to control

[17:55] than repeatedly asking for huge redesigns. So, let us quickly recap what we have covered in this particular module. We started by understanding what Claude code is

[18:07] and why it is different from a normal fraud conversation. Normal fraud is excellent for answering questions, explaining ideas, and generating pieces of code. While fraud code can work directly inside a project involvement and interact with the files required for that particular project.

[18:22] Then we looked at the concept of the project workspace and why working within the correct project matters. We also looked at fraud models and learned that you don't need to memorize every model version. In the next particular lesson,

[18:35] we are going to take all the fundamentals further and look at how to make cloud code workflow much smarter. We will explore persistent project instructions, reusable commands, skills, hooks, and how to manage the project as it becomes larger.

[18:48] So now let us move to the demonstration part and let us learn whatever we have covered in the theory. Now for this demo part, I want you to open Chrome and go to official cloud website

[19:01] and download cloud desktop for Windows. So, since we are starting from scratch, the first thing we need is cloud desktop. Cloud code is available directly inside the desktop application so that we don't need

[19:13] to start with a separate terminal installation. So you can go here, write cloud for desktop. You can see here and from here you can go and download the cloud.

[19:29] See here download for Windows and there is another format. So here you can see you can download for Mac, Windows, Linux, whatever operating system is there it's compatible with you will download.

[19:42] Then the second step is you need to download and install git for Windows. Just go here and download git for Windows download Here you can see go to here and then here you can click here to download

[20:02] so before we start working with a local project on windows we need to get installed we don't need to learn that right now we simply need it to install so that cloud code can work without our local project the step three is we have to install opencloud desktop now open the opencloud installer

[20:18] and complete the installation since i have already downloaded it you need to just download the cloud and just get the permissions so the once the installation is complete open cloud desktop and this is where we'll access cloud code and work on our project so you have to sign in using your

[20:36] account i have already signed in using my account you can log out from here and you can sign in so once you're signed in make sure that your account has access to cloud code and maybe you will be needing the premium version to access it. Now at the top you can see here is

[20:53] normal chat here is non-Cloud code and this is where the workflow changes. Chat is where we normally talk to cloud by giving the prompts and everything here but cloud code is that page where we have to

[21:07] write our codes and make edits. So for this what we will do is I've already made it you can see it from here that this is the dashboard this I have made

[21:20] without using gethengetha so this is all was there which has made and this is the website which it has made on the localhost so we'll make this how let us see

[21:32] So, firstly we will go to our desktop. We will create one folder. Learning track. Okay. So, first step is creating a folder to our desktop which is learning track. You can see that this folder is now empty.

[21:54] So I'm starting with a completely empty folder. There is no code or project file here. You can see everything we see later will be created through our cloud code workflow. Okay, so I'm going again here. So now we'll connect cloud code to our project folder by selecting local and choosing this folder.

[22:12] We are allowing cloud code to work with the files inside this project. So you can see here no folder is selected. I will just go here and open it I made the folder on nextop learning track I will just

[22:25] select this folder trust workspace so we don't need to understand every option on the screen for now just remember these four things where cloud is working where we give it instruction where the model which model we are using and how much freedom cloud has to change so you

[22:40] can see this is opus 5.5 we have selected the model ok you can select the model from here also whatever you feel like you can select so different models are useful for different type

[22:52] of tasks but as a beginner you don't need to keep switching between them we will use the recommended coding model and focus on learning the workflow so here you can see the permission mode

[23:05] here it is auto for our first project we are going to use plan mode this means claude will first understand what we want to create a plan before it starts changing our project so this is a plan mode we can use accept edit also so if we accept the edit it will change the file

[23:24] in the folder so for now i will be using accept edit plan we have already understood that what is the plan first uh it is it will create a plan and then it will make the changes so everything

[23:37] is done you can see this is the interface i have selected the model i have selected the permission i have selected my fault i'll paste this prompt plan a simple personal learning dashboard for me do not build anything the dashboard is for beginners who want to track what they're

[23:52] currently learning i want the user to be able to add learning topics see all the learning topics mark a topic as completed see the total number of topic and how many topics are completed so I want the interface to be cleaned avoid unnecessary features and

[24:06] dependency and choose a simple technical approach for this project okay I'll put enter and it has started its session so wait for a while it has it is creating so it is using three web languages HTML CSS and JavaScript okay so it has given

[24:25] that what the file is going to look like how the features is going to act how the the data will be saved design style then the file name okay this is another prompt

[24:39] I'm giving it to it regarding the interface and everything okay now let us say go so make sure that you have a premium account for the cloud for the

[24:52] same otherwise you cannot use it because it takes token to generate anything okay So you can see that learning dashboard total topics zero, zero completed. So suppose I want to add your JavaScript as completed. So I will just add it.

[25:18] I'll just add it from here so you can see that this is the final dashboard it is opening

[25:30] for example I'll say JavaScript and add so you can see total topics added one and the topic name is this can complete here for example I have also learned Python so I'll add the

[25:46] topic and I'll just cross it so you can see how this is working now coming back to our folder I've shown you previously it was all empty but now you can see that it has got

[25:58] this CSS file JS file and all the files which are required so you can see in the vs code all the CSS file and everything is visible here so this is how you can make a website without even

[26:14] writing one single line of code. You can use these files and create it and you can follow the steps whichever I've shown you to create the files.

[26:27] So in the previous modules we learned how cloud code can help us start a project, understand an existing code base, create a development plan and build a complete application step by step. We also explored how we can manage our workflow more efficient by using project

[26:40] instructions, reusable skills, hooks, slash command and effective context management. Now we are reaching the final stage of working with an AI coding assistant. At this point, the goal is not simply to generate more code or keep adding new features. A professional

[26:55] development workflow is not only about building something quickly, it is also about raising the quality of work, what we have created, identifying possible improvement and finding problems, testing the application properly and making sure that the final product is reliable.

[27:09] And this is where Cloud Code becomes much more valuable. Instead of treating AI as just a tool that writes codes, we can use it as a development partner that helps us analyze, review, debug, and improve our applications.

[27:21] The first important concept we will understand is sub-agents. Now, when we normally interact with Cloud Code, we are usually working with one main AI session. We provide instructions, Cloud analyzes the project, makes the necessary changes, and gives us the results.

[27:36] This works well for many tasks, but as projects become larger and more complex, some situations require different types of expertise. A developer reviewing a project may need to look at multiple areas such as code structure, security, performance, user experience, and application behavior.

[27:53] Instead of asking one AI assistant to handle every type of analysis together, we can divide the work into smaller, specialized tasks. This is where sub-agents become useful. Now, a sub-agent is a specialized AI agent that focuses on a particular responsibility.

[28:08] It works with a specific goal, analyzes the required area, and then provides its findings back to the main conversation. Now, you can think of it as a like software development team. In a traditional team, we may have different people responsible for different areas.

[28:23] One developer focuses on back-end logic, another focuses on front-end experience, and another reviews testing or security. Sub-agent brings a similar approach to AI-assisted development. For example, when reviewing an application, we can have one sub-agent which focuses on

[28:38] code quality, potential bugs, duplicate logics, maintainability, or performance concerns. Now another sub-agent can focus on user interface experience, accessibility, mobile responsiveness,

[28:52] navigation flow, and overall usability. The advantage is that each agent approaches the project with a specific purpose instead of trying to analyze everything at once. However, it is important to understand that using more agents does not automatically mean better results.

[29:09] The effectiveness of sub-agents depends on how well we define the task. If we create multiple agents that are doing the same type of analysis, we may simply get repeated information. Revenual benefit comes when each agent has a clear responsibility.

[29:22] responsibility. So, for example, asking one agent to review security, another agent to review user experience makes sense because these are different perspectives. But asking five agents to review the

[29:34] same small piece of code may not provide much additional value. Now, the key skill is knowing when to delegate and how to divide the work effectively. Now, coming with parallel work with AI agents, once we understand sub-agent, the next important concept is parallel work.

[29:49] In software development a significant amount of time is spent analyzing problems reviewing code researching solution and testing different part of an application When multiple tasks are independent and do not rely on each other completing them one after another may not always be the most efficient approach

[30:06] This is where parallel work becomes useful as it allows different tasks to be handled at the same time, improving efficiency and reducing overall development time. For example, imagine you are improving a learning dashboard application where one task involves checking whether the interface works properly on mobile devices,

[30:26] while another task focuses on reviewing the backend logic to identify unnecessary complexity. Since these two tasks are separate and do not depend on each other, they can be analyzed independently.

[30:38] However, it is important to understand that not every task should be paralyzed. If one task depends on the outcome of another task, then the task needs to follow a specific order. For example, if you need to understand a database issue before making changes to the API logic, both tasks cannot be performed independently.

[30:57] A good developer understands the relationship between different tasks and decides where parallel work can provide real benefit. This is one of the major advantages of AI-assisted development. Because AI is not only useful for generating code, it can also help developers organize their workflow,

[31:14] divide complex problems, and approach software development in a more efficient manner. Now let us move to another important concept in the AI development ecosystem, which is MCP, which stands for Model Context Protocol.

[31:28] The simplest way to understand MCP is to think of it as a bridge that allows AI models like Cloud to connect and interact with external tools, services, and additional sources of information.

[31:40] Normally, cloud code works with the information available inside your project environment. It can understand your file, analyze your code, identify patterns, and help you modify different parts of your application.

[31:53] However, modern software development rarely depends on a single environment. Developers work with multiple tools and platforms such as sometimes documentation, databases, cloud platform, project management tool, development platform and internal company system.

[32:09] MCP here provides a standardized way for AI system to communicate with these external resources and access additional capabilities beyond the immediate project file. For example, imagine you are building an application using a framework that receives frequent updates. Instead of manually

[32:26] searching through documentation every time, you need information and MCP connection can allow Cloud to access relevant documentation sources and use that information while helping you develop the application.

[32:39] Now, similarly, MCP connections with another service can allow Cloud to interact with specific capabilities provided by those platforms, making the overall development workflow more efficient. Now, however, the process of MCP is not just to connect every tool just because we can.

[32:55] The goal is to connect only the tools and resources that provide real value to your specific workflow. A professional developer does not select tools randomly, they carefully select technology that solves the problem and improve the productivity.

[33:10] The same principle applies when building AI power development workflow. MCP becomes powerful when it creates meaningful connection between AI models and the tool developer already used, allowing AI to become more capable and integrated part of software development process.

[33:25] Now let us discuss one of the most important skills in software development, which is debugging. Every developer, regardless of their experience level, spends a significant amount of time identifying and fixing problems in an application.

[33:39] A bug can occur due to many different reasons such as incorrect logic, unexpected user behavior, integration problems, incorrect data handling or issues between different parts of the system.

[33:51] Now many beginners think debugging simply means finding the incorrect line of code and immediately changing it. However, professional debugging is not just about making quick fixes. It is about structured process of investigation where developer first understand the problem and apply the right solution.

[34:08] A strong debugging approach can be divided into five steps. Reproduce, investigate, understand, fix and test again. The first step is reproducing the problem. Before making any changes, it is important to clearly understand what is happening by identifying which action creates the issue,

[34:27] when the problem occurs and what is expected behavior. Providing clear information about the problem also helps AI tool understand the situation better and provide more accurate assistance.

[34:39] The next step is investigation, where instead of immediately asking AI to fix the issue, the developer should first analyze the problem cause behind the problem. A good data game workflow focuses on questions such as which part of the application is responsible for this behavior,

[34:53] why is the application behaving this way, what changes could solve the issue, Could the change impact other parts of the application? This approach helps unnecessary modification and reduces the chances of introducing new problems while fixing the existing one.

[35:08] Once the root cause is identified, the required fix can be applied. However, debugging does not end after making a change. The final and most important is testing again to ensure that original problem has been resolved and the rest of the application continues to function correctly.

[35:24] A successful fix is not just about removing an error, it is about improving the overall stability and reliability of the system. This is why debugging is not just a process of fixing mistakes but also a way of understanding how an application works better.

[35:40] Now after development and debugging, the next important stage is final review. When an AI system feels that an application is complete, we should not immediately assume that everything is perfect. AI can generate impressive solutions and helps us build applications faster.

[35:55] But software quality still requires human judgment, testing, validation. Final testing helps us ensure that the main features are working correctly, user workflows are smooth, recent changes have not introduced new issues,

[36:08] the application behaves as expected, and the interface works properly across different environments. At this stage, the focus of development changes during the development phase. Our primary goal is building new functionality.

[36:21] Now, however, during the final review phase, the focus shifts towards stability, reliability, and ensuring the application provides a consistent experience for users. This means avoiding unnecessary feature addition and concentrating on improving the quality of existing application.

[36:38] Now, a good final review involves looking at the application from the perspective of a real user and asking important questions such as, can user complete important tasks easily? Are there any confusion interactions?

[36:50] Does the application handle unexpected situation properly? Does the interface work correctly across different screen sizes and environment? And are there any visible error that could affect the user experience?

[37:03] While AI can support this review process by analyzing code, suggesting improvement, and identifying possible issues, human testing remains essential. Developer understand the process and intention behind the product.

[37:16] wide user experience, the final application from a practical perspective. Both viewpoints are important to create a successful software project. Throughout this course, we have followed a complete AI-assisted development journey using cloud code.

[37:31] We started by understanding a project, analyzing requirements, and creating a clear development plan. Then we moved into building the application step-by-step, improving our workflow using project instructions, reusable components, automation, and better way of managing context.

[37:47] After that, we explored how to review application, debug problems, connect external capabilities through tools like MCP, and perform proper testing before considering an application complete.

[37:59] So, the entire workflow can be summarized as plan, build, improve, automate, review, debug, test. This represents a modern approach to software development where AI works alongside developer throughout the entire development lifecycle.

[38:14] The future developer will not be simply someone who writes the code manually anymore. Instead, the future developer will be someone who knows how to communicate those clearly, guide AI system effectively, review generated solution and make strong technical decisions.

[38:29] The most important skill is not learning one specific command, feature or tool because AI technology will continue to evolve rapidly. The real skill is to understand how to collaborate effectively with AI.

[38:42] This means giving AI clear instructions, understanding the problem before asking for solution, reviewing the approach before accepting changes, maintaining organized project rules, using specialized agents when required and carefully testing everything that AI creates.

[38:58] It is important to remember that AI-generated code still requires human understanding and judgment. The best way to improve your skills with code and AI-assisted development is through continuous practice. Start with small projects such as building your personal dashboard, a task management application, a portfolio website, or any idea that interests you.

[39:19] Follow the same process every time. first understand the goals, create a plan, build a solution step by step and review the output and continuously improve the application. With consistent practice, Cloud Code will become more than just a coding

[39:33] assistant. It will become a powerful development partner that helps you think more clearly, solve problems and create better software. So that is all for this particular course. I'll see you in the next one.

[39:51] you