We needed to redesign our website. The old design had grown messy. It no longer reflected our services in a clear way. Instead of hiring an agency, I decided to try a different route. I used modern LLM tools and rebuilt/redesigned the site myself.
Step 1: Pull the Website into Figma
I started by downloading the current website into Figma. I used a licensed version so I could access Figma Make. That gave me the freedom to redesign the structure while keeping what still worked. Inside Figma:
- Cleaned up layouts
- Removed and updated outdated sections
- Added new service pages
- Adjusted the visual hierarchy
This part felt natural. Figma is visual and you see the structure. You move blocks and change is immediate. Figma isn’t the easiest tool either. The real shift came when coding was needed.
Step 2: From Design to Code with Google’s Antigravity
To generate the code I used Google’s Antigravity. The idea was simple: connect design to implementation and let the LLM handle most of the boilerplate.
In practice simplicity disappeared. I had to:
- Set up Antigravity and connect it to our Github and pipelines
- Configure IDs and permissions
- Install coding languages etc.
- Connect it to Figma via MCP integration
- Redo design in Figma
I did not know the setup process at first. LLMs and colleagues helped me through it step by step. Without colleagues’ guidance I would have stopped early. Once connected I started generating the frontend code from the Figma designs.
The Reality of “Vibe Coding”
LLM-driven development works on simple apps without too much legacy. In smaller environments for people who are just starting. It does not work on autopilot.
A few hard lessons became clear:
Prompting is critical The quality of output depends on how clearly you define structure, constraints and intent. If the prompt is vague, the result is vague. If the context is missing, the architecture drifts and you burn through your quota of credits. Did that often.
Refactoring is unavoidable Generated code rarely fits perfectly into a production setup. I had to refactor large parts so the site would run smoothly and stay maintainable. (Ever heard of the term AI slop?)
Multilingual adds complexity Our site supports multiple languages. That added edge cases in routing, content structure and layout consistency. Uniform design across languages required extra adjustments for links to work and content being added from correct sources.
Integration friction is real Even with MCP integration between Figma and Google’s Antigravity things broke. Often. Some outputs failed without clear error messages. Troubleshooting took time. For some issues I couldn’t get fixed no matter how hard I tried. I am not a complete beginner in the world of development but clearly not experienced enough.
This was not magic. It was iterative and sometimes slow with evenings spent in flow state to get things working.
Current Status
The output is now “kind of OK.” The new website structure works (analytics will tell the truth). The new service pages are in place. The core design is aligned and added some flourish to certain elements.
But there is still work ahead:
- Performance and ongoing refactoring
- Cleaner component structure
- More consistent design tokens
- Better multilingual handling
A website is never a finished product. It is a system under constant improvement.
What I Learned
Modern LLM tools can accelerate development. They reduce boilerplate and help with setup friction. They are strong when given precise instructions and enough context. More on limitations later on our blog.
But they do not replace:
- Architectural thinking
- Clear requirements
- System-level consistency
- Testing and validation needs (Still gotta learn how to build tests. Now it was all manual)
You still need to think like an engineer. The difference is that now, the CEO can sit in that role and directly shape the system. With the system I mean website as all our other people are allocated to client work.
LLM’s aren’t a silver bullet nor are they up to the task of bleeding edge where creativity is needed. It’s a good workhorse but a bad master.
What happened after few days
Thinking small changes to the website would be contained and wouldn’t need too much work. I wanted to add a new blog post with table layout we didn’t have yet. Colleague asked Claude what I had done. Claude replied with the following explanation:
Very sassy to say the least. Irony being that blog post I published is about discipline in the age of AI and agentic development. Read it here: The Socio-Technical Architecture of Extreme Programming: Foundations, Philosophical Roots and the Agentic Future
