Tools & Workflow • • 6 min read

Mastering AI-Driven Workflows: ai-devkit and antigravity-kit Guide

The transition from traditional coding to AI-augmented development has brought a specific set of frustrations that every senior engineer eventually encounters. Even with powerful tools like Cursor or Claude Code, we often find ourselves repeating the same architectural constraints, naming conventions, and project goals every time we start a new chat session. This "context debt" is the primary friction point in modern AI workflows.

Recently, two open-source toolkits from the Vietnamese developer community have emerged to solve this exact problem: ai-devkit (by codeaholicguy) and antigravity-kit (by vudovn). While they might seem similar at a glance, they solve two different halves of the AI productivity equation. ai-devkit provides the project with long-term memory and structural documentation, while antigravity-kit provides a sophisticated layer of specialized agents for execution.

This guide explores how to integrate both into your professional workflow to transform your AI assistant from a general-purpose LLM into a context-aware senior partner.

The Architectural Gap: Why AI Toolkits Are Necessary

To understand why these tools are game-changers, we must analyze the "Context Gap." Large Language Models (LLMs) operate within a limited context window. When you open a project in Cursor, the AI uses RAG (Retrieval-Augmented Generation) to search your files, but it doesn't inherently understand the intent behind your architecture or the roadmap of your current sprint unless specifically told.

Without a structured framework, you face two main issues:

  • Context Fragmentation: The AI forgets the global "Rules of the House" (e.g., "We always use the Repository Pattern") while focused on a local bug.
  • Generalist Mediocrity: A generalist prompt receives a generalist answer. A task requiring security auditing needs a different "mental model" than one requiring CSS refactoring.

Deep Dive: ai-devkit – The Project's Long-Term Memory

ai-devkit is designed around the philosophy that documentation is code for AI. It structures your project's meta-information into seven distinct phases that mirror the Software Development Life Cycle (SDLC).

The 7-Phase Documentation Structure

By initializing ai-devkit, you create a docs/ai/ directory. This directory becomes the "source of truth" for the AI's understanding of your project:

docs/ai/
├── requirements/    # The 'Why' and 'What' (PRDs, User Stories)
├── design/          # The 'How' (Architecture, Tech Stack, API Specs)
├── planning/        # The 'When' (Sprint tasks, implementation order)
├── implementation/  # The 'Standard' (Linting, naming, patterns)
├── testing/         # The 'Quality' (Test strategies, mock data)
├── deployment/      # The 'Where' (CI/CD, environment variables)
└── monitoring/      # The 'Health' (Logging patterns, error codes)

The magic happens via the .cursor/rules/ directory, where ai-devkit generates rules that instruct Cursor to read these specific docs before generating code. This ensures the AI never suggests a .then() block when your implementation/README.md explicitly mandates async/await.

Deep Dive: antigravity-kit – The Specialist Execution Layer

If ai-devkit is the project's brain, antigravity-kit is its hands. It focuses on the Agentic Workflow. Instead of interacting with a single "AI Chat," it routes your requests through specialized personas.

Specialist Agents and Skill Modules

The kit includes 20 specialized agents. When you ask a question, the system determines which persona is best suited for the task:

  • @backend-specialist: Focuses on logic, database optimization, and API design.
  • @security-auditor: Scans for SQL injection, XSS, and broken access control.
  • @debugger: Uses a "Chain of Thought" approach to isolate root causes rather than guessing.
  • @ui-ux-pro-max: Provides high-fidelity UI suggestions based on modern design systems.

Beyond agents, it provides 11 workflow commands (like /brainstorm and /enhance) that trigger pre-defined prompt chains, ensuring high-quality, consistent output across different tasks.

Installation and Project Initialization

To begin, you need a Node.js environment. Install both toolkits globally to access their CLI tools:

# Install the toolkits
npm install -g ai-devkit @vudovn/ag-kit

# Navigate to your project root
cd my-awesome-project

# Initialize ai-devkit (Select 'cursor' as environment)
ai-devkit init

# Initialize antigravity-kit
ag-kit init

The Hidden Step: Excluding Meta-Docs from Git

In many enterprise environments, you might not want to commit AI-specific documentation to the main repository. Use .git/info/exclude to keep these files local to your machine without cluttering the shared .gitignore:

cat <<EOF >> .git/info/exclude
.agent/
docs/ai/
.cursor/
.ai-devkit.json
EOF

Strategic Insights: Populating the Context

A toolkit is only as good as the data it contains. To get 10x value, you must fill out the Design and Implementation docs immediately. Here is a high-performance template for docs/ai/design/README.md:

## Core Tech Stack
- Framework: .NET 8 Web API
- Database: PostgreSQL with Entity Framework Core
- Caching: Redis (Distributed Cache)
- Auth: OpenID Connect with Duende Software

## Architectural Patterns
- Clean Architecture (Domain, Application, Infrastructure, WebApi)
- CQRS using MediatR
- Result Pattern for error handling (no exceptions for flow control)

And for docs/ai/implementation/README.md, define your specific coding style:

## C# Coding Standards
- Private fields: _camelCase
- Methods: PascalCase
- Use 'var' only when the type is obvious from the right-hand side.
- All public methods must have XML documentation.
- Primary Constructors (.NET 8) preferred for Dependency Injection.

The Integrated Workflow: A Practical Example

How do these work together in a real-world scenario? Let’s say you need to add a "Rate Limiting" feature to your API.

Phase 1: Planning (ai-devkit)

Start with /new-requirement. The AI reads your current design and implementation docs. It realizes you are using .NET 8 and suggests the built-in Microsoft.AspNetCore.RateLimiting middleware instead of an external library, aligning with your "Minimal Dependency" philosophy documented in design/.

Phase 2: Brainstorming (antigravity-kit)

Run /brainstorm "Should we use Fixed Window or Token Bucket for public API endpoints?". The @security-auditor agent will weigh in on the pros and cons of each for preventing DDoS vs. providing user flexibility.

Phase 3: Implementation (antigravity-kit)

Use /create "Rate limiting policy for Auth endpoints". The @backend-specialist generates the code. Because ai-devkit has already loaded your "C# Coding Standards," the generated code uses Primary Constructors and correct naming conventions automatically.

Phase 4: Review and Validation (ai-devkit)

Run /check-implementation. The AI compares the new code against docs/ai/design/. If you accidentally added the rate limiting logic in the Controller instead of the Infrastructure layer (violating your Clean Architecture rule), it will flag it.

Troubleshooting and Best Practices

While these toolkits are powerful, they require maintenance:

  • Drift Management: As your architecture evolves, update your docs/ai/ files. If the docs say you use REST but you’ve moved to GraphQL, the AI will provide incorrect suggestions.
  • Agent Overlap: Occasionally, antigravity-kit might route to an agent you don't expect. If the output feels "off," explicitly invoke an agent (e.g., "Using @security-auditor, review this...").
  • Context Bloat: If your docs/ai/ folder becomes too massive, the AI might get confused. Keep documents concise and focused on high-level patterns rather than exhaustive detail.

Conclusion

The combination of ai-devkit and antigravity-kit represents a shift from "Prompt Engineering" to "Context Engineering." By providing a structured memory of your project and a specialized team of agents to act on it, you eliminate the repetitive re-explanation phase of AI coding. This allows you to focus on high-level architectural decisions while the AI handles the implementation with precision and consistency.

Both projects are open-source and reflect the practical needs of modern developers. Start with a small feature, populate your docs, and experience the difference that a context-aware AI assistant makes in your daily velocity.

← Back to Blog