Transcription
Greetings to all. Today we have a very interesting breakdown. We are diving, so to speak, into the world of coding with AI. We are focusing on the best practices that the OPIC developers are sharing. Well, in relation to their code tool, of course. >> Yes. Hello. Our sources today are the engineering blog plus conference talks. The guys have described everything in quite a bit of detail there. >> Exactly. And our mission today is, well, to try to extract the most valuable, perhaps sometimes non-obvious lessons from this, which will be useful, I think, when working with any AI assistant for coding, not just with Claude. >> Absolutely. >> And here's the main question that concerns me: as developers, how can we, let's say, truly get the most out of these new things without drowning in a flood of advice and guides? What approaches are really game-changers? >> Hmm, good question. >> Okay, let's get to it then. >> Yes, and right away, perhaps, it's worth making a very important disclaimer. I think the engineers at Tropic themselves, they insist that their recommendations are not some kind of set of ironclad rules, not dogma. It's more like, you know, a set of proven starting points, routes, if you will. >> Uh-huh. So, not an instruction to do it this way and no other way. >> Absolutely. The most important thing, as they emphasize, is adaptation. Adaptation to yourself, to your specific project, even to your personal work style. You know, there's simply no universal recipe here. >> Well, yes, that's logical. >> And it is precisely in this flexibility, in personalization, that the key to, well, truly effective interaction with AI lies, it doesn't matter if it's Claude or something else. I agree, flexibility is super important. And here, by the way, the first fundamental thing that is constantly talked about at HRroop is context. >> Oh, yes, context is everything. >> Any large language model works as well as it understands, uh, well, the task environment, right? >> Exactly. Without context, it simply, well, hallucinates or gives something completely wrong. And for their console tool, Cloud Code, they offer a solution. A special file, cloud.md. What is its main idea? Can you tell me more? >> Yes, of course. The idea is actually simple and, I would say, elegant. To provide the model with all the necessary and structured information about the project even before you start a dialogue with it. It's like, you know, giving a new team member a brief introductory course, a project brief. >> Uh-huh. And what do they recommend including there? Absolutely everything. >> Well, not everything, of course, but all significant things. That is, what commands are used for building, for running, for testing, what are the main features of the architecture or, say, the project structure, are there any specific conventions for code style, for naming, what are the key libraries, well, in short, everything that will help the AI get up to speed faster. Essentially, it's a cheat sheet for the AI. Interesting, especially since they emphasize the importance of instructions for running and testing. It would seem like a trifle, but it's not. Look, a simple Python script, right, it can be run in dozens of different ways. Just Python or Python 3 or with certain flags, or necessarily within a virtual environment. >> Uh-huh. >> And if this is not specified in Cloud MMD, what will the model do? It will choose randomly and almost certainly be wrong. And then you'll be sitting there figuring out why nothing works. >> Understood? So, explicit is better than implicit, as always in programming. >> Exactly. That's a basic principle. The less the model has to guess for you, the more predictable the result will be, and the less time you will spend correcting its errors. And here, by the way, it's worth noting that the idea of such a configuration file for an AI assistant is, of course, not unique. Competitors like Gemini or in the settings of GitHub Copilot also have their own ways of setting context. >> Yes, I've seen something similar. >> But the Cloud MD approach is interesting for its, shall we say, flexibility and focus specifically on console work. That's their unique selling point. But even if another tool is used, say, some IDE plugin like Cursor, creating a similar Markdown file describing the project can still be very useful, at least for yourself, to structure your thoughts. And for the AI, of course. >> And here, in my opinion, the most interesting part of their Cloud MD approach begins. I mean the concept of cascading configuration. >> Ah, yes, yes, that's a cool thing. >> That is, the file can be placed in the project root, committed for the entire team. That's understandable. And it can be added to Gitignore so that there are some personal settings that you don't want to share. Also logical. But the most curious thing is that Cloud Code looks for this file not only in the current directory where you are, but also goes up the directory tree, all the way to the user's home directory. Am I understanding this correctly? >> Absolutely correct. It goes up the chain. Current folder, the folder above, even higher. And so on, up to the user's home. So, it turns out you can have some global cloud MD at home with general preferences, well, I don't know, like comment style or favorite Git commands. >> Uh-huh. >> And then in each specific project, you can have your own cl MD, which overrides these global settings or supplements them with something specific to the project. That looks quite powerful. >> You are absolutely right. This is indeed a very elegant solution for managing configurations at different levels. It allows you to avoid duplicating the same thing in each project. General settings from the home folder are inherited and then supplemented or overridden by the specifics of a particular repository. Very convenient. >> But there's probably a catch here. You have to keep this file up to date. >> You guessed it. It's critically important to understand this. Cloud MD is by no means set it and forget it, it's a living document. The project evolves, right? Dependencies change, new team conventions appear, the architecture can evolve. And this file requires regular updates, otherwise it will quickly become outdated and start providing incorrect context. >> So, it should become part of the routine to check and update Cloud MD. Well, they highlighted it, right, it should become a habit. Moreover, the engineers say that they themselves periodically run the content of their Cloud MD through Cloud itself. >> Seriously? How so? >> Like this. They use prompts like "improve this text to make it as understandable as possible for the assistant" or "make this description more structured and complete for Cloud." It turns out to be a kind of meta-optimization of context using AI itself. >> Wow, that's a closed loop, isn't it? Interesting. >> Yes? >> Yes. And by the way, if there is no cloud.md file in the project at all, you don't have to create it manually from scratch. The tool has an init command. >> Ah, like Git init? >> Similar, yes. You run Cloud init or whatever it's called, and the tool itself tries to scan the project, looks at the folder structure, dependency files, maybe README, and suggests a basic structure for this cloud.md with some already found information, and then you just add the details. >> Convenient. So, to summarize on context: it's critical. Cloud.mD is the main way to set it. It's cascading and requires constant maintenance. Understood? Exactly. >> What about tools and integration? The console Cloud Code itself. I understand its main strength is its ability to work with other command-line utilities. >> Absolutely, that's its, you could say, bread and butter. Modern development largely happens in the console, right? >> Well, yes. Git, build, tests, deploy, >> working with clouds, Docker, Kubernetes, all there. And the AI assistant's ability to interact with all these tools is its key advantage over, say, pure chatbots or plugins that live only within the IDE. They particularly highlight integration with Git and specifically with GitHub CLI, GH for working with tasks, pull requests, CI/CD, and so on. >> Can it do other things, I don't know, query a database or something else? Potentially, yes, it can use any command that is available in the system in the user's PATH. If you have a utility for working with databases installed, it can call it. If you have AWSCLI or kubectl, it can interact with them. >> Wow. But then a rather unpleasant question about security immediately arises. >> Mm, yes, a very correct and very important question. If it can execute any command, it can theoretically do something dangerous. Well, I don't know, execute rm accidentally or intentionally. How does Anthropic approach this risk? >> They approach it very seriously because they understand that such power comes with great responsibility. Firstly, Cloud Code has control mechanisms. Through configuration files, the same Cloud.md or global settings, you can explicitly limit the set of allowed commands, create a whitelist. >> Uh-huh. So, forbid everything except what's needed. >> For example, yes. Or, conversely, create a blacklist of dangerous commands. Plus, there are launch flags that require explicit confirmation from the user before executing potentially destructive operations, for example, before deleting files or running sudo commands. So, the tool tries to be safe by default, but allows the user to set the balance they need between convenience and, so to speak, paranoia. There's always a compromise here. >> Understood. And besides the usual commands that just return text, some MCP and API protocol was mentioned. Can you explain what that is and why it's needed? It sounds a bit complicated. >> Yes, that's for more advanced scenarios where simply running a command and getting its text output is not enough. MCP is Meta Command Protocol. Essentially, it's a structured way of exchanging data between Cloud Code and external tools or scripts that you can write yourself. >> Structured, what does that mean? >> Yes, not just text. Instead, you can send and receive, for example, JSON objects, binary data, possibly even images. Or give more complex multi-step instructions to the tool. This allows for truly deep integrations. Here's an example they give. Using MCP, you can integrate code with Puppeteer. >> Puppeteer is for browser control, right? >> Exactly. And through MCP, you can give a command: "Open this web page, take a screenshot of this element, and send me the image." And Claude will receive not just text, but an image that it can analyze. >> Wow, that's serious, >> right? >> Yes? But Anthropic also rightly warns that such complex integrations through MPC or API require a very careful approach to security because they further expand the agent's capabilities and potential risks if something goes wrong. This is for experienced users who understand what they are doing. It sounds very powerful, but yes, and a little frightening. Is there anything simpler for customization for ordinary users, so they don't have to write their own MPC handlers? >> Yes. And this, in my opinion, is one of the coolest and most accessible discoveries: the so-called slash commands. Commands via slash commands, >> like in Slack or Discord. >> Very similar, yes. The idea is that you can define your own commands that will start with a slash. And they are defined very simply, using ordinary Markdown files. Inside such a file, you essentially write a prompt that describes exactly what your custom command should do, what steps to take, what other utilities to call, what result to return. >> Can you give an example to make it clearer? >> Of course. Anthropic developers often give the example of an "Analyze issue" command. The user types "Analyze issue 123" in the console. >> Uh-huh. And Cloud Code finds the Markdown file corresponding to this "Analyze issue" command. Inside this file, let's say, it says: "Using GitHub CLI GH, get the details of issue number $1. Analyze the description, the latest comments, related pull requests. Return a brief summary of the problem and suggest two to three possible steps to solve it." >> And does it do that? >> Yes. It substitutes the number 123 for the dollar sign, executes this prompt, calls the cloud to get information, then analyzes the received text and gives the developer a structured answer. Here's the essence of the problem, here are possible solutions. >> Cool. That's a great way to automate routine operations that you often do. >> Exactly, analyzing an issue, creating a branch from a template, running a specific set of tests, generating boilerplate code. All of this can be wrapped in such simple slash commands and the tool can be adapted to your specific workflow. It's very flexible and doesn't require complex programming. >> Understood. So, you've set up the context via cloud.md, figured out the integrations, maybe even written a couple of your own slash commands. What about the development process itself? Do Anthropic observe any, well, let's say, effective patterns of working with AI? How do people use it day to day? >> Yes, they do. And this pattern, it might seem familiar to many experienced developers because it's quite universal. They describe it like this: explore, plan, implement, commit. >> Well, that seems logical. What's the specificity when working with AI? >> There is specificity at each stage and its own nuances. >> What exactly? Tell me. Look at the exploration stage. When you're just trying to understand a task or find the cause of a bug or figure out a new technology for yourself, you start a dialogue with Claude. And here it's very important, as they emphasize, to explicitly instruct the model. "Don't write code yet." Or "Let's discuss options first." >> Why does it jump to writing code right away? Well, yes, any large language model, be it GPT, ChatGPT, Copilot, Cursor, any of them, is designed for generation. To the question "How do I implement X?", it will most likely immediately try to give you a ready-made piece of code. That's its nature, its purpose. >> Uh-huh. Like, "here, take the solution." >> Exactly. But the problem is that this premature code, generated without deep discussion, without planning, often turns out to be not what's needed, or it works incorrectly, or it leads to a dead end altogether, and you spend time understanding it, correcting it, and then possibly discarding it entirely. >> I see. So, first dialogue and mutual understanding, and then we'll think about the code. >> Absolutely. First, you need to make sure that you and the AI equally understand the task, the constraints, the context, and only then move on to the next step, >> which is called planning. >> Yes. And the planning phase becomes critically important when working with AI, much more so than when you code alone. Here, it is recommended to use special techniques or prompts to stimulate the model to think more deeply, not just to give the first option that comes to mind. >> What kind of techniques? >> Well, for example, just add the word "think" to the request or the phrase: "Think through the steps, break it down into subtasks," "Suggest several alternative approaches." This helps to get not just a superficial answer, but a more structured, detailed action plan. >> Sounds reasonable. >> And this plan, which you develop together with the AI, it is extremely important to document it. Not just leave it in the chat history, but actually copy and paste it somewhere. Either into a separate file, or directly into a ticket in Jira or GitHub issue, or into some design document. >> Why is it so important to document it specifically? It would seem, well, you agreed and that's that. >> Because it creates a common, immutable reference point for both you and the AI. If something goes wrong later during the implementation phase, or you forget some nuance, or the AI starts to drift off course, you can always return to this approved plan and say: "Okay, stop, we agreed on this. Let's go back to step number three." >> Ah, I see. It's like an informal contract, then? >> In a way, yes. Without a documented and decomposed plan, the dialogue with AI can very quickly become chaotic, and the result absolutely unpredictable. The plan is the foundation of manageable AI development. >> Okay, you've convinced me. There's a plan, it's documented. Let's move on to the implementation phase. What are the main recommendations from Anthropic here? The keywords here, as they say, are iteration, frequent commits, and surprisingly, test-driven development. TDD. >> TDD. Development through testing. That's unexpected. It would seem, why impose such strict frameworks of tests on such a, let's say, creative and somewhat chaotic system like LLM? >> But it turns out that these very frameworks help. This is one of the most interesting observations. In my opinion, TDD and LLM are a true "Made in Heaven," as they say. >> Why? What's the synergy? >> Look, what is TDD? First, you write a test that fails because the functionality doesn't exist yet. This test, it's essentially a very clear, formal, verifiable specification of what you want to achieve. >> Well, yes. >> And this clear specification is the ideal input for an LLM. The model doesn't need to guess what you meant. It has a specific test that should start passing. This prevents it from going off into its own fantasies and generating beautiful but non-working code, or code that works, but not quite as needed. The test is like rails that the AI should move along. >> Hmm, interesting. So, the test guides the AI. >> Exactly, it provides absolutely clear, unambiguous success criteria. "Make this test turn green." This is much more understandable for the model than the abstract "implement function X." But again, there's a nuance. The model needs to be explicitly instructed to use TDD. It won't happen on its own. You need to say directly: "Use TDD. First, write a failing unit test for this function." >> And if you don't say it? >> And if you don't say it, it will most likely either skip this step and immediately provide the implementation, or, even worse, generate both the implementation and the tests for it, which will immediately pass. Such green tests are useless. They don't really test anything. >> Understood? So, you need to constantly guide the model, control the process. You can't just say, "Make me a feature" and go have coffee. >> Alas, not yet, although many dream of it. Active process management, constant dialogue, clarification – this is the key to success with the current generation of AI assistants. And another recommendation for TDD from Anthropic: ask the model after each small code change to run not all project tests, which can be time-consuming, but only those that are relevant to the changed code. >> And how will it know which ones are relevant? Well, you can prompt it, or it can try to determine it itself based on dependencies. Modern test frameworks can often do this. The main thing is to give it such an instruction: "Run only relevant tests." This significantly speeds up the cycle. You write code, check with a test, refactor. >> I see. We've covered the process of exploration, planning, implementation, commit, and the role of TDD. Let's move on to best practices for interaction during the actual writing of code, refactoring, debugging. What else do the engineers at Froop advise? >> They advise to enrich the context you give the model as much as possible. And not just with text, meaning not just with code and descriptions. Modern models, especially those like CLU 3, are multimodal, they understand images well. >> So, you can show a screenshot directly? >> Yes, you can and should. See a bug in the interface? Take a screenshot, send it, and ask why this button has moved, how to fix it in CSS. Or you have a Figma or Zeplin design mockup, take a screenshot of the desired component and say: "Lay this out for me in React." >> Wow. >> And those very MCP integrations we talked about allow for automated transfer of such visual data. For example, a script using Puppeteer takes a screenshot of the current state of a web page and sends it to the model without you having to manually copy and paste images. >> Listen, this should save a colossal amount of time on explaining visual problems in words. You know, on the left, a bit lower, such a block, and so on. >> Exactly. How many times have we wasted time on such explanations, and here's a picture, here's the problem, how to solve it. This is especially useful for front-end development, for layout, for fixing visual bugs, for working with CSS. And they note an interesting point. Claude can help with layout or styles, even if the developer themselves, well, let's say, is not very strong in CSS. The model can analyze a screenshot of the mockup and suggest a specific CSS rule or even a ready-made component that implements it. >> Cool. I also heard them mention some YOLO mode. It sounds quite risky, honestly. >> YOLO, yes, it's an acronym for You Only Live Once. In the context of code, it means a mode of operation where the tool executes the commands it suggests without additional user confirmation. >> So, it decides what to run itself. >> Well, it suggests a command. If YOLO mode is enabled, it executes it immediately. Without asking, "Are you sure?" >> Hmm? And why is it needed? >> It really speeds up work, especially if you are confident in what you are doing, and the commands are quite routine. You don't have to constantly press Y or Enter. But, as you correctly noted, it also increases risks, and it can make a mistake, suggest the wrong command. And if it's destructive, >> Uh-huh. >> then it will hurt. >> Exactly. Therefore, the YOLO mode is recommended to be used with great caution, either for well-understood non-critical tasks where the cost of error is low, or, and this is an important piece of advice, by running the Claude Code itself within an isolated environment, for example, in a Docker container with limited access rights to the file system and network. >> Ah, so even if it executes something wrong, the damage will be limited to that container. >> Yes, it's like a sandbox for AI. Security should always come first, especially when you give AI the ability to execute commands on your system. >> Logical. What about things like explaining code or generating documentation? Can AI help with that too? >> This is one of the strongest aspects of modern LLMs. And Claude is no exception here. The dialogue with AI, during which you analyze a complex piece of code together or look for the cause of a bug or design a new feature, is itself a valuable artifact. And this dialogue can and should be reused. It can easily be turned into code comments that explain the logic, or into a description for a pull request that tells the reviewer what and why was done, or even into a full documentation section for users or other developers. So, don't let the results of the communication go to waste, >> exactly, preserve those valuable insights, those explanations that were obtained during the collaborative work with AI. This is a very effective way to generate documentation that is often more up-to-date than manually written documentation after the fact. >> Okay. And, of course, we can't forget Git. It is, well, let's admit it, a pain for many developers. Oh, yes, Git is a tool of incredible power, but often with a completely unfriendly interface and a bunch of commands with non-obvious options. Remembering all this can be very difficult. >> I agree. >> And here LLMs like Claude act as a translator, a translator from natural human language to the language of commands. >> So, you can just tell it what you want? >> Yes? You can say something like "undo my last commit, but keep all changes in the working directory" or "find the commit where I added the calculate_total function in the orders.py file" or: "Show me the differences between my current branch and the main branch, only for the src/core folder." >> and it will pick the right command with the correct flags. >> Most likely, yes. It will analyze the request in natural language and generate the corresponding command or sequence of commands. This removes a huge cognitive load from the developer, who doesn't need to look up documentation or remember syntax. It's especially useful, they say, for resolving merge conflicts. Models often handle conflicts quite well and offer meaningful resolution options, which for many is one of the most unpleasant tasks in Git. Yes, merge conflicts are a whole other story. So, to summarize the interaction, the key is in effective communication with the model, in how you set tasks for it. >> Absolutely. There are many parallels here with effective communication between people, with a human colleague. You need to be as specific as possible, you need to be concise, don't waffle, you need to avoid ambiguity. A bad prompt, as they give an example, "add tests." Well, what tests? Where, for what? A good, specific prompt: "Write a unit test for the calculate_total function, which is located in the orders.py file. Use the pytest library and, please, mock the external call to the Payment Gateway service." >> Do you feel the difference? >> A huge difference. The more specific the request, the higher the probability of getting exactly what you need on the first try. And one more important point. If the task is large and complex, it needs to be decomposed, don't try to solve everything with one giant prompt. It's better to break it down into logical steps, perhaps present it as a list or checklist, and ask the model to focus on one step at a time. "Let's do this first. Done? Okay. Now let's move on to the next item." This makes the process much more manageable and predictable. >> M. You know what's striking here? How much all these tips about context, planning, TDD, clear communication, decomposition, how much they resemble, in general, standard good practices for software development as a whole, even without AI? >> And that's a very accurate observation, yes, in many ways, AI assistants simply reinforce the need to follow these best practices. It's like they don't forgive sloppiness or lack of clarity in task definition. If you work with AI as structurally and thoughtfully as you should work with code and colleagues, the result will be good. If you try to work chaotically, the AI will only multiply that chaos. >> Interesting conclusion. Are there any other specific tips, for example, for working with Jupiter Notebooks? They are also popular, especially in Data Science, >> yes? There's a separate recommendation for Jupiter Notebooks. It's quite simple but important. They advise keeping the console where Cloud Code or another tool is running and the notebook itself open next to each other. For example, with the code in a split screen. >> And why? >> To see both. Exactly. Notebooks are very dynamic. Cells are executed, restarted, variable states change, output can change. And this constant visual control over what's happening in the notebook helps to better understand the current state and give the model more accurate and up-to-date instructions or code snippets. Without this, it's easy to get confused and give the AI incorrect context from some previously executed cell. >> Understood? So, keep everything in front of your eyes, logically. In the talks we watched, some more advanced techniques for using Cloud CD were also mentioned. Let's briefly touch on them too. What was particularly interesting there? >> Yes, there were several points for, let's say, advanced users. For example, they mentioned that some Anthropic engineers run up to four instances of Cloud Code simultaneously. >> Four. Why? >> Tasks. One, for example, writes tests, another the implementation, a third searches for information in documentation, a fourth refactors old code. This requires good context management skills, but it can probably significantly speed up work on complex things. >> Impressive. >> What else? >> They talked about special commands for managing the dialogue context itself. There's the CLR command. It completely clears the history of the current session to start, as it were, from a clean slate if the dialogue has reached a dead end. And there's the compact command. >> Compact. Compress. >> Yes, it doesn't delete the history, but asks the Claude model itself to make a brief summary, an abstract. And this summary is then used as the new, shortened context. This is useful to reduce the number of tokens passed to the model when the dialogue becomes very long, and to avoid exceeding context window limits. >> Hmm, clever. Self-summarization. >> Uh-huh. Another useful tip they mentioned is actively using the Escape key. A single press of ESC interrupts the model's current response generation. This is useful if you see it's clearly going in the wrong direction. You can stop it without waiting for it to finish. >> And a double press? >> And a double press of ESC ESC not only interrupts generation but also immediately clears the input line so you can immediately enter a new clarifying request. This speeds up iterations when you need to quickly correct the train of thought. >> Useful little things. What about custom tools, which we mentioned in connection with MCP and SLC commands? Have they been developed further? >> Yes, they emphasized that the ability to create custom tools is one of the key ways to adapt Cloud Code to yourself. Whether it's simple slash commands based on prompts or more complex integrations via MCP with scripts in Python, Go, or anything else. This allows you to teach Cloud to work with your specific API systems, databases, file formats. >> Understood. And was there anything else about Cloud MD besides cascading and the need for updates? >> Yes, they clarified the differences between personal cloud MD, which is located in the home directory and contains your personal preferences, for example, code style, favorite Git aliases, and project Cloud MD in the repository root, which describes the specifics of this particular project and is shared with the team. And they mentioned the ability to easily share these Cloud MD configurations via Git. That is, you can create a repository with a set of useful Cloud MD files for different types of projects or languages and use them as templates. A good idea for teamwork. Anything else advanced? >> There was an interesting idea about using different Claude models for different tasks within a single workflow. It's no secret that Tropic has several models: Haiku, Sonnet, Opus. They differ in speed, intelligence, and cost. >> Yes, of course. And the idea is to use, for example, the most powerful and intelligent Opus model for complex tasks during the planning, requirements analysis, and architecture design stages. And for more routine tasks like generating boilerplate code, writing simple tests, or formatting, use a faster and cheaper model, for example, Haiku. >> So, switch between models depending on the tasks. >> Well, or configure the tool so that it automatically selects the appropriate model for a specific type of request. This allows for optimization of both speed and cost. >> Sounds very rational. And there was something else non-obvious about Git, it seems. >> Yes, there was an interesting idea about using Git commit history not just as a way to track changes or roll back, but as a source of additional context for AI. >> How so? >> You can ask Cloud CD to analyze the change history of a specific file or code section. For example, "Look at the history of the userservice.py file over the last month and explain why the authentication logic was changed." The model can look at commits, their messages, possibly even related tickets if they are mentioned in the commits, and try to reconstruct the reason why the code is currently in this state: what decisions were made earlier, what problems were they trying to solve. Wow! This can be super useful for understanding legacy code or some complex, non-obvious parts of a project. >> Exactly. Instead of spending hours digging through git log and git blame yourself, you can ask the AI to do this analytical work and give you a summary. This is another way to use AI not only for generating new code but also for understanding existing code. >> Amazing. Well, I think we've covered all the main points from the Anthropic materials quite thoroughly. Let's try to summarize. If we put all this together, what are the key takeaways for any developer who wants to work effectively with AI coding assistants? It doesn't matter if it's Cloud or another tool. >> Yes, let's try to formulate the main points. I think they are as follows. First, it is undoubtedly the critical importance of context. AI without context is just a random text generator. Context needs to be provided actively, both statically through configuration files like cloud.md, and dynamically. During the dialogue, provide code, error logs, task descriptions, and even, as we found out, screenshots. >> Agreed. Context is number one. What's next? >> Second, it's structured workflows. Not chaos, but a thoughtful flow. Following stages like exploration, planning, and implementation-commit, using methodologies like TDD, which bring order and verifiability to working with AI. >> Uh-huh. Order and structure. Third. >> Third is the communication with the model itself. It must be clear, specific, unambiguous. You need to decompose complex tasks, you need to provide feedback, correct the model if it makes mistakes. In short, behave as you would with a smart, but sometimes absent-minded intern who requires clear instructions. >> Good analogy. Fourth point. >> Fourth is the active use of integration with other tools. Don't perceive AI as a separate entity, but integrate it into your usual toolkit, into the CLI console, into the Git version control system. Possibly through APIs or protocols like MCP for deeper connections. And it should help you work with what you already work with. Logical. And fifth. >> And fifth, perhaps, is an iterative approach to development itself. Don't try to generate the entire feature at once. Work in small steps, check frequently, with tests or manually, frequently commit small, logically complete changes. This allows you to control the process and correct errors in time, which AI will inevitably make. >> Context, structure, communication, integration, iteration – it sounds like a whole philosophy of AI development. >> In a way, yes. But it's important to emphasize again what we started with. All of this is not rigid dogma, but guiding principles. The Anthropic engineers themselves say: "Experiment, find what works for you, for your team, for your project." The goal is not to blindly follow someone's instructions, but to build your own convenient, effective, and perhaps even enjoyable workflow using an AI assistant, whether it's Claude, Copilot, Cursor, or some future tool that hasn't appeared yet. Adaptability and willingness to try new things are what's truly important in our time. >> And to conclude our discussion today, I would like to propose a small topic for reflection. We see how AI tools for coding are becoming more powerful, smarter, and more deeply integrated into our daily work. And the question is: how might this change the very essence of the developer profession in the near future? Will our focus shift from writing every single line of code, which AI might soon do better than us, to higher-level tasks such as strategic project planning, deep requirements analysis, setting correct tasks for AI, reviewing and verifying generated code, managing complex systems where AI will be just one component. What new skills, perhaps related to systems thinking, critical evaluation, the ability to prompt and guide AI correctly, will come to the forefront? Will they become more important than the ability to write code in a specific language? >> It was interesting to discuss.