Ask an AI coding assistant to write a function, and the familiar workflow is still fairly simple: you describe the task, inspect the generated code, run it in your editor, and fix whatever breaks. The developer remains responsible for almost every execution step that follows.
That model is beginning to change. Google’s agentic era development tools point to a different model of software work. In simple terms, the AI can take on a larger part of the task instead of waiting for the developer to request every individual step.
Instead of simply giving an engineer a piece of code to copy and paste, these systems can work across relevant parts of a project, plan several changes, use development tools, and check whether the result works. If you work on a large codebase, the operational difference becomes easier to see right away.
Google is still adding to these tools, and not every capability is available in every product or environment. Some features may also depend on the account or access level. You can see the difference more clearly when an AI agent is given a real software task.
Get a Quote
FAQ
Contact Us
From Code Suggestions to Larger Tasks
Software development is moving beyond interactive code completion toward larger, agent-led tasks. The important difference is how much of the work the AI can handle before a person needs to step in.
Traditional completion tools operate strictly inside the active file. They predict what code is likely to come next based on what the developer has already written. The developer still has to decide which files to change, run the application, check errors, and make the necessary fixes manually.
Example: Adding Login Security to an Existing API
Give an AI agent the task of adding OAuth2 PKCE login security to an existing application interface, and the work involves much more than generating a single block of code. The system needs to understand the overall context, make coordinated edits, and check its work.
The agent will first analyze the application and determine relevant files and libraries, along with the current authentication structure. Next, it will determine which of the routes, dependencies, authentication configuration, and other files need modification. Once those modifications have been made, the agent executes commands and tests them. Should any fail, the agent will interpret the error and make another modification until it passes. The developer can now review all changes and approve the commit.
How the Google Antigravity 2.0 Platform Operates
The Google Antigravity 2.0 platform is designed around AI agents that can take on multi-step development tasks. Developers can work with these agents through a desktop environment or a command-line terminal, depending on how they prefer to work.
Breaking a Large Development Job Into Smaller Tasks
A large software task does not always have to be handled by one AI agent. Antigravity can split a large development job into smaller tasks assigned to specialized subagents.
For example, an engineer updating an application can assign one agent to update database structures, another to modify how the application handles requests, and a third to write automated tests. All three tasks can move forward at the same time.
Working With Antigravity From the Command Line
Antigravity CLI brings Antigravity’s AI development capabilities directly to the command line. In simple terms, developers who prefer working through a terminal can give tasks to the AI without opening the main desktop interface.
Google describes the tool as Go-based and designed to support asynchronous work. In practice, a developer could use the terminal to handle tasks such as dependency updates, routine checks, or other work that does not require a graphical editor.
Read Our Blog: Complete Guide to Generative Engine Optimization (GEO) for Businesses
From One-Off Tasks to Background Work
Antigravity 2.0 also points toward a less hands-on style of development. Agent-based workflows can take on recurring or multi-step tasks, reducing the need for a developer to initiate every individual action.
How Developers Can Check the AI’s Work
Antigravity provides information that helps developers review what an agent has done. Depending on the task, this can include the plan it followed, changes made to the code, and results from browser or terminal activity.
Engineers review these actual build results and test reports rather than manually reading through every single line of generated code.
What Gemini 3.5 Flash Adds for Developers
An AI agent needs to do more than suggest a line of code. It may have to understand a large amount of project information, use external tools, work through several steps, and respond to test results.
The Gemini 3.5 Flash capabilities most relevant to software teams include:
- Large context: Gemini 3.5 Flash supports a 1-million-token input context. In practical terms, this gives the model room to work with a large amount of code, documentation, or other project information at once.
- Tool use: Gemini can connect with external tools and run code, allowing an AI application to perform actions instead of simply generating an answer.
- Multimodal AI for application development: It accepts text, images, video, audio, and PDFs. This opens up development workflows that involve design files, UI screenshots, and technical architectural diagrams alongside raw source code.
- Computer use: Gemini 3.5 Flash can interact with supported computer environments, including browsers, which gives developers more ways to build agents that can carry out tasks.
- Agentic tasks: Google positions Gemini 3.5 Flash specifically for coding, multi-step workflows, and longer-running agentic tasks.
Google introduced Gemini 3.5 Flash with coding, agentic workflows, and longer-running tasks in mind. Those capabilities make it a useful model for software agents that need to work through several steps rather than produce one answer and stop.
How Google AI Studio and Antigravity Work Together
A common question among engineering teams is how to position different tools within their development pipeline. Recent Google AI Studio developer updates have expanded the platform’s role in application development, rather than treating it purely as a prompt-testing environment.
Google AI Studio and Antigravity are not completely separate steps in a development pipeline. Google AI Studio can be used to build and test an initial application, and the complete project can then be exported to Antigravity when the work moves into a more agent-focused development environment.
Once the project becomes more complex and requires changes across many files, testing, and ongoing engineering work, Antigravity provides a suitable environment for continuing the project.
Read Our Blog: Beyond the Search Bar: Optimizing Your Brand for the AI-First Journey
Example: Using AI Agents on a Real Project
Consider a company moving an internal service from one API approach to another. The change may involve the database, the application’s interface, and the tests that make sure existing features continue to work.
For example, the team might use GraphQL for the new interface instead of traditional REST endpoints.
The process starts with scoping. The software engineer writes down clear rules for how the data should be structured, what limits to place on queries, and who should have access.
At this point, the team can prototype the first version in Google AI Studio to generate and test initial GraphQL patterns and verify that responses return in the expected format.
Once that first version is working, the team can move the project into Antigravity 2.0. The engineer instructs the platform to update database queries and data structures across the project. In this setup, the AI can split the work between subagents: one adjusts the database layer, another writes resolvers, and a third prepares the tests using terminal commands.
Testing is where the workflow becomes particularly useful. Suppose one of the automated tests fails because a database query is too slow. The agent inspects the error message, adds a missing index to the database, and runs the test again.
The developer can then review the changes, performance logs, and test results before approving the update. For teams automating coding tasks with Gemini, this can leave engineers with more time for validation and architectural decisions instead of manual file updates.
Using AI Agents With APIs and Web Services
Web and API integration is another area where agentic tools could reduce repetitive development work. APIs are the connections that allow one software service to exchange information with another. A major part of modern software work involves connecting third-party services, payment processors, or external data feeds.
An AI agent can read the technical documentation for an external service, work out how the two systems need to exchange information, and help create the code that connects them. This can include technical documentation such as an OpenAPI specification.
Instead of an engineer manually writing connection code or setting up authentication, the agent reads the vendor guide, generates the connection module, writes sample responses, and tests the link against a safe testing environment.
Where Businesses Can Use These Tools
For larger IT teams, this fits into a wider set of enterprise IT automation trends, particularly in software maintenance, testing, and legacy-system work:
- Updating older applications: Converting legacy codebases to modern architectures while keeping automated tests running to catch errors.
- Keeping software dependencies current: Setting background agents to check, update, and test security patches across projects without interrupting everyday development.
- Creating tests: Having agents parse feature requirements, write testing matrices, and run test suites automatically.
- Understanding unfamiliar code: Letting agents review unknown parts of a codebase, explain dependencies, and draft documentation for new developers.
For an IT services company such as TreeMultisoft Services, scaling IT services with generative AI could mean less time spent on repetitive development work and more time for experienced engineers to focus on architecture, security, integration, testing, and client requirements. Google’s next-gen developer tools are increasingly moving beyond code generation to tasks such as testing, tool use, and multi-step development work.
Why Developers Still Need to Stay in Control
AI can handle more of the work, but important software decisions still need human review:
- Architecture: People still need to decide how major parts of a system should work together and set fundamental boundaries.
- Security: Developers must review access controls, password handling, sensitive data isolation, and user authentication.
- Production releases: An AI agent may prepare and test changes, but a human engineer should approve important releases to live environments.
- Business and legal requirements: Software must follow the company’s actual business rules and any relevant regulatory standards.
How Software Development Roles May Change
Agent-led development does change some everyday habits for technical teams.
Clear instructions matter more. If an agent receives a vague request, it has more room to make the wrong assumption. You still need to decide what the software should do and what limits the agent must follow.
Testing becomes even more important. An agent needs clear feedback to know whether its changes actually work. Automated tests give the AI something concrete to verify instead of relying on a human to spot every error.
Developers will also spend more time reviewing changes, test results, and overall system behavior. The job does not disappear. The focus shifts toward evaluation and technical decision-making.
What This Means for Software Teams
The bigger change is the amount of work an AI system can handle around the code itself. It can understand a project, make several related changes, run tests, and report the outcome.
Developers still define requirements, make architectural decisions, check security, review results, and approve production changes. The work shifts, but the responsibility does not disappear.
For companies building or maintaining software at scale, the practical benefit may be simple: AI handles more routine engineering work while experienced teams retain control over the decisions that matter most.
Get a Quote
FAQ
Contact Us
FAQs
How is Antigravity 2.0 different from earlier Antigravity releases?
Google has expanded Antigravity's capabilities to allow orchestrating specialized subagents. It also added Antigravity CLI, which uses the same underlying system. The overall direction is toward coordinating complex, multi-step development tasks rather than limiting AI assistance to simple inline suggestions.
How does Gemini 3.5 Flash execute code safely?
Google's managed agents run code and tools inside isolated, Google-hosted Linux environments. This sandbox gives the agent a controlled place to execute commands and verify code rather than giving it unrestricted access to the developer's local machine.
How should developers handle the transition from Gemini CLI to Antigravity CLI?
Google is transitioning Gemini CLI users in certain individual and free-use scenarios to Antigravity CLI. Developers affected by the transition should follow Google's official migration guidance rather than assuming that existing commands map one-to-one.