00:00:00There are many AI code editors, each with its own set of tools and features that make it stand out.
00:00:04Claude Code is arguably the best, especially with the Opus model, but it's also expensive.
00:00:09On the other hand, Cursor is another favorite among developers who like to see the code side by side with the agent's actions, but it has its own problems.
00:00:16Google also released Anti-Gravity with Gemini 3, which became rapidly popular among developers because of the model and its free usage.
00:00:23It is newer than both Claude Code and Cursor, but it has implemented a lot of things better than Cursor.
00:00:28Now ever since AI coding started getting powerful, a lot of people have been coming out with their own workflows with these tools.
00:00:35But the key to any good workflow is how efficient it is at managing your context.
00:00:39Previously, Anthropic released an agent harness designed for long-running tasks, and this time, Cursor has released its own harness designed to significantly improve the use of Cursor by maximally utilizing its capabilities.
00:00:50The principles mentioned in the article are largely applicable to all agents, so I'm taking these principles to Google's Anti-Gravity.
00:00:57It might not be the best yet, but it has features that set it apart from the others.
00:01:01We've got a lot to talk about today because, with the addition of this harness, Anti-Gravity's performance has improved significantly.
00:01:28Lastly, there is how you, as a user, interact with it, how you prompt it, and how you follow up with the responses.
00:01:38The harness is important because different models respond to the same prompt in different ways, as each model has its own strengths and performs best in the environment it was trained for.
00:01:48For example, a model trained in a shell-based environment might naturally prefer using GREP over a dedicated search tool.
00:01:54This matters because we know that some models, like Claude, excel with XML prompts, while others perform better with Markdown.
00:02:00Therefore, it's crucial that the harness we use is tailored to the specific model we're working with.
00:02:04Planning before implementation is essential to ensure that the code meets your expectations.
00:02:10Experienced developers are more likely to plan before generating code because it forces clear thinking about what is being built and gives the agent concrete goals to target.
00:02:18Anti-Gravity's planning feature is the one I like the most because revising the plan is easy with commenting.
00:02:24When I started in planning mode, it thoroughly analyzed my instructions and the existing code base, then generated a detailed plan.
00:02:30Although reading through the plan was tedious, it is essential to review it carefully to ensure the implementation aligns with the vision, so make sure to thoroughly read through it.
00:02:38For changes, I just had to comment on any line that did not match my goal, and it incorporated the change into the revised plan.
00:02:46It is essential to keep refining until the plan is perfect.
00:02:49Once done, the agent can implement everything autonomously.
00:02:52Even if the implementation does not match what you wanted, it is better to go back to planning mode and edit the plan rather than using follow-up prompts.
00:03:00After that, the agent needs to work with the correct context.
00:03:03But before that, here's a word from our sponsor.
00:03:05Luma AI and their new tool Dream Machine, Ray3 Modify.
00:03:08If you've worked with AI video, you know the frustration, you generate something cool, but the moment you try to change the style or scene, the character breaks, motion feels off, and you're stuck regenerating.
00:03:18Ray3 Modify solves that.
00:03:20For the first time, AI video actually feels directed, not guessed.
00:03:23You can take an existing clip, even a real performance, and transform the world, lighting, or cinematic style while keeping the character identity, motion, and emotional beats intact.
00:03:33The performance stays locked, the look evolves exactly how you want.
00:03:36With character reference and modifiable keyframes, you control what stays consistent and what changes across shots.
00:03:42Perfect for hybrid workflows, short films, music videos, and cinematic concept work.
00:03:47Even smaller productions.
00:03:48Honestly, this feels like real AI post-production.
00:03:51Stop guessing. Start directing.
00:03:53Check out Ray3 Modify in the pinned comment or scan the QR code and see what's possible.
00:03:58Once you have perfected your planning, your job is to provide each agent with the context needed to complete the task.
00:04:04Another thing that people get wrong is they tend to manually tag every file.
00:04:08You don't need to manually do it, as agents have powerful search tools that can pull context on demand.
00:04:13Manually tagging files loads everything into context, even though not all lines are needed.
00:04:18Agents can use grep to load the specific segments they require.
00:04:21For example, if I want to make a change on the signup page, tagging the file would load the entire component of more than 200 lines into the context, bloating it unnecessarily.
00:04:30Even though the lines actually required are just one function of about 50 lines, the rest of the lines which are completely unnecessary would still be included.
00:04:38Instead of tagging the file manually, rely on the agent's search tool to grep for the function it needs.
00:04:43You don't have to do everything in a single conversation.
00:04:45Start a new conversation for any new task, or whenever the agent's performance becomes confused or it keeps making the same mistakes.
00:04:52Essentially, start a new conversation once you have completed one logical unit of work.
00:04:57For instance, I start a new conversation for every new feature I want to implement and begin with planning for that feature as I want.
00:05:04This way, all tasks are isolated and exactly as I need.
00:05:07The only time you do not need to start a new conversation is when you are working on the same feature, need the same context from the discussion, or are debugging a feature the agent has implemented.
00:05:16Outside of these cases, it is better to reduce the noise by starting a new conversation.
00:05:21The effectiveness of the agent's responses is actually a guide for when you should start a new conversation.
00:05:26If you want to refer back to any details from your previous chats, you can do so by referencing them directly in the chat and mentioning that conversation, instead of guiding the agent through it again.
00:05:35This allows the agent to identify the conversational context intelligently, letting it selectively read from the chat history and pick only the context it needs.
00:05:43The agent's capabilities can be extended by using a set of rules and skills.
00:05:47You can customize its behavior by defining rules for your project, which are specific guidelines or best practices you want the agent to follow consistently.
00:05:55Anti-Gravity makes it simple to add these customizations across either the local or global scope.
00:06:00To add a guideline, simply include the rule in the project scope.
00:06:03These rules are stored in the .agent folder, which contains a rules folder with markdown files for the instructions.
00:06:09For example, I added a rule in this project to make the front-end VCAG compliant.
00:06:13Once the rule is added and a task is assigned to Anti-Gravity, the agent generates a plan that incorporates the rule, including label tags with inputs and other details, to make the entire page VCAG compliant.
00:06:24You can add as many rules as your workspace needs to guide and extend the agent's capabilities.
00:06:29Similarly, agent skills were added in Anti-Gravity by following the same open standard set by Anthropic, which contains instructions, scripts, and domain-specific knowledge.
00:06:38Skills are loaded dynamically when the agent decides they are relevant, which keeps the context managed.
00:06:43All of the skills reside in the .agent folder for Anti-Gravity.
00:06:47Each skill contains a specialized skill .md file that includes the name, a description of what goes into the context, and all the details on how to use the skill.
00:06:55Access to other references and scripts is stored in their respective folders.
00:06:59Using skills in Anti-Gravity is as simple as specifying which skill you want and what task you want it to perform.
00:07:05I asked Anti-Gravity to use the test specialist skill to write test cases for my project, and it took some time to create a complete testing plan using the skills guidelines.
00:07:14I also used all the libraries I had mentioned in the references, along with the scripts and all the guidelines defined in the skill, to perform the task.
00:07:21Models are getting better at analyzing images, so we should rely on their capabilities more and include them in our prompts to enhance their understanding.
00:07:29Instead of explaining with words the design you want to include, you can just take a screenshot of the section you want to implement.
00:07:35Go to Anti-Gravity, paste in the screenshot, and ask it to implement that section exactly like the screenshot.
00:07:41By using its image analysis capabilities, it can fully understand the image and implement it.
00:07:45Another thing I use images for the most is error debugging, because it is easier to explain UI issues with a screenshot rather than just describing the error in words.
00:07:54So whenever I have any UI issues, I take a screenshot, give it to Anti-Gravity, and it fixes it for me.
00:08:00Instead of blind diving into code, we need to follow software development best practices in AI development too.
00:08:06There are some common workflows that work well with agents. The first one is test-driven development, where the agent writes the tests first and then writes the code to satisfy those tests.
00:08:15The reason why test-driven development with AI agents works is because they have a clear target toward which they should optimize, they know what the criteria of success are, and they are able to incrementally improve in that direction.
00:08:26So when working on the backend setup, I had not written any code and just gave the prompt asking the agent to write tests for the auth root and describe the input and the output and the test behaviors and I explicitly mentioned that it should not write the code for the tests at this stage.
00:08:40Once the agent had written the test cases and I was satisfied with them, I asked the agent to run the tests.
00:08:45These tests failed at first because they do not have any implementation yet.
00:08:49After the tests were completed, I committed them to Git to maintain a log in case the agent tried to modify the tests.
00:08:55Then, I asked the agent to write the code for the endpoint, explicitly instructing it not to modify the tests.
00:09:01We then kept iterating until all of the tests passed, asking it to verify repeatedly until every test succeeded.
00:09:07This way, the agents have a clear goal to iterate toward.
00:09:10When you start working on a new codebase with an agent, you need to ask the same type of questions you would ask a teammate.
00:09:16This allows the agent to dig through the codebase using grep and semantic search, find the answers, and understand how the codebase works while trying to answer you.
00:09:24I ask questions about the details of the codebase and the routes so the agent can grasp the project's structure and functionality.
00:09:30That way, whenever I give it a new feature to implement, it already knows the project's structure, making it easier to implement the feature.
00:09:37Git is important because it not only acts as version control but also serves as a knowledge base for the coding agent.
00:09:43We have already emphasized the importance of using Git in previous videos.
00:09:47Clear Git commits not only provide a knowledge base for your agent, but they also help manage features, track the last stable version, and revert changes if the agent modifies something you did not want it to.
00:09:58To make my work with Git easier, I use a set of reusable commands that we call workflows in anti-gravity.
00:10:04For committing, I prefer a structured commit format, so I make sure the commit workflow enforces that commit messages, follow this structure, and even include examples for the agent.
00:10:13Before committing, certain security and code review checks are performed to ensure my Git commits are clean and aligned with my standards.
00:10:20You can also create sets of commands for managing pull requests, worktrees, branches, and more, making the entire Git workflow more consistent and efficient.
00:10:28Invoking these workflows is as simple as writing the workflow name, which then executes all the steps automatically.
00:10:34You can use other commands, such as fix issues or review, to perform code reviews and run workflows for updating dependencies, based on the specific needs of the code base.
00:10:43This might sound basic, but AI-generated code definitely needs review and is not always perfect.
00:10:48One important practice is to watch the agent while it is working.
00:10:51If you see it heading in the wrong direction, interrupt it immediately and redirect it toward your goal.
00:10:56Once the agent has finished, you need to perform a review using the agent itself.
00:11:00In my projects, I often use a custom workflow for code reviews that incorporates all the best practices with Git.
00:11:06It highlights issues based on severity, lists all the checks that should be performed on the code to ensure it is correct, and can also include linters and tests to run after the review.
00:11:15This ensures the code is high quality and reliable.
00:11:18Since almost all projects are managed using source control such as GitHub, we use BugBots for advanced AI analysis to catch issues and suggest improvements on every pull request.
00:11:28There are many AI-powered tools that can help review your code, such as CodeRabbit, Sentry, and others.
00:11:33Even GitHub has built-in code review features for every pull request, which help manage team workflows.
00:11:38To identify architecture issues, we can ask the agent to create a mermaid diagram.
00:11:43Using these diagrams, we can visually analyze and spot key problems.
00:11:47These diagrams are especially useful because visuals are easier to understand and serve as clear documentation for the project's architecture.
00:11:54Running agents in parallel is very important because it not only improves the performance of the AI models, but also saves a lot of time compared to waiting for a single agent to complete a task.
00:12:05This approach can significantly improve outputs.
00:12:07I often use multiple agents working simultaneously, assigning each one a different task, and I also use multiple models since each model excels at different tasks.
00:12:16The agents work independently and notify you only if they need input, allowing them to operate simultaneously.
00:12:22Since anti-gravities agents share the same workspace and are not isolated, I let them work in separate branches.
00:12:28Once they complete their tasks and pass the checks I have defined for the project, I merge their features into the main branch.
00:12:34Often we encounter bugs that we cannot figure out how to fix.
00:12:38In such cases, debug mode is the best solution.
00:12:40Instead of just guessing fixes, debug mode tries to understand what could be going wrong and generates logging statements for your code, helping reduce bugs and making the debugging process more systematic.
00:12:50Even though there is no native debug mode in anti-gravity, we can implement one using a debug mode skill.
00:12:56This skill contains all the instructions for debugging unexpected behavior in the code.
00:13:00It follows an evidence-based approach, generates hypotheses, and provides a detailed multiple-phase plan for approaching the problem and resolving it.
00:13:08It is guided by specific scripts and references to improve its effectiveness, making the debug mode much more reliable.
00:13:14Whenever I encounter any sort of bug, I just use debug mode and let the agent figure out what went wrong by following the guides in the skill.md, making my error debugging process smooth.
00:13:25That brings us to the end of this video.
00:13:27If you'd like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below.
00:13:33As always, thank you for watching and I'll see you in the next one.