Balancing the rigors of PhD research with the itch to build software feels like fighting a war on two fronts, where time is the only casualty. When your mental bandwidth is consumed by academic papers and complex modeling, your personal coding projects usually end up gathering digital dust. I realized that to keep building, I had to stop being the "coder" and start being the "orchestrator." By moving beyond simple AI assistance to a fully autonomous agentic workflow, I’ve created a development loop that codes, audits, and heals itself while I focus on my dissertation.
The Bottleneck: Why AI Chat Isn't Enough
Most developers today use AI as a sophisticated autocomplete or a conversational debugger. You ask a question, get a snippet, and manually paste it into your IDE. While this is faster than Stack Overflow, you remain the bottleneck. You are still the one clicking "run," reading the error logs, and pushing the commits.
For someone handling high-intensity academic work, this "manual" AI interaction is still too expensive in terms of context switching. To truly scale your output, you need to move from AI-assisted coding to Agent-first orchestration. This means building a system where the AI doesn't just suggest code—it understands the project context, executes tasks, and responds to feedback without your constant supervision.
Meet the Squad: The 4 Pillars of an Autonomous Team
To replace a human team, you have to replicate the specialized roles found in a professional dev shop. My autonomous "Dev Team" is composed of four distinct AI-driven roles that pass the baton to one another.
The Architect (Gemini)
Every project starts with a high-level goal, but jump-starting straight into code is a recipe for technical debt. Gemini acts as my Architect. I provide the "Big Picture" idea, and the model analyzes the requirements, suggests the best tech stack (often FastAPI or Django), and generates a Precise Implementation Plan. This plan serves as the source of truth for the rest of the loop, ensuring the "Engineer" doesn't hallucinate features I don't need.
The Engineer (Antigravity)
This is where the heavy lifting happens. Antigravity takes the Architect’s plan and begins the execution phase. Unlike a standard LLM, it operates within a controlled environment where it can:
- Write modular code using models like Gemini 3.1 Pro or Claude 4.6 Opus.
- Initialize project structures automatically.
- Run local tests to verify that the code isn't just syntactically correct but functionally sound.
The Auditor (CodeRabbit)
Even the best AI-written code needs a second pair of eyes. Once Antigravity pushes the code to a GitHub Pull Request, CodeRabbit steps in. It performs a deep, asynchronous review of the PR, looking for:
- Logic flaws and edge cases.
- Security vulnerabilities.
- Compliance with PEP8 or specific project style guides.
- Instead of me having to review every line, CodeRabbit leaves actionable comments directly on the PR, acting as a tireless Senior Lead Engineer.
The Self-Healer (Antigravity + GitHub MCP)
This is the "secret sauce" that makes the team truly autonomous. In a traditional setup, I would have to read CodeRabbit's feedback and fix the code myself. By using the Model Context Protocol (MCP), I’ve bridged the gap. Antigravity can now "read" the GitHub context, ingest the review comments from CodeRabbit, and autonomously push fixes to address the feedback.
The Power of the Model Context Protocol (MCP)
If you haven't explored the Model Context Protocol (MCP) yet, you are missing the most important shift in AI development since the transformer. MCP is an open standard that allows AI models to connect seamlessly to external data sources and tools without custom, brittle integrations.
By implementing a GitHub MCP server, I’ve given my AI agents a "peripheral nervous system." They no longer just generate text; they can interact with the repository's state.
Key benefits of the MCP-driven approach:
- Context Awareness: The agent knows exactly which file the review comment refers to without you copy-pasting the code.
- Tool Interoperability: It allows Antigravity to use GitHub as a "brain extension," checking issue labels or reading PR discussions to understand the "why" behind a requested change.
- Reduced Latency: Decisions happen at the edge of the workflow, reducing the need for the human-in-the-loop to act as a bridge between different software platforms.
From "AI-Assisted" to "Agent-First"
The transition to an agentic workflow is a mindset shift. In the old way (AI-assisted), the human is the center, and the AI is the tool. In the new way (Agent-first), the Workflow is the center, and the human is the manager.
Think of it like the difference between using a calculator and writing a script. The calculator helps you do the math faster, but the script does the math for you while you sleep. For a PhD student or a busy professional, this isn't just about "efficiency"— it's about reclaiming your cognitive energy.
Top comments (0)