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.csshad 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.cssfrom 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 missinggenerateEngineerTablefunction. 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
d3ebd4fhappened 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
- Respect the Legacy: Don't delete code you don't understand until you're sure you don't need it.
- Commit Often, Even the Broken Stuff: Those "broken" commits saved us. They gave us a checkpoint when we needed to backtrack.
- 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.
- 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 anasyncfunction.
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
No comments:
Post a Comment