A weekend with Antigravity: 17,000 Lines of Code in < 48 Hours

This weekend, I didn't just code. I accelerated.

I spent the last 48 hours pair-programming with Antigravity, an advanced AI coding assistant. We took a legacy JavaScript codebase—riddled with global variables, monolithic files, and "spaghetti" dependencies—and transformed it into a modern, service-oriented architecture.

The results go beyond just "helper" status. The metrics suggest a level of productivity that warps the traditional time-cost equation of software development.

This app started out in 2024 as a scrappy concept, MVP, rapidly coded as a single index.html file with inline vanilla Javascript & CSS code - messy spaghetti code that grew and grew, until this weekend when I decided to just stop, refactor and clobber all technical debt. The goal? To experience the full journey of coding with AI and improve the code over time, to eventually get a "modern" app deployed. This code was touched by many AI hands: GPT-o1, Gemini, Claude, Codex 5.1, and also my manual tweaks here and there. 

---

The Analytics: Friday to Sunday

Let's look at the raw data from git. This represents activity from Friday, December 5th, to Sunday evening, December 7th.

• Commits: 60 (non-merges)
• Files Changed: 89
• Lines Added: 10,468
• Lines Deleted: 6,755
• Total Code Churn: ~17,223 lines

17,000 lines of code touched in one weekend.

The Narrative: Deconstructing the Monolith

When we started on Friday, the application was held together by window objects. Functions were exposed globally, state was scattered across main.js and utils.js, and components were tightly coupled to the DOM via inline onclick handlers.

Here is the story of our weekend, told through the commit log:

1. The Purge of Globals: We began by hunting down window. dependencies. One by one, we replaced fragile global state with rigid, testable Singletons and Services.
2. Breaking main.js: We took the 1,000+ line main.js file and chopped it up. We extracted logic into dedicated domains: PlanningService, AIService, SystemService, and NotificationManager.
3. Refactoring the UI: We implemented a VIEW_REGISTRY pattern, moving away from ad-hoc function calls to structured Class-based component management.
4. Safety Check-ins: You see this pattern in the logs constantly: "Safety checkin - refactoring...". We moved fast, but we didn't break things. The AI allowed me to make sweeping architectural changes with the confidence that I wasn't leaving behind broken references.

The "Antigravity" Effect: AI vs. Human Effort

How long would this have taken a human developer working alone?

The Human Estimate:

To touch 89 files and rewrite the core architecture of an application requires immense cognitive load.

• Day 1-3: Reading code, mapping dependencies, planning the refactor safe-zones.
• Day 4-8: Executing the refactor file-by-file. Manually checking imports. Wrangling with loads of ReferenceError
• Day 9-10: Regression testing. Realizing you broke the "Save" button because it relied on a global variable you deleted three days ago.

Conservative Estimate: 2 Weeks (1 Sprint) of full-time, focused work.

The Antigravity Reality:

We did it in 14.7 hours.

I analyzed the timestamps of every commit. Our total active coding time—the actual time spent typing, refactoring, and verifying—was less than 15 hours.

• Saturday: ~5 hours of strategic refactoring.
• Sunday: ~9.5 hours of high-intensity execution.

The AI didn't just "autocomplete" lines. It understood the architectural intent. When I said "Refactor this to use a Singleton pattern", it didn't just write a class; it found every usage of the old global variable across 20 files and updated them instantly. It remembered the context I would have forgotten.

This wasn't just faster coding. It was higher leverage coding. I spent my weekend making high-level architectural decisions, while Antigravity handled the thousands of lines of execution required to make those decisions reality.

---

Conclusion

If this weekend proved anything, it's that the metric for "developer productivity" is changing. We aren't limited by typing speed or syntax recall anymore. We are limited only by our ability to describe the architecture we want.

My small experiment shows a software engineer would've saved two weeks of work in 15 hours! 

Did I waste my weekend coding with AI? Maybe...but I'm learning a ton and having fun coding after a very long time...it's like I'm back to my early teenage days of losing myself inside the machine...

A week with Antigravity animated by Google Gemini

Codebase Evolution: Time-Lapse

CSS

JS

HTML

Other

Fun animations with Google Gemini - my repo stats

Commit Velocity: https://github.com/khanmjk/altsoftwareplanning

Daily Throughput & Key Milestones

Having some fun with git stats dashboarding via Gemini Pro

Engineering DNA Report

Deep dive analytics of the "Antigravity" refactor

⚡ Vital Statistics

0

Files Touched

-0

Net Lines of Code

0

Active Hours

🕰️ Productivity Clock

📂 Architecture Heatmap

🔥 Churn Champions (Volatile Files)

🎨 The Monolith Buster: CSS Evolution

Tracking the deletion of legacy styles vs. the creation of modular view components.

The Antigravity Chronicles: A Week of Refactoring, Regret, and Redemption

In a previous post I shared my experience with Antigravity... here's what I was actually able to achieve in less than one week... for those of you still doubting the revolution and impact on software developers, you need to start waking up... I believe that AI coding agents will disrupt frontend software developers...

The rest of this blog post was written by Gemini, from within the Antigravity IDE (another use case for Antigravity, you don't need to leave the console to write a blog post!).

I asked it to review our changes from the past week and write a blog post reflecting on the journey so far... As usual, AI models are ever the optimists -- I actually spent a lot of time coaxing, cursing, shouting and fixing up both Claude and Gemini mistakes... sometimes undoing a lot of work and starting over again!!

The Spark

It started with a simple frustration: Mermaid.js wasn't cutting it.

On November 24th, I looked at our Gantt charts and realized they were static, rigid, and frankly, boring. I wanted interaction. I wanted to drag, drop, and resize. I wanted "Antigravity"—a branch where we would defy the weight of our legacy code and build something modern.

I didn't know I was about to break everything.

The Good: High Velocity & The "Frappe" Win

The early days were a rush. We integrated Frappe Gantt, and suddenly, the application felt alive.

• Dynamic Resizing: We built a split-pane view that finally let users control their workspace.
• Smart Scrolling: We conquered the "sync scroll" beast, ensuring the task table and chart moved in perfect harmony.

The velocity was intoxicating. We were shipping features daily. But speed has a price.

The Bad: The Monolith & The Mess

As we pushed new features, the cracks in our foundation began to show.

• The 2600-Line Monster: Our style.css had grown into a terrifying monolith. Changing a button color in the "Settings" view would inexplicably break the layout in "Roadmaps."
• Dependency Hell: At one point, we were loading multiple versions of libraries, causing race conditions that made the Gantt chart flicker like a strobe light.
• The "Safety" Check-ins: You can see the panic in the git logs.

  Commit c628846: "safety checkin - fixed and broke service dependencies caroussel"

We were fixing one thing and breaking two others. The codebase was fighting back.

The Ugly: "I've Lost a Feature"

The low point came on December 1st. In our zeal to refactor the OrgView, we got careless. We deleted a chunk of legacy code that generated the engineer table. It wasn't just a bug; it was a regression.

Commit d3ebd4f: "checkin even if I've lost a feature in roadmaps :-("

This was the "Ugly." The moment where you question if the refactor is worth it. We had to go dumpster diving into the git history (specifically commit a0020189) to retrieve the generateEngineerTable function. It was a humbling reminder that "legacy" often means "working."

The Redemption: The Monolith Buster

We couldn't keep patching holes. We needed a structural change.

On December 2nd, we launched Operation Monolith Buster.

• The Strategy: Divide and conquer. We identified every view (Org, Gantt, Roadmap) and gave it its own CSS file.
• The Execution: We slashed style.css from 2,600 lines down to a manageable core.
• The Result: 12 new modular files. 100% component isolation. Peace of mind.

The AI Tag Team: Gemini & Claude

This week wasn't just a test of code; it was a test of the "Multi-Model Workflow." We switched between Gemini and Claude depending on the problem at hand, and the results were illuminating.

Where Claude Shined: The Architect

When it came to the CSS Monolith Buster, Claude was the surgeon.

• Strength: Precision in refactoring. I could paste a 500-line CSS file and ask it to "extract the Gantt styles," and it would do so with surgical accuracy, rarely missing a bracket.
• The "Aha" Moment: Claude suggested the folder structure reorganization that finally made sense of our chaotic js/ directory.

Where Gemini Shined: The Visionary & The Fixer

Gemini was our "big picture" thinker and our debugger.

• Strength: Contextual awareness. When we broke the OrgView, Gemini was the one that helped us "time travel" through the git history to find the missing generateEngineerTable function. It understood the intent of the missing feature, not just the code.
• The "Aha" Moment: The narrative you're reading right now? That's Gemini. Its ability to synthesize logs, commits, and user intent into a coherent story is unmatched.

The Trip-Ups (The "Hallucinations")

It wasn't all smooth sailing.

• The Over-Confidence: Both models struggled when I asked for "blind" fixes without enough context. The regression in commit d3ebd4f happened because we trusted an AI to "clean up unused code" without verifying if it was actually unused.
• The Lesson: AI is a powerful accelerator, but it lacks object permanence. It doesn't "know" you need that feature you haven't touched in 3 months unless you tell it.

Lessons Learned

1. Respect the Legacy: Don't delete code you don't understand until you're sure you don't need it.
2. Commit Often, Even the Broken Stuff: Those "broken" commits saved us. They gave us a checkpoint when we needed to backtrack.
3. Use the Right Model for the Job: Use Claude for structural refactoring and strict logic. Use Gemini for creative synthesis, debugging, and "big context" reasoning.
4. AI is a Co-pilot, Not an Autopilot: The AI helped generate code fast, but it took human oversight to spot that we were await-ing outside of an async function.

Conclusion

The antigravity branch lives up to its name. We aren't just weighed down by technical debt anymore. We have a modern navigation system, a modular CSS architecture, and a powerful new Gantt engine.

It wasn't a straight line. It was a messy, chaotic, beautiful week of coding. And I wouldn't have it any other way.

By The Numbers

• Total Commits: 80+
• Net LoC Change: -1,200 (We deleted more than we wrote!)
• Panic Commits: ~3
• Features Resurrected: 1

Before Refactor Commit: 0b82efa

css

components

Modal.css

aiChatPanel.css

enhancedTableWidget.css

ganttChart.css

header.css

management.css

notifications.css

roadmapModal.css

settings.css

layout

main-layout.css

sidebar.css

style.css// 2600+ lines (MONOLITH)

js

accomplishmentsView.js

capacityTuning.js

dashboard.js

data.js

documentation.js

editSystem.js

featureFlags.js

ganttPlanning.js

goalsView.js

impactView.js

main.js

mermaidGenerator.js

orgView.js

roadmap.js

roadmapTableView.js

sdmForecasting.js

utils.js

visualizations.js

yearPlanning.js

components

HeaderComponent.js

ManagementView.js

RoadmapInitiativeModal.js

SettingsView.js

SidebarComponent.js

SystemsView.js

WorkspaceComponent.js

enhancedTableWidget.js

gantt

FrappeGanttRenderer.js

GanttFactory.js

GanttRenderer.js

MermaidGanttRenderer.js

ganttAdapter.js

ganttGenerator.js

managers

NavigationManager.js

NotificationManager.js

After Refactor Current State

css

style.css// Core only

views// NEW: Modular

accomplishments-view.css

capacity-tuning-view.css

dashboard-view.css

documentation-view.css

gantt-planning-view.css

goals-view.css

org-view.css

roadmap-table-view.css

roadmap-view.css

sdm-forecasting-view.css

system-edit-view.css

visualizations-view.css

welcome-view.css

year-planning-view.css

foundation-components// NEW: Design Sys

ai-chat.css

buttons.css

cards.css

collapsible.css

d3-visualizations.css

dependencies.css

dropdowns.css

dual-list.css

forms.css

legends.css

loading.css

modals.css

system-selector.css

tooltips.css

js

repositories// NEW: Data

SystemRepository.js

state// NEW: State

AppState.js

components

DashboardView.js

HeaderComponent.js

ManagementView.js

OrgView.js

RoadmapInitiativeModal.js

RoadmapView.js

SettingsView.js

SidebarComponent.js

SystemsView.js

WorkspaceComponent.js

enhancedTableWidget.js

Living in Antigravity: A Weekend with Gemini 3, Claude Opus 4.5, Codex 5.1 Max and the Death of "Clean Code"

I spent my entire weekend inside Google’s Antigravity IDE, juggling the three titans of late 2025: Gemini 3 Pro, Claude Sonnet 4.5, and OpenAI Codex 5.1 Max.

My test subject? A "Franken-app" I started building back in the stone age of September 2024. Back then, I was using GPT-4o and the early, limited versions of Claude Sonnet. At the time, those models felt like over-eager interns: they generated code fast, without thinking, and prioritized "showing it works" over best practices.

One+ years later, the landscape has shifted. The "Vibe Coding" hype suggested that software engineering was dead. I’m here to tell you that it’s not dead—but it has mutated into something entirely different.

Here is a video showing the new App refresh versus the old style side-by-side:

Here is what I learned re-wiring a two-year-old messy codebase into an enterprise-grade web app in 48 hours.

The Antigravity Experience: 13 Days In

As I write this, Google Antigravity is less than two weeks old. I installed it on Day 2, and honestly? It was rough. It froze, crashed, and felt heavy. But after the stability patch earlier this week, something clicked.

The "Killer App" isn't just the code generation; it’s the Conversational Context. With Gemini 3 Pro integrated directly into the IDE, I found myself managing a large-scale refactor not by typing code, but by debating architecture. I could propose ideas, ask Gemini to critique them, and even generate UI mockups right there in the console—no context switching to Figma or Photoshop.

However, it’s not perfect.

• The "Human Bottleneck": Antigravity encourages you to run parallel workspaces with multiple agents. But I found that while the machine is multi-threaded, I am not. Context switching between three different agents causing chaos in three different branches is mentally exhausting.

• The "Browser Agent": Promising, but slow. It’s fascinating to watch an AI navigate your app to test it, essentially replacing the QA role, but right now, it struggles to "drive" complex applications without crashing.

The Model Showdown: December 2025 Edition

Since Antigravity lets you swap models, I played them against each other. Here is the reality check:

1. Claude Opus 4.5 (The "Academic"): Supposedly the best coding model in the world. It provides the best analysis and writes detailed, "Senior Engineer" style impact assessments. However, it still makes junior mistakes. It would change a CSS class to fix one page, completely forgetting the cascading impact on the rest of the site. High IQ, low spatial awareness.

2. Gemini 3 Pro (The "Collaborator"): The best conversationalist. It holds the "big picture" context better than the others, but it struggles with long-running threads. Eventually, the context gets so heavy that it stalls or starts hallucinating old patterns.

3. OpenAI Codex 5.1 Max (The "Brute Force"): When I hit a wall, I called in Codex. It lacks foresight and nuance, but it is 100% confident and usually finds a way to "just make it work."

The Big Question: Is Spaghetti Code Actually Bad??

This brings me to my most controversial observation.

We spend so much time prompting these models to respect encapsulation, avoid global namespaces, and write "Clean Code." But why? We are forcing AI to mimic human limitations.

I successfully transformed a 90s-style interface into a Jira-level Enterprise UX in one weekend. The code under the hood? It’s a mess. It is clearly "vibe coded." A human engineer would weep looking at the dependency graph.

But I ask you: So What?

If the AI writes the code, maintains the code, and fixes the bugs, why does a human need to understand it?

• Machines are better than us at reading large datasets and understanding complex, spaghetti-like relationships.

• If the application is secure and performant, the "readability" of the code is purely a vanity metric for human ego.

We are moving toward a future where we trust the machine to do the job. The role of the software engineer is shifting from "Author" to "Architect" and "Reviewer." You still need a technical background to know what to ask for—you need to know what a "race condition" is to spot when the agent creates one—but you no longer need to care about how the syntax is structured.

The Missing Pieces: How Antigravity Can Win

While Antigravity is impressive, my weekend of deep work exposed three critical gaps where the "Agent" promise falls short of the reality. If Google wants this to replace VS Code, here is what needs to happen next.

1. We Need a "Time Machine" for Code

Right now, Antigravity operates in a linear flow. If an Agent goes down a rabbit hole for 20 minutes and ruins the codebase, your only option is to manually git revert or undo endlessly. The Fix: We need Conversation Forking and System Restore Points.

• Imagine a "DVR" slider for your development session. I want to scrub back to 2:00 PM, right before I asked Gemini to "refactor the auth module," and fork the reality there to try a different prompt.

• We need "Save States" for the Agent’s brain, not just the code. I want to revert the context, not just the files.

2. The Context "Amnesia" Problem

I found that even with massive context windows, I am still the only thread tying everything together.

• The Problem: If I start a new workspace for a "UI refresh," that agent has no idea I just spent three hours discussing database schema changes in a different thread.

• The Fix: Cross-Conversation Memory. Agents need a shared "hive mind" or a persistent Project Knowledge Graph. If Agent A makes a decision in Thread 1, Agent B in Thread 2 should instantly know about it without me having to copy-paste the summary.

3. "Architect Mode" vs. "Intern Mode"

It is baffling that in late 2025, I still have to explicitly prompt a state-of-the-art model to "avoid global namespaces" or "separate concerns."

• The Reality: These models are still trained on the average of all GitHub code—which means they default to "average" (spaghetti) quality. They prioritize working code over maintainable code.

• The Fix: I shouldn't have to prompt-engineer basic competence. Antigravity needs a toggle for "Strict Architect Mode"—a system-level guardrail that forces the Agent to adhere to SOLID principles and Design Patterns before it writes a single line of code. I don't want an eager intern; I want a Senior Engineer who pushes back when I ask for something stupid.

Observations So Far: The Paradox of Productivity

I have successfully rewired a 90s-style web app into a modern enterprise platform in 48 hours. The result is undeniable, but the process felt like herding cats.

• The "Vibe Coding" Reality: The app looks great, but under the hood, it is a "Vibe Coded" mess. The dependency graph looks like a bowl of spaghetti.

• The Stability Tax: I found myself having to "close-and-restart" Antigravity multiple times to clear out "ghosts" in the machine.

• The Human Bottleneck: The promise of agents is parallelism, but I am still single-threaded. Trying to manage three agents simultaneously is mentally exhausting. Instead of writing code, I am now a Project Manager constantly unblocking three different junior developers who type at the speed of light but forget instructions every hour.

The value proposition is compelling, but we are not there yet. We have replaced "syntax errors" with "context errors," and I am not sure which one is harder to debug.

The Verdict

Antigravity is buggy, resource-hungry, and requires a "close-and-restart" every few hours. But it is undeniable that the tide has turned. Frontend engineering as we knew it in 2024 is gone.

The future isn't about writing code. It's about managing the agents that write it for you—and perhaps, learning to love the spaghetti.

Note: This blog post was initially written by me and later tidied up with Gemini Pro.

How to use AI to generate software architecture diagrams from simple prompts

In a previous post, I shared some of my experience adding AI features into this proof of concept application I've been building entirely with AI coding assistants. This weekend, I found a way to break through the obstacle I faced with attempting to use Gemini to generate images through its Imagen API. A much simpler way to realise my goal of getting an AI to generate architecture diagrams from a simple prompt, is to instruct the LLM to produce Mermaid diagrams.

All it needed was a carefully crafted system prompt, instructing the AI to create the Mermaid diagram syntax from the data model, and voila! We now have a way to generate almost any diagram one can think of. 

Take a look at this video:

And here's built-in native features of the app that shows different Mermaid diagrams for the system under inspection:

Play with the app here
Source code
Project Wiki

Demonstrating the power of bulk changes to delivery plans

So I've added some bulk operations to the SMT app.

Bulk AI Agent Scenarios (Macro Operations)

Empower the agent to perform complex, multi-entity updates that are tedious to do manually. Each plan highlights the scope before execution (e.g., “This will affect 12 teams...”).

1) Capacity & Resourcing Manager

• User intent: “Reduce all teams’ capacity by 20% to account for burnout.” / “Set everyone’s AI productivity gain to 15%.”
• Tool: bulkUpdateTeamCapacity (supports capacityReductionPercent, aiProductivityGainPercent, avgOverheadHoursPerWeekPerSDE, plus filters by teamIds or orgIdentifier).

2) Strategic Portfolio Manager

• User intent: “Move all ‘Low ROI’ initiatives to the Backlog.” / “Approve all initiatives under the ‘Cloud Migration’ goal.”
• Tool: bulkUpdateInitiatives (criteria: goalId, themeId, roiValue, confidenceLevel, status, isProtected).

3) Scope Trimmer (“Haircut” Tool)

• User intent: “Reduce the scope of all committed initiatives by 10% to fit the plan.”
• Tool: bulkAdjustInitiativeEstimates (adjustmentFactor scales SDE-year assignments; same criteria options as above).

4) Org Restructurer (Advanced)

• User intent: “Move all teams from John Doe to Jane Smith.”
• Tool: bulkReassignTeams (moves all teams from one SDM to another).

Safety checks

• Bulk operations can be destructive; the agent surfaces an impact summary before running (e.g., “Reducing capacity for 15 teams”).
• Plans are shown to the user before execution; review the description to confirm scope.

Example scenarios

• Scenario A: “Austerity” Plan — “Increase overhead to 10 hours/week for everyone and move all ‘Low’ confidence initiatives to the backlog.”
  • Plan: bulkUpdateTeamCapacity({ avgOverheadHoursPerWeekPerSDE: 10 }) + bulkUpdateInitiatives({ status: 'Backlog' }, { confidenceLevel: 'Low' })
• Scenario B: “AI Boost” — “Assume 20% productivity gain for all teams.”
  • Plan: bulkUpdateTeamCapacity({ aiProductivityGainPercent: 20 })

Here's a transcript of the chat - using AI agent to tweak the year plan: