Veritas

Code changes. Docs don’t. Things break. Veritas checks every codebase and PR, flags outdated or missing documentation by opening precise GitHub issues. Silent when correct. Actionable when not.

Comment

Veritas.dev - AI-Powered Documentation Verification

Inspiration

We've all been there: spending hours debugging code, only to discover the documentation was wrong. A function that supposedly takes two parameters actually needs three. The example in the README uses an outdated API. The OpenAPI spec doesn't match the actual endpoints.

This frustration led us to a shocking discovery: $85 billion is lost annually to outdated documentation. Developers waste 17 hours per week on incorrect docs, and 78% of teams don't trust their own documentation.

The breaking point? Watching a junior developer spend an entire day debugging because the docs showed login(email, password) while the code required login(email, password, mfa_token). One missing parameter. Eight wasted hours.

We realized there's an automation gap. Nobody automatically verifies that documentation matches code and finds the differences between the code and the docs.

That's why we built Veritas: an intelligent GitHub App that ensures your documentation never drifts from reality.

What it does

Veritas is an AI-powered GitHub App that automatically detects when code changes don't match documentation, then creates issues to keep everything in sync.

How it works:

  1. Developer creates a PR adding a new feature
  2. GitHub automatically notifies Veritas via webhook
  3. Veritas analyzes the code changes using multi-language parsers
  4. AI compares code signatures with documentation
  5. Veritas posts a issue highlighting any mismatches
  6. Developer reviews and fixes PRs, staying perfectly in sync

Key Features:

Multi-Language Support - Parses Python, JavaScript, TypeScript, Java, Markdown, and OpenAPI specs

AI-Powered Comparison - Uses Gemini 2.5 with the token compnay for semantic analysis, not just string matching

Trust Score - Assigns a 0-100% score showing how accurate your documentation is

Automatic Fixes - Creates issues to correct docs (README, API docs, OpenAPI specs)

How we built it

Architecture

Veritas runs as a cloud-hosted service that integrates with GitHub as an official GitHub App. The pipeline flows through several stages: webhook reception → file fetching → multi-language parsing → AI comparison → trust scoring → automated issue creation.

Technology Stack

Backend: FastAPI, Python, Gemini API, Trae IDE

Frontend: React, Vite, Tailwind CSS, Recharts for analytics

Infrastructure: Deployed on Vercel with serverless functions

Multi-Language Parser System

The heart of Veritas is our parser factory that handles 6 different file types. Each language gets specialized parsing (Python uses AST, JavaScript uses Tree-sitter, Java uses regex patterns), but all return a normalized data structure. This lets the comparison engine work uniformly across languages.

Sponsor Integration

Token Company Bear-1: Compresses analysis context by 60%, reducing costs from $0.15 to $0.006 per analysis (96% savings!)

Trae (ByteDance): Used the AI IDE to write faster code, saving time for better testing and designing

The Comparison Engine

When comparing code to docs, we build a comprehensive prompt showing both the actual function signature and what the documentation claims. Bear-1 compresses this context, we send it to Gemini. The AI identifies mismatches in parameters, types, or descriptions with impressive accuracy.

Challenges we ran into

Parser Accuracy Across Languages

Different languages have wildly different syntax. We solved this with a modular parser factory where each language has its own parser, but all return normalized output. Tree-sitter proved essential for JavaScript/TypeScript, while Python's built-in AST module was surprisingly robust.

LLM Cost Explosion

Initial testing showed analyzing one repository cost $0.15 due to massive context windows. At scale, this meant $150 per 1,000 repos which is unsustainable. Bear-1 compression reduced this to $0.006 per analysis (96% savings), making enterprise deployment economically viable.

Parallel Development

With 4 developers working simultaneously, we could have faced merge hell. Trae's AI IDE helped ship quality code real fast.

Accomplishments that we're proud of

Solved a Real Problem - This isn't a toy. Veritas catches actual documentation drift in production codebases.

Production-Ready - Fully functional GitHub App that creates real issues, works on real repos, and is deployed live.

Multi-Language - Supporting 4 programming languages plus docs formats covers 90%+ of codebases.

What we learned

Cost Optimization is Critical - Bear-1 compression didn't just save money, it made our product viable at scale. Economics shape product design.

GitHub App Model is Powerful - Building as an official GitHub App (like Dependabot) gave us automatic webhooks, built-in auth, and user trust.

Multi-Language is Complex but Valuable - Each language needs different parsing strategies, but real codebases are polyglot. The effort pays off.

IDE Integration is Essential - Developers don't want to context-switch to dashboards. They want verification in their workflow.

Auto-Fix is the Killer Feature - Detecting problems is good. Automatically fixing them is transformative.

What's next for Veritas

Short-term (3 months)

  • Support for Go, Rust, C++, C#, Ruby, PHP
  • Scheduled weekly/monthly repository audits
  • Custom rules per organization
  • CI/CD integration with blocking checks

Medium-term (6 months)

  • Historical tracking and trend analysis
  • Smarter auto-fixes using fine-tuned models
  • Native IDE plugins (VS Code, JetBrains, Vim)
  • Advanced analytics and ROI dashboards

Long-term (1 year)

  • Enterprise features (SSO, self-hosted, SLAs)
  • Full documentation generation from code
  • Bidirectional sync (update code from docs)
  • Mobile app for approving fixes on the go

Our Vision

A future where documentation debt is impossible. Where every function is automatically verified to match reality. Where developers spend zero time debugging outdated examples.

Documentation rot ends here.

Built with ❤️ by Team Veritas at NexHacks 2026

Built With

Share this project:

Updates