Docs-as-Code with AI: The DocuWriter.ai approach

Traditional docs-as-code is powerful but requires constant manual work. Every code change means manually updating Markdown files, reviewing documentation PRs, and rebuilding sites. DocuWriter.ai transforms docs-as-code by adding AI automation—keeping all the benefits of version control and Markdown while eliminating the manual documentation burden.

What is Docs-as-Code?

Docs-as-code is a documentation philosophy that applies software development practices to documentation: store docs in version control, write in plain text formats, review through pull requests, build automatically, and deploy via CI/CD pipelines.

Instead of documentation living in separate tools like Confluence or SharePoint, docs-as-code means:

• Documentation files live in your Git repository alongside code
• Written in plain text formats like Markdown (not WYSIWYG editors)
• Versioned with Git - every change tracked, branched, and merged like code
• Reviewed via pull requests - documentation changes go through code review
• Built and deployed automatically - CI/CD pipelines generate sites from source files
• Single source of truth - docs and code stay in sync because they live together

The problem with traditional documentation tools: They live in separate systems, require context switching, become outdated quickly, and have no connection to the code they document.

The docs-as-code solution: Documentation becomes part of your development workflow, making it easier to write, maintain, and keep current.

DocuWriter.ai: Docs-as-Code with AI: All the benefits of docs-as-code (Git integration, Markdown, versioning) PLUS artificial intelligence that automatically generates and maintains documentation from your code. Traditional docs-as-code requires manual writing; DocuWriter.ai automates it.

The Problem: Traditional Docs-as-Code is Still Manual

While docs-as-code is better than Confluence-style documentation, it still has a fundamental problem: you have to manually write everything.

Manual Writing is Time-Consuming

Even with Markdown in Git, someone still needs to:

• Write initial documentation from scratch
• Document every function, API, and process
• Update docs when code changes
• Remember which docs need updating after code changes

This takes hours of developer time every week.

Documentation Still Falls Behind Code

Docs-as-code stores documentation with code, but it doesn’t keep docs in sync with code. When a developer changes a function signature, they still need to:

1. Remember the documentation exists
2. Find the relevant docs file
3. Update it manually
4. Hope they updated everything affected by the change

Result: Even docs-as-code documentation becomes outdated.

Onerous for Developers

Developers love Git workflows, but they hate writing documentation. Traditional docs-as-code still requires developers to manually document everything, which feels like a chore that takes time away from coding.

The Solution: DocuWriter.ai = Docs-as-Code + AI Automation

DocuWriter.ai brings artificial intelligence to docs-as-code, automating the parts developers hate while keeping all the benefits they love.

What DocuWriter.ai Adds to Docs-as-Code

Traditional docs-as-code:

1. ✅ Store documentation as Markdown in Git
2. ✅ Version control for docs
3. ✅ Review via pull requests
4. ✅ Build and deploy automatically
5. ❌ Manual writing of all documentation
6. ❌ Manual updates when code changes

Docs-as-code with DocuWriter.ai:

1. ✅ Store documentation as Markdown in Git
2. ✅ Version control for docs
3. ✅ Review via pull requests
4. ✅ Build and deploy automatically
5. ✅ AI generates initial documentation from code
6. ✅ Automatic updates when code changes (repository sync)

The difference: DocuWriter.ai automates documentation generation and maintenance while keeping the Git-based workflow developers love.

How DocuWriter.ai Works: Intelligent Docs-as-Code

1. Store Documentation in Your Repository

Like traditional docs-as-code, documentation lives in your Git repository:

your-repo/
├── docs/
│   ├── api/
│   │   ├── authentication.md
│   │   ├── users.md
│   │   └── posts.md
│   ├── guides/
│   │   ├── deployment.md
│   │   └── testing.md
│   └── README.md
├── src/
│   └── api/
│       ├── users.py
│       └── posts.py
└── scripts/
    └── deploy.sh

DocuWriter.ai difference: These Markdown files are automatically generated and maintained, not manually written.

2. Automatic Documentation Generation from Code

Instead of manually writing docs/api/users.md, DocuWriter.ai analyzes src/api/users.py and generates comprehensive documentation automatically.

Example: Your code:

@app.route('/api/users/<int:user_id>', methods=['GET'])
@require_auth
def get_user(user_id):
    """Retrieve user by ID."""
    user = User.query.get_or_404(user_id)
    return jsonify(user.to_dict())

DocuWriter.ai generates docs/api/users.md:

# Users API

## GET /api/users/{user_id}

Retrieve user by ID.

### Authentication Required
Yes - Bearer token required in Authorization header.

### Path Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| user_id | integer | Yes | User's unique identifier |

### Response

**200 OK** - Returns user object

**404 Not Found** - User with specified ID does not exist

**401 Unauthorized** - Missing or invalid authentication token

### Example Request
```bash
curl -X GET https://api.example.com/api/users/123 \
  -H "Authorization: Bearer YOUR_TOKEN"

Response:

{
  "id": 123,
  "name": "John Doe",
  "email": "john@example.com",
  "created_at": "2025-01-17T10:30:00Z"
}

Time savings: What takes an hour to write manually is generated in seconds.

3. Repository Sync: Automatic Updates When Code Changes

This is DocuWriter.ai’s superpower: when your code changes, documentation automatically updates.

How it works:

1. Developer modifies code and pushes to repository
2. DocuWriter.ai’s webhook receives push notification
3. Analyzes Git diff to identify what changed
4. Determines if changes affect documentation
5. Updates relevant documentation files
6. Creates pull request with updated docs for review

Example: You add a new query parameter to the API:

@app.route('/api/users/<int:user_id>', methods=['GET'])
@require_auth
def get_user(user_id, include_posts=False):  # New parameter
    user = User.query.get_or_404(user_id)
    if include_posts:  # New functionality
        user.posts = Post.query.filter_by(user_id=user_id).all()
    return jsonify(user.to_dict())

DocuWriter.ai automatically updates documentation:

### Query Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| include_posts | boolean | No | Include user's posts in response |

PR created by DocuWriter:

Title: Update users API docs - Added include_posts parameter

Changes detected in src/api/users.py (lines 23-28):
- Added include_posts optional parameter
- New functionality to include user's posts

Documentation updated in docs/api/users.md:
- Added include_posts query parameter documentation
- Updated example requests

Manual work required: Review and merge PR (1 minute). Documentation writing and maintenance: Zero.

Learn more about Repository Sync →

4. Git-Based Review Workflow

Documentation updates go through the same code review process as code changes:

• DocuWriter creates branch with documentation updates
• Opens pull request for team review
• Reviewers check accuracy and completeness
• Approve and merge when satisfied
• CI/CD deploys updated documentation

Benefits:

• Quality control on documentation changes
• Team visibility into documentation updates
• Git history of all documentation changes
• Roll back documentation if needed

5. Automated Deployment

Because documentation is in Git, it integrates with your CI/CD pipeline:

# .github/workflows/docs.yml
name: Deploy Documentation
on:
  push:
    branches: [main]
    paths: ['docs/**']
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build documentation site
        run: mkdocs build
      - name: Deploy to GitHub Pages
        run: mkdocs gh-deploy

Every documentation update automatically deploys to your documentation site. No manual steps required.

Why DocuWriter.ai is Superior to Traditional Docs-as-Code

Traditional Docs-as-Code Tools (GitBook, MkDocs, Docusaurus)

GitBook, MkDocs, and Docusaurus are popular docs-as-code platforms. They provide:

• Markdown storage in Git ✅
• Static site generation ✅
• Pretty documentation websites ✅
• Version control ✅

What they DON’T provide:

• Automatic documentation generation from code ❌
• Synchronization when code changes ❌
• Intelligence about your codebase ❌

With these tools, you still manually write everything. They just store it in Git and make it look nice.

DocuWriter.ai: Intelligent Docs-as-Code

DocuWriter.ai includes everything traditional tools provide PLUS:

✅ Automatic generation from code (saves 80% of initial work) ✅ Repository sync keeps docs current (saves 95% of maintenance work) ✅ Code understanding across 10+ programming languages ✅ API documentation generated from route definitions ✅ Process documentation generated from scripts and configs ✅ Database schema docs from migrations and models

Comparison:

Bottom line: Traditional docs-as-code tools are just storage and rendering. DocuWriter.ai is storage, rendering, AND intelligence.

Confluence/Notion vs DocuWriter.ai

Traditional documentation platforms (Confluence, Notion) fail at docs-as-code entirely:

Confluence/Notion:

• ❌ Documentation separate from code
• ❌ No Git integration
• ❌ No version control
• ❌ Manual writing and maintenance
• ❌ Context switching required
• ❌ Expensive per-user pricing

DocuWriter.ai:

• ✅ Documentation in repository with code
• ✅ Native Git integration
• ✅ Full version control
• ✅ Automatic generation and maintenance
• ✅ Developer-friendly workflow
• ✅ Usage-based pricing

For development teams, there’s no comparison. DocuWriter.ai fits developer workflows while automating the tedious parts.

Implementing Docs-as-Code with DocuWriter.ai: Complete Guide

Step 1: Set Up Documentation Directory

Create a /docs directory in your repository:

mkdir -p docs/{api,guides,reference}
cd docs

Organize by content type:

• /docs/api/ - API endpoint documentation
• /docs/guides/ - User guides and tutorials
• /docs/reference/ - Technical reference material

DocuWriter.ai will populate these directories automatically based on your codebase structure.

Step 2: Connect DocuWriter.ai to Repository

1. Sign up at app.docuwriter.ai
2. Connect GitHub, GitLab, or Bitbucket
3. Select repository to document
4. Grant DocuWriter read/write access (for generating docs and creating PRs)

Time: 2 minutes

Step 3: Generate Initial Documentation

In DocuWriter.ai dashboard:

1. Click “Generate Documentation”
2. Select what to document:
   • ☑ API endpoints
   • ☑ Functions and classes
   • ☑ Database schema
   • ☑ Configuration files
   • ☑ Deployment scripts
3. Choose documentation style (OpenAPI, narrative, reference)
4. Click “Generate”

DocuWriter analyzes your code and creates comprehensive Markdown documentation in your /docs directory.

Time: 2-5 minutes (depending on codebase size)

Result: A pull request titled “Initial documentation generation” with comprehensive docs.

Step 4: Review and Merge Initial Documentation

Review the generated documentation:

• Check accuracy of automatically generated content
• Add human context where beneficial (design decisions, gotchas, business logic)
• Fix any errors or unclear sections
• Approve and merge

Time: 10-30 minutes review time

Your docs-as-code foundation is complete.

Step 5: Enable Repository Sync

Turn on automatic synchronization:

In DocuWriter.ai Settings → Repository Sync:

1. Enable “Automatic documentation updates”
2. Configure sync behavior:
   • Automatic PRs (recommended): DocuWriter creates PRs for review
   • Direct commits: Auto-commit to main (for trusted automation)
   • Notifications only: Alert when updates needed
3. Set sync triggers:
   • ☑ Sync on push to main branch
   • ☑ Sync on pull request creation
   • ☑ Sync on tagged releases
4. Choose documentation scope:
   • ☑ API documentation
   • ☑ Function/class documentation
   • ☑ Configuration files
   • ☑ Database schema
   • ☑ Process documentation

Repository sync is now active. When code changes, DocuWriter automatically updates documentation.

Step 6: Set Up Documentation Website (Optional)

Make documentation accessible as a website using a static site generator.

Option 1: Use DocuWriter.ai’s Built-in Hosting (Easiest)

In DocuWriter.ai dashboard:

1. Go to Settings → Hosting
2. Enable “DocuWriter Hosting”
3. Choose subdomain: yourproject.docuwriter.dev
4. Select theme and customization
5. Click “Deploy”

Result: Documentation live at https://yourproject.docuwriter.dev with automatic updates when docs change.

Option 2: Self-Host with MkDocs

Install MkDocs:

pip install mkdocs mkdocs-material

Create mkdocs.yml:

site_name: My Project Documentation
theme:
  name: material
  palette:
    primary: indigo
nav:
  - Home: index.md
  - API Reference: api/
  - Guides: guides/

Deploy to GitHub Pages:

mkdocs gh-deploy

Option 3: Self-Host with Docusaurus

Install Docusaurus:

npx create-docusaurus@latest website classic

Configure to use /docs as content source.

Recommendation: Start with DocuWriter.ai’s built-in hosting for zero-config deployment. You can always switch to self-hosted later.

Step 7: Integrate with CI/CD

Add documentation deployment to your CI/CD pipeline:

GitHub Actions example:

# .github/workflows/docs.yml
name: Documentation
on:
  push:
    branches: [main]
    paths: ['docs/**']

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Deploy to DocuWriter.ai
        run: |
          curl -X POST https://api.docuwriter.ai/deploy \
            -H "Authorization: Bearer ${{ secrets.DOCUWRITER_TOKEN }}" \
            -d '{"repo": "${{ github.repository }}"}'

Result: Every docs change automatically deploys to your documentation site.

Docs-as-Code Best Practices with DocuWriter.ai

1. Store Docs Close to Code

Keep documentation near the code it documents:

/src/api/users.py
/docs/api/users.md  ← Document the API

DocuWriter.ai automatically creates this logical organization based on your codebase structure.

2. Use Consistent Markdown Structure

DocuWriter.ai generates documentation with consistent structure:

# [Component Name]

## Overview
Brief description

## Usage
How to use with examples

## API Reference
Detailed function/endpoint documentation

## Examples
Real-world usage examples

## Troubleshooting
Common issues and solutions

This consistency makes documentation predictable and easy to navigate.

3. Let AI Handle the “How”, Humans Add the “Why”

DocuWriter.ai excels at documenting “how” (parameters, responses, code structure). Humans should add “why” (design decisions, business logic, gotchas).

Example:

DocuWriter.ai generates:

## GET /api/users

Returns paginated list of users.

### Parameters
- page (integer): Page number
- per_page (integer): Items per page (max 100)

Human adds context:

## Design Decision: Why We Limit to 100 Items Per Page

We limit pagination to 100 items to prevent database performance issues.
During testing, queries >100 items caused slowdowns on our largest customer
databases. This limit balances usability with performance.

Best of both worlds: AI handles tedious documentation, humans add valuable context.

4. Review DocuWriter.ai’s PRs Carefully

When DocuWriter.ai detects code changes and updates documentation, review the PR:

PR review checklist:

• ☐ Are code changes correctly reflected in docs?
• ☐ Are new parameters/fields documented?
• ☐ Do examples still work?
• ☐ Is additional context needed?
• ☐ Are deprecated features marked as deprecated?

Treat DocuWriter.ai’s PRs like any code PR—thorough review ensures quality.

5. Version Documentation with Code Releases

Tag documentation versions alongside code:

git tag -a v2.0.0 -m "Release 2.0.0"
git push --tags

This creates permanent snapshots of documentation matching code at specific versions. Users can reference docs for older versions if needed.

Example: “How does authentication work in v1.5.0?” → Check out that tag, read the docs.

6. Use Branch-Based Documentation

Create documentation updates in feature branches alongside code changes:

git checkout -b feature/add-pagination

# Make code changes
# DocuWriter detects changes and updates docs in same branch

git push origin feature/add-pagination
# Open PR with both code and doc changes

Result: Code and documentation reviewed together, ensuring they stay in sync.

Real-World Example: Complete Docs-as-Code Setup

Let’s see a complete example of docs-as-code with DocuWriter.ai for a Python Flask API.

Repository Structure

my-api/
├── src/
│   ├── api/
│   │   ├── users.py
│   │   ├── posts.py
│   │   └── auth.py
│   └── models/
│       ├── user.py
│       └── post.py
├── scripts/
│   └── deploy.sh
├── .github/
│   └── workflows/
│       └── deploy.yml
└── docs/  ← DocuWriter.ai generates everything here

DocuWriter.ai Generates

docs/
├── README.md                    # Documentation homepage
├── api/
│   ├── users.md                 # From src/api/users.py
│   ├── posts.md                 # From src/api/posts.py
│   └── authentication.md        # From src/api/auth.py
├── database/
│   ├── user-model.md            # From src/models/user.py
│   └── post-model.md            # From src/models/post.py
└── deployment/
    └── production-deploy.md     # From scripts/deploy.sh + .github/workflows/deploy.yml

Generated documentation example: docs/api/users.md

# Users API

Endpoints for managing users in the system.

## List Users

**GET** `/api/users`

Returns paginated list of users.

### Authentication
Required - Bearer token

### Query Parameters
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| page | integer | 1 | Page number |
| per_page | integer | 20 | Items per page (max 100) |
| sort | string | created_at | Sort field: name, email, created_at |

### Response

**200 OK**
```json
{
  "users": [
    {
      "id": 1,
      "name": "John Doe",
      "email": "john@example.com",
      "created_at": "2025-01-15T10:30:00Z"
    }
  ],
  "total": 50,
  "page": 1,
  "per_page": 20,
  "pages": 3
}

Example

curl -X GET "https://api.example.com/api/users?page=1&per_page=20" \
  -H "Authorization: Bearer YOUR_TOKEN"

Get User by ID

GET /api/users/{user_id}

Retrieve specific user by unique identifier.

Authentication

Required - Bearer token

Path Parameters

Response

200 OK - Returns user object

404 Not Found - User does not exist

401 Unauthorized - Invalid or missing authentication

Example

curl -X GET "https://api.example.com/api/users/123" \
  -H "Authorization: Bearer YOUR_TOKEN"

This documentation is automatically generated and maintained by DocuWriter.ai Last updated: 2025-01-17 from src/api/users.py

### Automatic Updates in Action

**Developer adds new endpoint:**

```python
@app.route('/api/users/<int:user_id>/posts', methods=['GET'])
@require_auth
def get_user_posts(user_id, limit=10):
    """Get posts by user."""
    posts = Post.query.filter_by(user_id=user_id).limit(limit).all()
    return jsonify([p.to_dict() for p in posts])

DocuWriter.ai detects change and creates PR:

Title: Update users API docs - Added get user posts endpoint

Files changed:
  src/api/users.py (+8 lines)
  docs/api/users.md (+25 lines)

Documentation added:
- New endpoint: GET /api/users/{user_id}/posts
- Parameters, authentication, examples

**Manual work:** Review PR (1 minute), merge. **Documentation work: Zero.**

## Why Choose DocuWriter.ai for Docs-as-Code

### 1. Saves Massive Amounts of Time

**Traditional docs-as-code:**
- Initial documentation: 40-80 hours
- Ongoing maintenance: 2-4 hours/week
- **Annual cost:** $15,000-$30,000 in engineering time

**DocuWriter.ai:**
- Initial setup: 10 minutes
- Ongoing maintenance: Automated
- **Annual cost:** ~$3,000 subscription
- **Net savings:** $12,000-$27,000/year

**Plus:** Better documentation quality and developer satisfaction.

### 2. Documentation Always Stays Current

Traditional docs-as-code still requires manual updates. DocuWriter.ai ensures accuracy through automatic synchronization—docs update when code changes, without manual effort.

### 3. Superior Developer Experience

Developers love Git workflows but hate writing documentation. DocuWriter.ai gives them the Git workflow they love while eliminating the documentation writing they hate.

### 4. Fits Modern Development Practices

- Git-based version control ✅
- Pull request reviews ✅
- CI/CD integration ✅
- Markdown format ✅
- Automated workflows ✅

DocuWriter.ai embraces modern development practices completely.

### 5. Better ROI Than Any Alternative

**Confluence/Notion:** Expensive, requires manual work, poor developer experience

**Traditional docs-as-code (GitBook, MkDocs):** Still requires manual writing and maintenance

**DocuWriter.ai:** Automated generation and maintenance with Git-based workflow

**Clear winner for development teams.**

<div class="mt-16 p-8 rounded-2xl bg-gradient-to-br from-green-500/10 to-blue-500/10 border border-green-500/20">
  <div class="text-center">
    <h3 class="text-2xl font-bold text-white mb-4">
      Docs-as-Code, Powered by AI
    </h3>
    <p class="text-vulcan-300 mb-6 max-w-2xl mx-auto">
      Get all the benefits of docs-as-code (Git integration, Markdown, version control) plus AI that automatically generates and maintains your documentation. Stop writing docs manually—let DocuWriter.ai automate it.
    </p>
    <div class="flex flex-col sm:flex-row gap-4 justify-center mb-8">
      <a href="https://app.docuwriter.ai/signup"
         class="inline-flex items-center justify-center px-6 py-3 rounded-lg bg-green-500 text-white font-semibold hover:bg-green-600 transition-colors">
        Start Free Trial
        <svg class="ml-2 w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
          <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 7l5 5m0 0l-5 5m5-5H6"></path>
        </svg>
      </a>
      <a href="/features"
         class="inline-flex items-center justify-center px-6 py-3 rounded-lg bg-vulcan-800 text-white font-semibold border border-vulcan-700 hover:border-green-500/30 transition-colors">
        See How It Works
      </a>
    </div>
    <p class="text-sm text-vulcan-400">
      Free 14-day trial • 5-minute setup • No credit card required
    </p>
  </div>
</div>

## Frequently Asked Questions

### How is DocuWriter.ai different from GitBook or MkDocs?

GitBook and MkDocs are static site generators—they render Markdown documentation into websites. You still manually write all documentation.

DocuWriter.ai is an **intelligent documentation platform** that uses AI to automatically generate documentation from your code, then renders it into beautiful websites. It includes generation, maintenance, and rendering—not just rendering.

**Comparison:**
- **GitBook/MkDocs:** Store and display manually-written docs
- **DocuWriter.ai:** Generate, maintain, store, and display automatically-created docs

### Can I use DocuWriter.ai with my existing docs-as-code setup?

Yes! If you already have Markdown documentation in your repository:
1. DocuWriter.ai preserves your existing documentation
2. Adds automatically-generated documentation alongside it
3. Maintains both human-written and AI-generated docs
4. You decide which parts to automate and which to keep manual

**Migration is non-destructive**—your existing docs remain untouched.

### What if I need to customize AI-generated documentation?

DocuWriter.ai creates pull requests for documentation changes. Before merging:
- Review generated content
- Edit directly in the PR
- Add human context and explanations
- Approve when satisfied

**You have full control** over final documentation content.

### Does DocuWriter.ai work with non-technical documentation?

DocuWriter.ai excels at **technical documentation** (APIs, code, processes, deployment). For non-technical content (marketing, HR policies), you can:
- Write manually in your docs-as-code repository
- Use DocuWriter.ai to maintain technical sections
- Keep non-technical docs in traditional tools if preferred

**Best approach:** DocuWriter.ai for technical docs, manual writing for non-technical content.

### How long does the migration to DocuWriter.ai take?

**Initial setup:** 10 minutes
1. Connect repository (2 minutes)
2. Configure what to document (3 minutes)
3. Generate initial documentation (2-5 minutes)
4. Enable repository sync (1 minute)

**Review and refinement:** 1-2 hours
- Review AI-generated documentation
- Add human context where beneficial
- Customize structure if desired

**Total:** Half a day to fully migrate to automated docs-as-code.

### Can I self-host DocuWriter.ai?

**Cloud version:** Easiest option, zero infrastructure management

**Self-hosted:** Available for enterprise customers with specific requirements (data residency, air-gapped environments, compliance)

**Most teams prefer cloud** for simplicity, but self-hosted options exist.

### What happens if DocuWriter.ai generates incorrect documentation?

Rare, but possible. When it happens:
1. DocuWriter creates PR with documentation changes
2. You review in PR (don't auto-merge blindly)
3. Edit incorrect sections directly in PR
4. Provide feedback to improve future generation
5. Merge when satisfied

**Quality control is built into the workflow** through PR reviews.

### How does pricing compare to traditional docs-as-code tools?

**Traditional docs-as-code (GitBook, MkDocs):**
- Tool cost: $0-$500/month
- Engineering time: $15,000-$30,000/year
- **Total:** $15,000-$30,500/year

**DocuWriter.ai:**
- Subscription: ~$3,000/year
- Engineering time saved: 80-95%
- **Effective cost:** $3,000/year with better results

**DocuWriter.ai provides 10x ROI** through automation.

## Related Resources

- [Repository Sync](/repository-sync) - How automatic synchronization works
- [Process Documentation Guide](/guides/process-documentation) - Automate deployment docs, runbooks
- [Compare with GitBook](/compare/docuwriter-gitbook-alternative) - Detailed comparison
- [API Documentation](/features/api-documentation) - Automatic API doc generation
- [Get Started](/signup) - Begin your docs-as-code journey with AI