Antigravity Case Study: How a SaaS Company Rebuilt Its Help Center with 300 AI-Generated Articles

The Problem: A Help Center That Created More Tickets Than It Solved

A B2B SaaS company with 4,000 customers and a product management platform had a help center problem. Their knowledge base contained 85 articles — written sporadically over 3 years by different team members with no style guide. The articles varied wildly in quality: some were detailed and current, others were outdated screenshots of a UI that no longer existed, and many skipped critical steps that new users needed.

The measurable impact:

• 42% of support tickets were questions already answered (badly) in the help center
• Average customer satisfaction for self-service: 2.8/5.0
• Bounce rate on help center: 68% (customers arrived, could not find answers, left to submit a ticket)
• Help center search success rate: 31% (7 out of 10 searches returned no useful result)

The support team of 8 agents spent most of their time answering repetitive questions that a good help center would have prevented. The head of support calculated that 42% of tickets at $15 average handling cost meant the company was spending approximately $180,000 per year on tickets that self-service should have handled.

The company needed to rebuild the help center from scratch — not 85 articles, but 300+ covering every feature, workflow, integration, and common question. At a traditional writing pace (2-3 articles per day per writer), this would take one dedicated technical writer 4-5 months. They did not have a dedicated technical writer.

The Antigravity Approach

Phase 1: Content Audit and Gap Analysis (Week 1)

The team started by mapping every support ticket from the past 12 months to identify what the help center should cover:

Ticket analysis (12 months, 14,400 tickets):
1. Getting started / onboarding: 23% (3,312 tickets)
2. Feature how-to questions: 31% (4,464 tickets)
3. Integration setup: 14% (2,016 tickets)
4. Account/billing: 11% (1,584 tickets)
5. Bug reports: 8% (1,152 tickets)
6. Feature requests: 7% (1,008 tickets)
7. API/developer questions: 6% (864 tickets)

Categories 1-4 (79% of tickets) were documentation problems — the information existed somewhere but was not accessible in the help center. Category 5-7 (21%) required human support regardless.

The team created an article list: 300 articles organized into 15 categories, with each article defined by title, target audience, and the support tickets it should prevent.

Phase 2: Voice Training and Template Design (Week 2)

The team trained Antigravity on their best existing support content:

• 15 well-written help articles (from the existing 85)
• 30 highly-rated support email responses
• Product documentation excerpts (for accuracy)
• Brand voice guidelines

The resulting voice profile captured:

• Second person address (“You can…” not “Users can…”)
• Active voice, present tense
• Short paragraphs (2-3 sentences maximum)
• Step numbering for procedures (1, 2, 3, not bullets)
• Technical terms explained on first use
• No assumptions about user expertise
• Consistent terminology (same feature names as the product UI)

They created 5 article templates:

Template 1: How-To (procedural)
Structure: Goal statement → Prerequisites → Steps → Result → Troubleshooting

Template 2: Concept Explanation
Structure: What is [feature] → Why use it → How it works → Example → Related features

Template 3: Integration Setup
Structure: Prerequisites → Authentication → Configuration → Testing → Common issues

Template 4: Troubleshooting
Structure: Symptom → Possible causes → Solution for each cause → When to contact support

Template 5: FAQ
Structure: Question → Short answer → Detailed explanation (expandable) → Related articles

Phase 3: Bulk Generation (Weeks 3-5)

The team generated articles in batches of 20, organized by category:

Week 3: Getting started and core features (100 articles)

For each article, the generation prompt followed this structure:

"Write a help center article for [Product Name].

Article: [title]
Template: [how-to / concept / integration / troubleshooting / FAQ]
Category: [category]
Audience: [new user / experienced user / admin / developer]

The article should help users who would otherwise submit
a support ticket asking: [sample ticket question]

Product context:
- [Feature name] is accessed from [location in UI]
- [Feature] does [what it does]
- Common mistakes: [list of common errors]
- Related features: [list]

Requirements:
- Include numbered steps for any procedure
- Include screenshots placeholders: [Screenshot: description]
- Include a 'Troubleshooting' section at the end
- Include 'Related articles' links at the bottom
- Maximum 800 words (users scan, they don't read)
- Use the exact feature names from our product UI"

Week 4: Integrations and advanced features (100 articles)

Week 5: Account management, API docs, and edge cases (100 articles)

Production rate: 20 articles per day (generation + initial review). Two team members handled the process — one wrote prompts and generated, the other reviewed output.

Phase 4: Quality Review and Publication (Week 6)

Every article went through a three-step review:

1. Accuracy review by product team (5 minutes per article): Does the article correctly describe the product? Are the steps in the right order? Are feature names correct?

2. Support team review (3 minutes per article): Would this article answer the corresponding support ticket? Is anything missing that customers commonly ask?

3. Screenshot addition (10 minutes per article): Replace [Screenshot] placeholders with actual product screenshots. This was the most time-consuming step and was done by the support team.

Total review and enhancement time: approximately 18 minutes per article. For 300 articles: 90 hours of review work, spread across 5 team members over one week.

Results After 90 Days

Support Ticket Reduction

The 35% ticket reduction was achieved because:

• Customers found answers before submitting tickets (self-service success)
• Support agents linked to help articles instead of writing explanations (faster resolution)
• Onboarding tickets dropped 52% (the getting-started articles were comprehensive)

Help Center Performance

Cost Impact

Support cost savings:
420 fewer tickets/month x $15/ticket = $6,300/month = $75,600/year

Help center build cost:
Antigravity subscription: $499/month x 2 months = $998
Team time (generation + review): 180 hours x $40/hour = $7,200
Total build cost: $8,198

Payback period: 1.3 months
Year 1 ROI: 822%

Support Team Impact

With 35% fewer tickets, the 8-person support team was not reduced — they were redeployed:

• 3 agents continued on ticket support (handling the remaining 780 tickets/month)
• 2 agents moved to proactive customer success (onboarding calls, health checks)
• 2 agents focused on help center maintenance and improvement
• 1 agent was promoted to lead a new “customer education” initiative (webinars, tutorials)

The head of support noted: “We didn’t save headcount — we invested the capacity in activities that actually prevent churn.”

Maintaining the Knowledge Base

Ongoing Content Pipeline

After the initial build, the team established a maintenance workflow:

Weekly:
- Review new support tickets for documentation gaps
- Generate 2-3 new articles for emerging questions
- Update 2-3 existing articles flagged as outdated

Monthly:
- Review article performance (lowest-rated, highest-bounce)
- Regenerate or rewrite underperforming articles
- Add articles for new features from the product release

Quarterly:
- Full audit of all 300+ articles against current product UI
- Remove or merge redundant articles
- Update screenshot-heavy articles after UI changes
- Review search analytics for terms with no matching articles

Product Release Integration

The team integrated article generation into the product release cycle:

Release workflow:
1. Product team finalizes feature documentation (internal)
2. 2 weeks before release: generate help center articles
   for new features using Antigravity
3. 1 week before release: product team reviews articles
4. Release day: publish articles simultaneously with feature
5. 1 week after release: review early support tickets for
   gaps, generate additional articles if needed

This ensured that every new feature had help documentation on launch day — something the company had never achieved before.

What Went Wrong

Problem 1: Outdated Screenshots Created Confusion

When the product UI was updated 3 months after the help center rebuild, 40% of articles contained screenshots of the old UI. Customers following steps saw different screens than the screenshots showed, leading to confusion and new support tickets.

Fix: The team implemented a screenshot tracking system — each article was tagged with the product version its screenshots matched. When a UI update shipped, a report identified all articles needing screenshot updates. The team prioritized high-traffic articles first.

Problem 2: Some Articles Were Too Generic

Antigravity-generated articles occasionally provided correct but generic advice. An article about “How to set up integrations” described the general process but missed integration-specific nuances (e.g., Salesforce integration required different OAuth settings than the general flow).

Fix: For integration articles, the team added integration-specific context to the generation prompt (API documentation, known quirks, common error messages). The regenerated articles were significantly more specific and useful.

Problem 3: SEO Cannibalization

Several help center articles started ranking in Google for product-related keywords, competing with marketing landing pages. A help article about “project management features” outranked the product’s feature page.

Fix: Added noindex tags to help center articles that were cannibalizing marketing pages. Adjusted the remaining articles’ titles to be more specific (“How to create a project timeline in [Product]” rather than “Project Management Features”).

Lessons for Other SaaS Companies

Map Tickets Before Writing Articles

The ticket analysis determined which articles would have the most impact. Without it, the team would have written articles based on feature importance (what they thought mattered) rather than customer need (what actually drove tickets).

Templates Ensure Consistency at Scale

300 articles written without templates would vary wildly in structure and quality. The 5 templates ensured every article followed a predictable structure that customers could navigate quickly.

Screenshots Are the Bottleneck

Article text generation was fast. Screenshot creation was slow. If the team could change one thing, they would have started the screenshot process earlier, in parallel with article generation.

Maintenance Is as Important as Creation

A help center that is not maintained becomes a help center that creates tickets instead of solving them. The ongoing maintenance workflow (weekly gap-filling, monthly quality review, quarterly audit) is not optional — it is what keeps the 35% ticket reduction sustained.

Frequently Asked Questions

How long did the entire project take?

6 weeks from start to live help center. Week 1: audit. Week 2: voice training and templates. Weeks 3-5: generation. Week 6: review and publication.

Can non-technical staff use Antigravity for this?

Yes. The support team wrote the generation prompts based on their knowledge of customer questions. They did not need to understand the product’s code — they understood the product’s features and customer workflows.

What about accuracy for technical documentation?

AI-generated help articles must be reviewed by someone who knows the product. Antigravity produces well-structured drafts, but a product team member must verify that steps are correct, feature names are accurate, and edge cases are addressed.

How many articles does a typical SaaS help center need?

A rough formula: (number of features x 3) + (number of integrations x 2) + (50 for account/billing/general). A product with 50 features and 20 integrations needs approximately 240 articles. More complex products need more.

Should we use Antigravity or ChatGPT for this?

Antigravity’s advantage is brand voice consistency across hundreds of articles. If all 300 articles need the same tone, terminology, and structure, Antigravity’s voice training produces more consistent results than manually prompting ChatGPT for each article. For a one-off article, either tool works.