15 June, 2026
Cut Outsourcing Costs by 50% by Writing Specs in Antigravity IDE

Many business owners spend hundreds of millions of VND on outsourced software development, but what they get back often isn't what they wanted. The root cause is a vague requirements spec. Today we'll show you how to write the spec yourself in Antigravity IDE, an AI tool that turns ideas into clear technical requirements. This not only lets you control the project, it can also cut up to 50% of the cost and time of working with outside developers.
Write one clear spec, and the engineering team builds a test version in 15 minutes
Antigravity is Google's new-generation IDE, built on VS Code. It puts the AI agent at the center. The agent reads code, writes it, and runs tests on its own. Humans sit and supervise, approving each step. It is a tool for technical people, not a push-button app for outsiders.
Business owners shouldn't expect to sit down and type out software themselves. That is still the developer's job. What you can do, and do very well, is write the spec. A spec is a description of what you want, as clear as you can make it.
We'll be straight about the pain. Most outsourced projects go over budget because the spec is fuzzy. You say one sentence and the partner understands it another way. You only find out it's wrong when it's done. Fixing it costs more money. Every revision round makes the invoice bigger. Some projects double their budget just because the initial description was loose.
Antigravity shortens that loop. You describe your requirements in everyday Vietnamese. The agent reads, analyzes, and proposes a structure. Your engineering team supervises the result and corrects anything that's off. A test version for a small job can be done in 15 minutes.
An important note. That 15-minute version is a prototype to see whether the idea is on the right track. It is not a product that runs live for customers. Use it to lock down requirements, not to start selling right away.
Getting started is simple. Open Antigravity and type your requirement in natural language. For example, an internal tool for recording orders. The agent asks follow-up questions when it sees missing information. You answer, and the agent proposes the screen flow and data tables.
After you approve, the agent writes the code and builds the interface on its own. The whole process appears on screen for the supervisor to follow. This is the difference. The agent doesn't work in secret. Every step is open for you and your engineering team to control.
We advise you to hand this job to a technical person at your company. They take your spec, sit down with Antigravity, and produce a quick test version. You don't need to code, only to describe exactly what you want. That is already half the success of a software project.

Describe the business in three layers so the agent understands your specific process
Every business has its own set of rules. How discounts are calculated, how orders are approved, how permissions are split across departments. Antigravity's agent is very capable, but it only gets things right when you describe enough. Describe too little and the result drifts. One small deviation in the business logic breaks the whole flow.
This is where many of you feel the most pain when outsourcing. The partner does exactly what you said. But you forgot to mention a few unwritten rules that live in your head. You only find out at acceptance. Both sides blame each other. Money lost, time gone, the relationship strained.
We share a way to describe things in three layers to limit that. It's a simple way of thinking, not a secret formula. You can use it even when writing a spec for an outside partner.
Layer one is context. You state which department uses it, who enters the data, and what the tool is for. For example, the sales team uses it to track orders during the day. The clearer it is who uses it, the better the agent builds an interface that fits real users.
Layer two is constraints. These are the rules that must not be broken. For example, orders over 50 million VND need manager approval. Or a customer can't share a phone number with another customer. List them all. Every constraint you miss is a hole the agent can't guess.
Layer three is concrete examples. You give a sample input and the output you expect. For example, when this order is entered, what should the screen show. One good example says as much as a long page of description.
With all three layers, the agent grasps most of your logic. There will still be spots to adjust, so the supervisor still has to read through the result. Don't trust the first output completely. However good the agent is, it still needs a final reviewer.
We advise you to write these three layers into one document and save it for repeated use. That document is the spec. When the project outgrows what you can do yourself, send that same spec to the MONA team. We understand it right away, quote accurately, and don't need many rounds to work out what you mean.

Supervise and edit the results: the human's role in the loop with the agent
There is a misunderstanding we should clear up. Antigravity is not a drag-and-drop tool for people who can't code. It is a real programming environment where the agent does the heavy lifting and a human holds the wheel. Don't believe ads saying anyone can build an app in minutes with no technical skills.
The human role in Antigravity is supervision. The agent proposes changes, and the human reviews and approves or rejects them. The agent writes a piece of code, and a technical person reads it to see whether it makes sense. This approach is called human in the loop. It keeps the product from drifting off course.
This is the pain of half-baked automation. Many of you have tried app-generating tools. At first it feels magical. But when you need to change one detail the way you want it, everything falls apart. Nobody in the company understands what the machine just created. You can't fix it, and you hate to throw it away.
Antigravity avoids that trap because it is open. Everything the agent does is real code in a real project. Your technical person can look at it, change it, and understand it. When you need to change the layout, the button color, or a text label, they tell the agent or edit it by hand.
The editing process is clear. You look at the version the agent just built. Anything that isn't right, you note down. Your technical person describes the change to the agent, for example move the save button to the top of the screen. The agent edits, and the reviewer checks again. Repeat until you're happy.
Antigravity can also run several agents in parallel. One agent does the interface, another handles the data. The supervisor coordinates both. This is fast, but the more agents there are, the more you need someone alert watching. Don't let many jobs run at once with nobody checking.
We'll be honest. This supervision needs someone with a technical background, even a basic one. A person who knows nothing about code won't know when the agent has gone wrong. You should assign an IT person at your company to own this part. That is the safest way to use Antigravity.

Point to an existing Excel file, and the agent reads its structure and builds a management tool
Most businesses manage with Excel or Google Sheets files. Orders, inventory, customer lists. A file works fine when you're small. But when many people edit at once, the data gets messy. One person deletes something by mistake and a whole month of figures is gone. This is a very real pain for you as your team grows.
Antigravity helps your engineering team turn that data into a tidier management tool. The approach is to point the agent at the data file you already have. The agent reads the columns, understands the data types, and proposes a tool for adding, editing, deleting and searching on top of it.
The steps are as follows. Your technical person connects a storage account or uploads the file to the workspace. Then they tell the agent, for example build a management tool from this file. The agent analyzes the structure and proposes the matching screens.
The most important step is checking. The agent guesses data types from the file's content. It can get them wrong. A date column read as text. An amount column that loses its format. The supervisor has to go through every field and fix what the agent guessed wrong.
We stress this point. Don't trust the agent to read it 100% right the first time. Your real data is usually messier than the agent expects. There are empty cells, hand-typed typos, and inconsistent formats. The technical person has to clean the data first, and only then let the agent build the tool.
Done right, the result is well worth it. You get an internal tool to replace the tangled Excel file. Many people can use it at once without overwriting each other. Permissions are clear about who can view and who can edit. Small internal jobs get solved without hiring out a whole package.
We advise you to use this approach for small, clear problems. Managing a list, tracking a simple process. When the data connects to many other systems, or has to run reliably for a long time, that's when you should bring in a dedicated team. We'll spell out this limit in the final part.

Set up automated tasks so the system sends a report every Monday morning
Periodic reporting quietly eats time. Every Monday morning someone sits down to compile last week's figures and send them to the board. It's repetitive, boring, and easy to get wrong. Miss one week and the boss asks. This is the kind of job worth letting a machine do instead of a person.
In a tool built on Antigravity, the engineering team can set up automated tasks. The principle has two parts. One is the trigger, meaning when it runs. The other is the action, meaning what it does when the trigger happens.
A concrete example. The trigger is 9 a.m. every Monday. The action is compiling the week's figures and emailing them to the board. Set it up once and the system runs on its own for good. You never have to remind anyone to do the report again.
You can add familiar channels too. Send an email notification when a new order comes in. Fire a Telegram message when inventory runs low. Update the status when a task is done. Every automated task is one less thing you have to do by hand.
But we have to talk about the hard part. Automation is only reliable when it's tested thoroughly. A wrongly set rule can send a wrong report to the whole board. Or blast the wrong notifications to customers. The supervisor has to test many times before letting it run for real.
This is also where the boundary starts to show. Antigravity can automate a few internal jobs. But when an automated flow touches money, customer data, or several systems at once, the risk climbs fast. A small error is no longer small.
We advise you to start with safe tasks. Internal reports, reminders, compiling figures. These are areas where mistakes don't do much harm. When you want to automate important processes that run continuously, let an experienced team build and watch them. That's our job.

From test version to real system: when you need a dedicated software team
Antigravity is very strong for building fast and testing ideas. But every tool has a stopping point. You need to know exactly where it is. Know it early so you don't pour effort into something and then have to drop it halfway. This is the most honest part of this article.
The first limit is security. A quickly built test version usually isn't up to standard on permissions and data protection. When the tool holds customer information, contracts, and amounts of money, the risk is very high. One exploited hole means lost data, lost trust, and sometimes legal trouble.
The second limit is deep integration. Larger businesses usually already have core systems such as a CRM or ERP. The new tool has to connect to them and pass data back and forth accurately. That takes technical knowledge that a quick self-built version can hardly deliver.
The third limit is load and long-term operation. A real system has to run reliably day and night, serve many people at once, and not crash at peak hours. When an incident hits at midnight, an on-call team has to fix it right away. A self-built tool doesn't come with that support team.
We'll be straight. When a project hits these three limits, doing more yourself only costs time. The harder you patch, the messier it gets. By the time you call a dedicated team, they have to untangle it from the start. You lose the old effort and pay for new effort too.
The smart approach is to split the roles. You use Antigravity to write a clear spec and build a quick test version. That test version proves the idea is right and clarifies the requirements. When you need a real system running for customers, you hand the spec and the test version to a dedicated software team.
That's where MONA comes in. We take the spec you've prepared and build it into a system that meets security standards, integrates deeply with your existing CRM and ERP, runs reliably, and has an on-call operations team. You save the description and testing work, and we handle the real build.
If you already have a test version on Antigravity and want to turn it into a system that runs for real, call the MONA hotline at 1900 636 648. We review the spec, give a transparent quote, and see it through. Don't let a good idea die at the test version stage.

Related articles
Professional website
design services
Own a website with a beautiful, 100% exclusive design and a lifetime warranty, with the ability
to expand features flexibly as your business grows, starting today!































Free AI courses
AI tools at work
VI
EN


