Photo by the editor
# Entry
Creation Product requirements document (PRD) is a common process in product management and a common task in sectors such as software development and the entire technology industry. But the story doesn’t end with PRD, and the next gigantic step is to turn it into a product, e.g. working software.
This article is a continuation of the previous one, where we turned a set of raw, messy information into a well-established PRD, and walks you through the same apply case (a mobile-friendly app called FloraFriend) to turn that PRD into a working software prototype using Google Antigravity.
Although the article demonstrates that a full software development process is impractical, we will highlight key aspects of using Antigravity for this purpose, along with some representative pieces of the generated software for illustrative purposes.
# Moving from PRD to software prototype
Get ready, because the magic happens in the process we’re about to describe. If used properly, Google antigravity may partially act as chief engineer. This is downloadable IDE available for multiple operating systems: you can think of it as a variation of VS Code, where instead of just typing in code, you can have AI agents write it for you.
Needless to say, the first step is to download Antigravity and install it on your computer.
The central element worth getting acquainted with in Antigravity is, above all, its dedication Agent Manager view: where we present our software requirements. Then, autonomous agents will plan, implement and even test the built solution.
Let’s start with the opening – by the way, I highly recommend picking up “Tokyo Night”! – theme and in your local file explorer, create a novel, empty project folder, giving it a name flora-friend-app. If you are familiar with VS Code, Antigravity’s UI (UI) will be very familiar to you.
Below you can see the result of opening the newly created folder called “flora’s friend app” which is currently empty:
First steps with Antigravity
Now comes the stimulating part. Open the Agent Manager view by clicking the dedicated button in the bar at the top. You’ll see a beginner-friendly explanation of what agents can do in the Agent Manager:
Agent Manager welcome screen
To get started, we’ll send you this prompt (don’t click “send” yet) asking for a plan to implement a mobile-friendly web app:
Serve as a Senior Full Stack Engineer. Please review the attached PRD for “FloraFriend”. Create a comprehensive deployment plan to build this web app mobile using Next.js, Tailwind CSS, and Shadcn UI. Don’t write code yet; first generate a Blueprint Artifact.
This hint an actual PRD document should be included, like the one you might get if you follow the previous, related article on NotebookLM for the PRD generation – or your own, for that matter. Either way, you have two main options include PRD: either manually paste the code as part of the prompt right after the above request, or by including a PRD file (.docx, .pdf or similar) in the project folder you created earlier – if you choose the copy-paste option, apply the option carefully Shift + Enter keyboard keys to create a few novel lines and paste the PRD right after the request, before sending the full prompt. Great news: the Google Gemini LLMs that power Antigravity and its agents have a huge context window size; in other words, we can attach a very long file of pasted text to seamlessly contextualize our tooltip.
After about a minute, you may get a response that looks like this:
Sample output in Antigravity Agent Manager
On the right side of the agent manager window, you will see a checklist containing software design steps such as “initialize Next.js application (…)“. Here we have the opportunity to review this list and send additional suggestions using the “Review” button to correct items or add novel ones, for example by prompting:
Add “Build Component: Plantcard (with Snooze Logic)” and “Weekend Logic” to your backend tasks.
Fresh or changed items will “magically” appear on the checklist.
Let’s go ahead and assume we’re cheerful with the plan as it is. This is a hard step because finding the right button to click and move on isn’t obvious, especially after several interactions to refine it. The key is to scroll up the generated artifact fields in the chat stream and find the one labeled “Deployment Plan”. Open it and on the right side click the “Continue” button. This is where the agents come into full operation, doing things like installing dependencies, creating a database schema with a few relevant tables via a file called schema.sqland so on. Below is an example of the code generated to perform these actions:
Generated a schema.sql file for our software database
The entire process is step-by-step and requires manual review and approval on your part before moving on to the next step, but gradually you’ll see the boxes ticked on your project planning checklist. Sometimes you will need to manually install certain dependencies in your PATH or meet similar requirements for agents to continue their work. But basically all it takes is careful interaction and prompting!
One last example: this is what a snippet of the final application might look like:
// components/PlantCard.tsx
import { useState } from 'react';
import { Card, Button, Badge } from '@/components/ui';
import { WaterDropIcon, SnoozeIcon } from '@/icons';
interface PlantProps {
name: string;
species: string;
nextWatering: Date;
onSnooze: (id: string) => void;
onWater: (id: string) => void;
}
export default function PlantCard({ name, species, nextWatering, onSnooze, onWater }: PlantProps) {
const isOverdue = novel Date() > nextWatering;
return (
{/* Visual Cue for Overdue Plants */}
{isOverdue && (
Thirsty!
)}
{/* The "Matt Feature" - Snooze Button */}
Next scheduled: {nextWatering.toLocaleDateString()}
);
}# Summary
This article shows you how to apply Google Antigravity, one of the newest tools available in the Google AI suite, to generate software prototypes. In particular, we illustrated the logic of transforming the PRD into a software prototype.
Ivan Palomares Carrascosa is a thought leader, writer, speaker and advisor in the fields of Artificial Intelligence, Machine Learning, Deep Learning and LLM. Trains and advises others on the apply of artificial intelligence in the real world.