Why Google Antigravity Suddenly Makes Sense

There are many AI code editors, each with its own set of tools and features that make it stand out. Claude Code is arguably the best, especially with the Opus model, but it's also expensive. On the other hand, cursor is another favorite among developers who like to see the code side by side with the agents actions, but it has its own problems. Google also released anti-gravity with Gemini 3, which became rapidly popular among developers because of the model and its free usage. It is newer than both clawed code and cursor, but it has implemented a lot of things better than cursor. Now, ever since AI coding started getting powerful, a lot of people have been coming out with their own workflows with these tools. But the key to any good workflow is how efficient it is at managing your context. Previously, Anthropic released an agent harness designed for longunning tasks. And this time, Cursor has released its own harness designed to significantly improve the use of cursor by maximally utilizing its capabilities. The principles mentioned in the article are largely applicable to all agents. So, I'm taking these principles to Google's anti-gravity. It might not be the best yet, but it has features that set it apart from the others. We've got a lot to talk about today because with the addition of this harness, anti-gravity's performance has improved significantly. Before we go into the methods, let us understand what a harness is actually built upon. There are three main components. The first is the instructions, which include the system prompts and rules that guide agentic behavior. These are specialized instructions that are built into the tool itself. The second component is the tools attached to the agent, which help it perform better. These include file editing, codebased search, and terminal execution, giving the agent the ability to carry out tasks effectively. Lastly, there is how you as a user interact with it, how you prompt it, and how you follow up with the responses. The 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. For example, a model trained in a shell-based environment might naturally prefer using GP over a dedicated search tool. This matters because we know that some models like Claude excel with XML prompts while others perform better with markdown. Therefore, it's crucial that the harness we use is tailored to the specific model we're working with. Planning before implementation is essential to ensure that the code meets your expectations. Experienced 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. Anti-gravity's planning feature is the one I like the most because revising the plan is easy with commenting. When I started in planning mode, it thoroughly analyzed my instructions and the existing codebase, then generated a detailed plan. Although 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. For changes, I just had to comment on any line that did not match my goal and it incorporated the change into the revised plan. It is essential to keep refining until the plan is perfect. Once done, the agent can implement everything autonomously. Even 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. After that, the agent needs to work with the correct context. But before that, here's a word from our sponsor. Luma AI and their new tool, Dream Machine, Ray 3 Modify. If 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. Ray 3 modify solves that. For the first time, AI video actually feels directed, not guested. You 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. The performance stays locked. The look evolves exactly how you want. With character reference and modifiable key frames, you control what stays consistent and what changes across shots. Perfect for hybrid workflows, short films, music videos, and cinematic concept work. Even smaller productions. Honestly, this feels like real AI post-prouction. Stop guessing, start directing. Check out Ray 3 modify in the pinned comment or scan the QR code and see what's possible. Once you have perfected your planning, your job is to provide each agent with the context needed to complete the task. Another thing that people get wrong is they tend to manually tag every file. You don't need to manually do it as agents have powerful search tools that can pull context on demand. Manually tagging files loads everything into context even though not all lines are needed. Agents can use GP to load the specific segments they require. For 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. Even 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. Instead of tagging the file manually, rely on the agent search tool to GP for the function it needs. You don't have to do everything in a single conversation. Start a new conversation for any new task or whenever the agents performance becomes confused or it keeps making the same mistakes. Essentially, start a new conversation once you have completed one logical unit of work. For instance, I start a new conversation for every new feature I want to implement and begin with planning for that feature as I want. This way, all tasks are isolated and exactly as I need. The 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. Outside of these cases, it is better to reduce the noise by starting a new conversation. The effectiveness of the agents responses is actually a guide for when you should start a new conversation. If 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. This allows the agent to identify the conversational context intelligently, letting it selectively read from the chat history and pick only the context it needs. The agents capabilities can be extended by using a set of rules and skills. You can customize its behavior by defining rules for your project, which are specific guidelines or best practices you want the agent to follow consistently. Anti-gravity makes it simple to add these customizations across either the local or global scope. To add a guideline, simply include the rule in the project scope. These rules are stored in the aagent folder which contains a rules folder with markdown files for the instructions. For example, I added a rule in this project to make the front end vag compliant. Once 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 vag compliant. You can add as many rules as your workspace needs to guide and extend the agents capabilities. Similarly, agent skills were added in anti-gravity by following the same open standard set by anthropic, which contains instructions, scripts, and domain specific knowledge. Skills are loaded dynamically when the agent decides they are relevant, which keeps the context managed. All of the skills reside in the aagent folder for anti-gravity. Each 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. Access to other references and scripts is stored in their respective folders. Using skills in anti-gravity is as simple as specifying which skill you want and what task you want it to perform. I 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. It 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. Models are getting better at analyzing images, so we should rely on their capabilities more and include them in our prompts to enhance their understanding. Instead of explaining with words the design you want to include, you can just take a screenshot of the section you want to implement. Go to anti-gravity, paste in the screenshot, and ask it to implement that section exactly like the screenshot. By using its image analysis capabilities, it can fully understand the image and implement it. Another 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. So whenever I have any UI issues, I take a screenshot, give it to anti-gravity and it fixes it for me. Instead of blind diving into code, we need to follow software development best practices in AI development too. There are some common workflows that work well with agents. The first one is testdriven development where the agent writes the tests first and then writes the code to satisfy those tests. The 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. So 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 offroot and described 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. Once the agent had written the test cases and I was satisfied with them, I asked the agent to run the tests. These tests failed at first because they do not have any implementation yet. After the tests were completed, I committed them to git to maintain a log in case the agent tried to modify the tests. Then I asked the agent to write the code for the endpoint, explicitly instructing it not to modify the tests. We then kept iterating until all of the tests passed, asking it to verify repeatedly until every test succeeded. This way, the agents have a clear goal to iterate toward. When you start working on a new codebase with an agent, you need to ask the same type of questions you would ask a teammate. This allows the agent to dig through the codebase using GP and semantic search, find the answers, and understand how the codebase works while trying to answer you. I ask questions about the details of the codebase and the roots. So, the agent can grasp the project's structure and functionality. That way whenever I give it a new feature to implement, it already knows the project's structure, making it easier to implement the feature. Git is important because it not only acts as version control, but also serves as a knowledge base for the coding agent. We have already emphasized the importance of using git in previous videos. Clear 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. To make my work with Git easier, I use a set of reusable commands that we call workflows in anti-gravity. For 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. Before committing, certain security and code review checks are performed to ensure my Git commits are clean and aligned with my standards. You can also create sets of commands for managing pull requests, work trees, branches, and more, making the entire Git workflow more consistent and efficient. Invoking these workflows is as simple as writing the workflow name, which then executes all the steps automatically. You 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 codebase. This might sound basic, but AI generated code definitely needs review and is not always perfect. One important practice is to watch the agent while it is working. If you see it heading in the wrong direction, interrupt it immediately and redirect it toward your goal. Once the agent has finished, you need to perform a review using the agent itself. In my projects, I often use a custom workflow for code reviews that incorporates all the best practices with git. It 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 llinters and tests to run after the review. This ensures the code is high quality and reliable. Since almost all projects are managed using source control such as GitHub, we use bug bots for advanced AI analysis to catch issues and suggest improvements on every pull request. There are many AI powered tools that can help review your code such as code rabbit sentry and others. Even GitHub has built-in code review features for every pull request which help manage team workflows. To identify architecture issues, we can ask the agent to create a mermaid diagram. Using these diagrams, we can visually analyze and spot key problems. These diagrams are especially useful because visuals are easier to understand and serve as clear documentation for the project's architecture. Running 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. This approach can significantly improve outputs. I 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. The agents work independently and notify you only if they need input, allowing them to operate simultaneously. Since Anti-gravity's agents share the same workspace and are not isolated, I let them work in separate branches. Once they complete their tasks and pass the checks I have defined for the project, I merge their features into the main branch. Often we encounter bugs that we cannot figure out how to fix. In such cases, debug mode is the best solution. Instead 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. Even though there is no native debug mode in anti-gravity, we can implement one using a debug mode skill. This skill contains all the instructions for debugging unexpected behavior in the code. It follows an evidence-based approach, generates hypothesis, and provides a detailed multiplephase plan for approaching the problem and resolving it. It is guided by specific scripts and references to improve its effectiveness, making the debug mode much more reliable. Whenever 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. That brings us to the end of this video. If 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. As always, thank you for watching and I'll see you in the next one.