Developing a full-stack application often feels like juggling flaming chainsaws. But what if you could automate the architecture, blueprinting, and scaffolding? Today, we’re diving into how we built the Full stack application using Antigravity IDE—a robust ecosystem powered by Angular, Stitch, Spring Boot 3 (JDK 21), and MySQL, all orchestrated through AI-driven tools like SpecKit, Stitch, and Gemini CLI.
Step 1: Crafting the “God-Prompt” PRD
Before writing a single line of code, we needed a roadmap. We used FeeDough’s Prompt Generator to create a high-fidelity Product Requirement Document (PRD).
The goal? A clear definition of:
- Core Modules: Auth (RBAC), User Mgmt, Product CRUD, and Dashboards.
- Technical Stack: JDK 21 Virtual Threads (Project Loom) for high concurrency, Spring Boot microservices, and Angular.
Prompt:-
create a prompt that will create PRD (Product requirement document) required for development of full stack application. We want front end to be develop in angular, middle ware in springboot microservice using jdk 21 and back end as MySQL. Make sure to include module like
Core Functional Modules
- Authentication & Authorization
- User registration, login, password reset
- Role-based access control (admin, user, guest)
- User Management
- Profile management
- Account settings
- Product Management
- CRUD operations on products (create, read, update, delete)
- Product categorization and tagging
- Feature Management
- CRUD operations on product features
- Linking features to specific products
- Search & Filtering
- Search products by name, category, or attributes
- Advanced filters for features
- Dashboard
- Overview of products, features, and usage statistics
Supporting Modules
- Audit & Logging
- Track changes made to products and features
- Activity logs for user actions
- Notifications
- Email or in-app alerts for product updates, feature changes
- API Layer
- REST/GraphQL APIs for integration with other systems
- Data Validation
- Ensure product and feature inputs meet business rules
Advanced/Optional Modules
- Analytics & Reporting
- Product usage statistics
- Feature adoption metrics
- Workflow/Approval
- Optional approval process for product or feature changes
- Versioning
- Maintain history of product and feature changes
- Integration
- Connect with external services (ERP, CRM, payment gateways if needed)
Non-Functional Modules
- Security
- Data encryption, secure APIs
- Scalability
- Load balancing, caching
- Performance Monitoring
- Health checks, error tracking
- Localization
- Multi-language support if targeting global users
outPut Prd text:-
The project involves developing a full-stack application with a front end in Angular, middleware in Spring Boot microservices using JDK 21, and a back end with MySQL. The application aims to provide a user-friendly experience with robust functionalities for managing products and users. The core functional modules will include features like authentication, user management, product management, and advanced search capabilities, among others.
The objective is to create a detailed Product Requirement Document (PRD) that outlines the necessary specifications and modules needed for successful development. This PRD should ensure clarity in requirements and facilitate efficient collaboration among the development team.
You have to outline the PRD by including the following key sections:
- Core Functional Modules
- Authentication & Authorization
- User Management
- Product Management
- Feature Management
- Search & Filtering
- Dashboard
- Supporting Modules
- Audit & Logging
- Notifications
- API Layer
- Data Validation
- Advanced/Optional Modules
- Analytics & Reporting
- Workflow/Approval
- Versioning
- Integration
- Non-Functional Modules
- Security
- Scalability
- Performance Monitoring
- Localization
Each section should provide:
a) a brief description of the module and its purpose
b) specific functionalities and requirements
c) any technical constraints or considerations
d) user roles and permissions related to the modules
Ensure that the PRD is comprehensive enough to guide the development team throughout the project lifecycle while being easily understandable for stakeholders.
Assume that the development team has experience with Angular, Spring Boot, and MySQL, and that they can commit to a timeline of _ months for the application development. The team consists of _ developers specializing in front end, middleware, and back end.
I want you to deliver a well-structured PRD for the full-stack application, organized according to the specified sections, and detailed enough to serve as a clear roadmap for the development process.
Step 2: Supercharging with AI Skills
We don’t just write code; we inject “skills” into our environment using skills.sh. This allows our AI agents to understand specific frameworks deeply.
We installed three essential skillsets:
- Spring Boot:
npx skills add ... --skill java-spring-boot - Angular:
npx skills add ... --skill angular-component - App Prompts:
npx skills add ... --skill spring-boot-application
[!TIP]
Safety First: Always check the Security Risk Assessment provided by theskillsCLI. Our chosen skills were flagged as Safe with Low Risk from Snyk.
Example:-
Step 3: UI Scaffolding with Google Stitch
Why start with a blank CSS file? We used the Stitch Tool from Google Labs to generate our UI pages. These assets were downloaded and placed directly into the Antigravity workspace to serve as the visual source of truth for our AI agents. 
Step 4: The CLI Power-Up (SpecKit & Gemini)
Now for the heavy lifting. We initialized our project structure and installed the brain of the operation.
By linking SpecKit with Gemini CLI, we created a bridge between architectural requirements and automated code generation.
Step 5: Executing the “Constitutional” Workflow
Using the PRD as context, we fed a master prompt into the Gemini CLI to generate the SpecKit command set. This is where the magic happens. We break the project down into five distinct AI directives:
/constitute (The Vision)
We defined the tech stack: Spring Boot 3 with Virtual Threads for maximum performance and MySQL with Liquibase for database versioning.
/specify (The Requirements)
| Module | Technical Focus |
|---|---|
| Auth | JWT + Refresh Token rotation  |
| Product Mgmt | JDK 21 Virtual Threads for I/O efficiency  |
| Dashboard | Real-time updates via WebSockets  |
/plan & /task (The Execution)
We mapped out an 8-Sprint roadmap, starting from the MySQL schema foundation to “Hardening” through security pen-testing and localization (i18n).
1. /constitute: Project Vision & Architecture
Objective: Build a scalable, secure product management ecosystem using Angular, Spring Boot (JDK 21), and MySQL.
- Frontend: Angular (Latest LTS) with RxJS for state management.
- Middleware: Spring Boot 3.x (JDK 21) utilizing Virtual Threads (Project Loom) for high-concurrency handling.
- Database: MySQL 8.0 with Liquibase for schema versioning.
- Communication: RESTful APIs with JWT-based security.
2. /specify: Module Requirements
Core Functional Modules
| Module | Purpose | Key Functionalities | Technical Considerations |
|---|---|---|---|
| Auth & AuthZ | Secure access control. | JWT, OAuth2, MFA, Password hashing (BCrypt). | Stateless sessions; refresh token rotation. |
| User Mgmt | Administer users. | CRUD operations, Role-Based Access Control (RBAC). | Ensure soft-delete for audit integrity. |
| Product Mgmt | Core business logic. | Catalog management, inventory tracking, image uploads. | JDK 21 Virtual Threads for heavy I/O tasks. |
| Search & Filter | Data discovery. | Multi-criteria filtering, full-text search. | Index MySQL columns for performance. |
| Dashboard | Data visualization. | Summary cards (Total users/products), activity feeds. | Use WebSockets for real-time updates. |
Supporting & Advanced Modules
- Audit & Logging: Implement Spring AspectJ (AOP) to intercept method calls and log changes to a central
audit_logtable. - Notifications: Email (SMTP) and In-app notifications for status changes.
- API Layer: Centralized Gateway for routing and Rate Limiting.
- Workflow/Approval: A state-machine logic for product approvals before they go “Live.”
3. /plan: Development Phases
- Phase 1: Foundation (Sprints 1-2)
- Setup MySQL Schema & Liquibase.
- Implement Auth Service (Spring Security + JWT).
- Angular Base Setup (Interceptors, Guards).
- Phase 2: Core Features (Sprints 3-5)
- Product and User CRUD microservices.
- Search/Filter implementation.
- Phase 3: Support & Advanced (Sprints 6-7)
- Audit logging and Notification engine.
- Analytics Dashboard integration.
- Phase 4: Hardening (Sprint 8)
- Security Pen-testing.
- Localization (i18n) implementation.
4. /task: Actionable Backlog
- [Backend] Configure Spring Boot 21 to use Virtual Threads for the Product API.
- [Frontend] Create Angular
AuthServiceandAuthGuardfor route protection. - [Database] Design ERD for
Users,Roles,Products, andAuditLogs. - [DevOps] Dockerize services for consistent local development via CLI.
5. /implementation: Non-Functional & Technical Standards
Security & Scalability
- Security: Implement CSRF protection, SQL injection prevention (via Spring Data JPA), and TLS encryption.
- Scalability: Microservices should be stateless to allow horizontal scaling behind a Load Balancer.
- Performance: Utilize Spring Caching (Redis or Caffeine) for frequently accessed product categories.
User Roles & Permissions
- Super Admin: Full access to User and System settings.
- Manager: Can manage products and view analytics but cannot delete users.
- Viewer: Read-only access to the Dashboard and Product catalog.
Final Step: Putting it All Together
The final piece of the puzzle is informing Antigravity and SpecKit to respect our custom context. During the /plan execution, we point the AI to:
- The
.agents/skillfolder (for framework-specific logic). - The
stitchfolder (for UI/UX consistency).
[phase1.foundation]
description = “Setup MySQL & Auth” context = [“.agents/skill”, “stitch/ui-ux”]
By combining a rigorous PRD with AI-driven skillsets and modern CLI tools, we’ve turned months of architectural planning into a streamlined, executable workflow JDK 21?** 
.
This blog explores how to leverage Antigravity IDE in combination with Speckit, Skill scripts, and Gemini Skills to streamline development workflows. By stitching together UI/UX design, LLM integration, and CLI-based development, teams can accelerate productivity and maintain modularity.
[Antigravity IDE + Speckit + Skill [cursor skill+ agentskill.sh + skill.sh] + gemini skill [https://github.com/google-gemini/gemini-skills/tree/main] to fetch the latest available LLM to do the work + create gemini.md files (from PRD files)+ Stitch (for UI/UX web and mobile screen) + Gemini model with antigravity IDE for development or Opencode cli or Kilo code cli + cline cli + Qwen cli]
Core Components
- Antigravity IDE: Central development hub with seamless integration across Opencode, Kilo code, Cline, and Qwen CLIs.
- Speckit + Skill Scripts: Schema-driven data management with
cursor,agentskill.sh, andskill.shfor modular automation. - Gemini Skills: Google Gemini Skills repository for fetching the latest LLMs.
- Gemini.md Files: Generated from PRDs to bridge product requirements and implemented skills.
- Stitch: Rapid prototyping tool for web and mobile UI/UX, integrated with Antigravity IDE.
- CLI Integrations: Opencode (open-source workflows), Kilo code (lightweight execution), Cline (CI/testing), Qwen (AI-assisted debugging).
Workflow Architecture
- PRD → Gemini.md: Convert product requirement docs into structured manifests.
- Skill Binding: Use
agentskill.shandskill.shto bind Gemini skills into Antigravity IDE. - UI/UX Stitching: Design screens in Stitch and export directly into IDE.
- LLM Integration: Fetch and embed the latest Gemini models for intelligent coding.
- CLI Execution: Deploy and test across Opencode, Kilo code, Cline, and Qwen CLIs.
Benefits
- Unified development workflows in Antigravity IDE.
- Scalable automation with modular skill scripts.
- Enhanced productivity via Gemini LLMs.
- Seamless design-to-code handoff with Stitch.
- Flexible deployment across multiple CLIs.
Source Code:-https://github.com/shdhumale/antigravity_workspace_default.git
