Back in September 2025, we published Building Alpha Bits Website with AI-Powered Workflows, a walkthrough of the stack behind this website: Svelte 5, Directus, and Trae IDE with Model Context Protocol (MCP) integrations. Readers kept asking for a follow-up, so here it is.
Six months later the site is still built on the same open-source base, but most of what surrounds it has changed. We've written this update for technical decision-makers who want the architecture details and for non-technical leaders who want to see what AI-assisted development looks like in production.
What stayed the same
The foundation we described in September is still in place. The frontend is Svelte 5 and SvelteKit, which gives us compiled reactivity, server-side rendering and no virtual-DOM overhead. Everything is open source and visible at github.com/AlphaBitsCode/studio-os.
Both choices have held up. Our Lighthouse scores are still consistently high, and the site deploys in under a minute.
What changed
1. TailwindCSS v4 for the design system
We moved from hand-rolled CSS to TailwindCSS v4 with the @tailwindcss/typography and @tailwindcss/forms plugins. Together with bits-ui, a Svelte-native component library built on Radix primitives, this gives us a consistent design system that AI agents find easy to work with. Utility classes are predictable tokens, and language models handle them very well.
2. Goodbye Directus, hello static markdown and SQLite
This was probably our biggest architectural decision: we dropped Directus entirely.
In September, Directus was our self-hosted headless CMS, and all content went through its admin interface. It worked, but it was one more service to maintain, one more attack surface to monitor, and one more dependency that could go down.
We replaced it with two things.
Blog content now lives in static .md files checked directly into Git. Every article on this site, including this one, is a markdown file in our content/blog/ directory, version-controlled alongside the source code. SvelteKit reads these files at build time and processes the markdown with remark. There is no CMS admin panel to breach, no database to inject into and no API endpoint to exploit, so the content is very hard to tamper with. Anyone who wanted to change our articles would need write access to our GitHub repository, which is protected by branch rules, code review and two-factor authentication.
Transactional data goes into SQLite, managed with Drizzle ORM. That covers everything that needs a database: logs of every AI Receptionist chat session, stored so we can query them; newsletter subscriptions collected through forms on the /news page and processed by our API; and lead data (company name, industry and contact details) gathered during live AI conversations.
SQLite gives us relational guarantees and very good performance. Drizzle provides type-safe queries that plug straight into our SvelteKit server functions. The schema is version-controlled, and migrations run with a single drizzle-kit push command.
We removed a whole self-hosted service from our infrastructure and reduced our attack surface, and authoring got easier too. The team writes markdown in whatever editor they prefer, commits through Git, and the site updates on deploy.
3. Groq-powered AI chat for the Receptionist service
The change visitors notice most is our AI Receptionist service. Visitors can have a real-time, 5-minute chat with one of four AI personas (Tim, Clara, Brian or Kamala), each with its own communication style and role.
Under the hood, the Groq SDK provides LLM inference with sub-second response times, fast enough that the chat feels like talking to a person. Server-side API routes in SvelteKit (/api/chat) handle prompt assembly, context injection and response streaming. Each persona has a detailed system prompt that covers personality, objectives, knowledge boundaries and guardrails. The AI learns about visitors through conversation instead of asking them to fill out forms, so details like company name, industry and what they're looking for come up naturally.
The system handles first-contact conversations around the clock while the human team works on other things.
4. Resend for transactional email
We added Resend for transactional email. Newsletter confirmations, lead notifications to our sales team and system alerts all go through Resend's API. Setup took about 15 minutes, which is rare for a developer tool.
5. Playwright for end-to-end testing
Shipping AI features to production without tests is like deploying on a Friday. We added Playwright for browser-level end-to-end tests, alongside Vitest for unit and component tests. Our smoke test suite runs before every deployment, and we recently started writing browser-level component tests with vitest-browser-svelte.
6. Netlify adapter for serverless deployment
We switched our deployment target to Netlify via @sveltejs/adapter-netlify. That gives us serverless rendering for dynamic routes such as the chat API, automatic CDN distribution for static assets, and a deployment pipeline triggered by a single git push. For our usage tier, the annual hosting cost is effectively zero.
The bigger change: agentic development
In September we called MCP integrations "game changers." They still help, but the way we work has changed much more since then.
From MCP to Antigravity in three weeks
Our original workflow used Trae IDE with MCP servers for Directus (our CMS at the time) and Shadcn UI components. That was already a step up, because the AI could query content and suggest components. But it was still prompt and response: we typed an instruction, the AI carried it out, and we reviewed the result.
For most of 2025, our main agentic coding tool was Claude Code, powered by GLM 4.7 and later GLM 5. We put a lot into this setup, building a library of custom skills and adding community-maintained ones from skills.sh. Skills are reusable instruction sets that teach the agent how to do specific tasks in your codebase, such as deployment procedures, testing workflows and component creation patterns. With a well-curated skill library, Claude Code was productive, and we used it to ship most of our HomeLab series and early feature work.
Then, three weeks ago in early February 2026, we switched to Antigravity, Google's agentic coding assistant, on the Google Ultra plan with access to Claude Opus 4.6 and Gemini Pro 3.1. We saw a large improvement right away.
The two models are good at different things. Gemini Pro 3.1 is better for rapid iteration, codebase-wide refactoring and tasks where speed matters. Claude Opus 4.6 is more precise on subtle architecture decisions, complex prompt engineering and code that needs careful reasoning. We switch between them depending on the task, often several times a day.
Here is what the agent does that we couldn't do before. It runs multi-step work on its own: it plans, researches the codebase, writes code across several files, runs tests and iterates on failures in a single workflow. It has native access to the terminal, the file system, browser automation and MCP servers, including Netlify for deployment and Stitch for UI prototyping. Knowledge items from past conversations carry forward, so after three weeks of daily use the agent knows our architecture, coding patterns, design system and even our preferred writing tone without being told again. And it checks its own work in a browser: it opens our running dev server and confirms that changes render correctly before reporting back.
In three weeks we shipped more with this workflow than we would usually manage in a quarter: the whole AI Receptionist service, the white-label CRM dashboard, newsletter subscription flows, blog navigation, email integrations, persona engineering for four AI agents, lead capture logic, Playwright test suites, and this blog post.
What this looks like in practice
A real example from this week: we needed "Previous Article" and "Next Article" buttons on our blog posts, with the next article's title truncated and styled correctly. In the old workflow, a developer would edit the server loader, the Svelte component and the CSS by hand. With Antigravity, we described the requirement in plain language, and the agent:
- Read the existing
+page.server.ts to understand the data model
- Modified the server loader to fetch adjacent posts
- Updated the Svelte template with navigation buttons
- Applied consistent styling using our existing TailwindCSS tokens
- Verified rendering in the browser
The human effort was one prompt and a code review, and the whole thing took under 10 minutes.
How the human role has shifted
For decision-makers, the main point is that AI agents change what developers do rather than replacing them. Our engineers now spend most of their time on architecture decisions (which database, which API pattern, which deployment strategy) and on product direction: what to build, how it should feel and what it does for the business. They review code, since the AI writes the first draft and a person makes sure it meets our quality and security standards. They also write the system prompts and guardrails for our AI agents, both the Receptionist personas and the development agents.
AI increasingly handles the glue work, such as wiring up routes, writing boilerplate and fixing CSS inconsistencies.
What's coming next
We're working on several additions for 2026:
- Paraglide i18n: multi-language support is already in our
package.json and will roll out for Vietnamese and English content soon.
- Cal.com integration: we've started integrating
@calcom/atoms for self-serve meeting booking on the site.
- More AI personas: personas for specific industries (F&B, education, eCommerce), based on our consulting engagements.
- Better analytics: real user monitoring and conversion tracking, beyond basic Lighthouse scores.
What we think this means
If you're evaluating your own web stack, a few things stood out to us.
Running a modern web presence with AI built in now costs close to nothing. Our hosting, database, email and deployment run on free or near-free tiers with open-source tooling.
AI agents are ready for production web development. This is how we build and ship code every day.
The speed compounds. Features that took days now take hours, and the more context the AI builds up about your codebase, the faster later work goes.
Human expertise matters more than before. You still need people who understand architecture, security and performance, and the AI multiplies their output without removing the need for their judgment.
Our repository is open at github.com/AlphaBitsCode/studio-os. Star it if you'd like to follow along as we keep building in the open.