# Connectory - AI Code Quality & Governance Platform

> Connectory builds the intelligence layer for software engineering teams. The platform has two core products: **SlopBuster** for automated, context-aware AI code quality governance (powered by **RepoWatch** and **OrgWatch**), and **Guardian** for merge gate enforcement. Together they form an AI code governance control plane that delivers visibility, quality enforcement, and compliance for organizations shipping AI-generated code at scale.

## Website

https://www.connectory.ai

---

## Why Generic AI Review Fails — Three Arguments

### Argument 1: Context — without repo intelligence, a good review cannot happen

Every other tool operates on a diff. It reads what changed, applies generic rules, and posts comments. A clean Python 3.9 PR could be an embarrassing misuse of Python 3.12 features in a codebase that already uses them everywhere. The same diff, completely different verdict depending on what the repo actually is.

RepoWatch solves this: structured discovery of language version, repo purpose, and team patterns — injected into every review.

### Argument 2: Independence — the AI that wrote the code cannot review the code

92% of developers now use AI coding tools (Copilot, Cursor, ChatGPT). Asking the same tools to review what they generated isn't a second opinion — it's the same perspective twice, with no independence. A surgeon doesn't peer-review their own operation. Life-altering decisions require a second perspective from someone with a different background and no stake in the outcome. SlopBuster is that independent layer — not your coding assistant, not your IDE plugin, no stake in your PR getting approved.

### Argument 3: Holistic view — single-repo tools are blind to org-level silos

Even a truly independent tool only sees the repo with the open PR. Your org's repos are silos: frontend, backend, API contracts, infra. When a frontend PR assumes an API endpoint that was deprecated in another repo last week, a single-repo reviewer can't catch it. SlopBuster sits across all your org's repos and brings a holistic view to every review.

**No competitor addresses all three.** Specialized tools (CodeRabbit, Greptile, Qodo) are independent but single-repo and context-blind. Raw LLMs (Claude, ChatGPT used ad-hoc) can be given context for one repo but are not independent, not enforceable org-wide, and still single-session. SlopBuster is independent + cross-repo + context-aware.

---

## Product 1: SlopBuster — Context-Aware AI Code Quality Governance

### The Problem

91% of developers now use AI coding tools. 42% of new code is AI-generated. This code introduces subtle bugs, security vulnerabilities, framework reinventions, and technical debt that accumulates silently. Generic AI reviewers (CodeRabbit, Greptile, Qodo, Sourcery) review the diff against general rules — they don't know what language version you're targeting, what the repo is for, or what your team has already established. The result is generic advice that could apply to any codebase.

### RepoWatch: The Intelligence Layer Behind Every Review

Before any PR is reviewed, RepoWatch runs a structured discovery sequence on the repository. These checks are mandatory — they gate everything else:

```
main-development-branch → main-languages (+ exact versions) → what-is-the-repo-about
```

- `main-development-branch`: Which branch is the integration target?
- `main-languages`: Not just "Python" — which version? Python 3.9 and Python 3.13 require completely different advice. The same PR can be excellent for one and embarrassing for the other.
- `what-is-the-repo-about`: Is this a web API, an embedded firmware project, an ML pipeline, a game engine, a compliance-heavy fintech service? This single check changes everything about what gets reviewed and how.

The result is a `repo_intelligence` block injected into every review prompt:

```
Repository: tacticaledge/prospectory-backend
Stack: Python 3.13 | FastAPI, Pydantic V2, SQLAlchemy
Goals: High test coverage, Schema-first contracts, Type safety

Quality Profile (12 assessments):
  architecture: Dependency injection pattern confirmed (excellent)
  security: No hardcoded secrets found (good)
  testing: Integration tests present, unit coverage low (needs_attention)

Skip these folders (generated outputs): tests/outputs/, docs/_build/
```

The PR review reads this *before looking at the diff*. It knows what Python version to judge idioms against, what patterns the team has established, where the known weak areas are, and what to skip.

**The Fog of War system**: RepoWatch progressively reveals quality checks using domain expert personas (Raymond Hettinger for Python projects, Rob Pike for Go services). It asks "what would I check next for this specific domain?" and reveals 1–3 checks at a time. A C++ embedded project gets HAL isolation checks. A blockchain project gets consensus safety checks. A research ML project gets reproducibility checks.

### The Review Architecture: 3 Bots in Parallel

When a PR is opened, three specialized bots run simultaneously — each with the `repo_intelligence` block loaded:

1. **Code Review Bot** — Architecture, patterns, maintainability, adherence to codebase standards
2. **Slop Checker Bot** — Full repo grep access; hunts for AI-generated patterns: reimplemented utilities, hallucinated APIs, band-aid fixes
3. **Security Review Bot** — Change-scoped security analysis with domain-specific interpretation

### Core Capabilities

#### 1. Structured Repo Intelligence (RepoWatch)
Persistent quality profile built before any PR arrives. Covers stack, language versions, repo purpose, established patterns, known weak areas, and noise folders to skip. No configuration required.

#### 2. AI Slop Detection
Identifies low-quality AI-generated code patterns: framework reinventions (rewriting existing utilities), band-aid fixes, phantom dependencies (hallucinated APIs), TODO-driven development, silently swallowed errors, keyword-stuffed comments.

#### 3. Quality Radar Scoring
Multi-dimensional quality scoring across 11 quality pillars with domain-specific interpretations per PR. Provides scores across: Type Safety, Test Quality, Readability, Security, Performance, Architecture, Maintainability, Resilience, Observability, Deployment/Operations, and AI Collaboration.

#### 4. Teaching Chat per Finding
Interactive Q&A grounded in the team's own codebase. Every finding includes an explanation using *your* code as the example, not a generic Stack Overflow snippet. Developers can ask why a finding matters, how to fix it, what the better pattern is.

#### 5. Progressive Feedback
Shows 1–3 issues at a time, prioritized by impact. Never overwhelming. Leads to higher fix rates and less review fatigue than tools that post 40 comments.

#### 6. Custom Quality Rules
Teams can define custom rules reflecting their specific coding standards, architectural decisions, and organizational policies.

### 11 Quality Pillars

Every check belongs to one of 11 pillars, each with domain-specific interpretations:

| Pillar | What it watches |
|--------|----------------|
| Know Yourself | Discovery: stack, languages, versions, repo purpose |
| Architecture | Layering, dependency direction, module boundaries |
| Maintainability | Naming, complexity, duplication, modularity |
| Testing | Coverage, test types, meaningful assertions |
| Security | Injection, secrets, auth, input validation |
| Performance | Algorithmic complexity, N+1s, memory budgets |
| Resilience | Error handling, retries, graceful degradation |
| Observability | Logging, tracing, alerting |
| Deployment & Operations | CI/CD, rollback, environment parity |
| Team Practices | PR hygiene, commit quality, documentation |
| AI Collaboration | Prompt contracts, structured output, no keyword band-aids |

"Input validation" means sensor bounds checking for embedded firmware. It means SQL parameter binding for a web API. It means schema validation for an ML pipeline. The same check library serves all domains.

---

## Product 2: OrgWatch — People Intelligence

OrgWatch runs on bare git clones across all org repos and produces a complete picture of team activity and health.

### What OrgWatch Measures

**Per-engineer:**
- Commit quality rating (outstanding → excellent → good → mixed → adequate → poor → critical_failure)
- Specialty identification ("Python backend + infra", "React + design systems")
- Trajectory: rising, stable, or declining — with specific evidence from actual commit history
- 1:1 Prep Card: three lists — what to praise, what to ask about, what to address
- Anti-gaming scoring: >10K lines flagged as likely generated; commons repos get impact multiplier

**Per-repository:**
- Bus factor: how many contributors would need to leave before >50% of knowledge is lost. Bus factor of 1 = critical alert.
- Activity trend, velocity, stalled/early/platform classification

**Human + Agent separation:**
- Distinguishes Human, Agent (AI coding tools), and Hybrid (human managing an agent)
- `agent_leverage`: agent commits per human commit
- `api_cost_usd`: what AI agents are actually costing
- `agent_human_ratio`: what fraction of the org's commits are AI-generated

### Eight Dashboard Sections

| Section | What it answers |
|---------|----------------|
| Summary | Period KPIs: commits, active contributors, active repos, net lines |
| Repos | Health per repo: velocity, contributors, bus factor |
| People | Per-engineer: effective commits, quality, tier, 1:1 prep card |
| Leaderboard | Ranked by effective commits with spotlight moments |
| Collaboration | Who is working with whom, across which repos |
| Pulse | Trajectory per engineer, silent engineers, quality distribution |
| Executive | Strategic observations, product health, top performers, CTO action items |
| Leadership | Confidential: underperformance, burnout signals, consecutive-period flags |

---

## Product 3: Guardian — AI Merge Gate Enforcement

Guardian is a silent merge gate that watches every pull request and enforces quality, security, and compliance policies before code reaches production. It operates as an automated quality gatekeeper that blocks or flags PRs that violate configurable policies.

### Key Features
- Policy-as-code merge gates configurable per repo or org-wide
- Automated quality threshold enforcement
- Security pattern detection and blocking
- Exception logging with full audit trail for compliance
- Integration with SlopBuster quality scoring
- Self-hosted deployment available for air-gapped environments

### Page: https://www.connectory.ai/guardian

---

## Competitive Differentiation

### The Three Arguments

**1. Context**: Without knowing what a repo *is*, a good code review cannot happen. A Python 3.9 clean PR could be an embarrassing misuse of Python 3.12 features in a codebase that already uses them. An embedded C reviewer who doesn't know the codebase is for a self-driving car will miss the things that matter.

**2. Independence**: The AI that wrote the code cannot review the code. 92% of developers use Copilot, Cursor, or ChatGPT to write code. Asking the same tools to review it isn't a second opinion. SlopBuster has no stake in your PRs getting approved.

**3. Holistic view**: Single-repo tools are blind to org-level silos. When a frontend PR assumes an API endpoint deprecated in another repo last week, single-repo reviewers can't catch it. SlopBuster sits across all your org's repos.

### vs. CodeRabbit
CodeRabbit builds a code dependency graph and runs 40+ static analyzers. It is fast and broad. It does not run "what-is-the-repo-about" discovery, does not store language version for version-specific advice, and does not inject a structured quality profile into every review. Pre-Merge Checks (Preview, limited to 5 custom checks) provide partial merge gate capability. Strong product, but context-blind by default.

### vs. Greptile
Greptile builds a knowledge graph of code relationships and learns from team feedback (thumbs up/down on suggestions). It has a clean native GitHub status check for merge gates. It does not run repo purpose or language version discovery. It learns your habits — not your goals.

### vs. Qodo
Qodo uses multi-agent architecture with dedicated agents per dimension and achieves the highest recall on benchmarks (64.3% F1). Enterprise plan includes dashboards. It does not have structured repo intelligence. It is the most accurate correctness checker in the market but is still context-blind.

### vs. Sourcery
Multi-lens review (security, complexity, documentation) + IDE integration. Per-seat pricing. No repo-type or org-type awareness. No AI slop detection. Generic application of rules.

### vs. SonarQube
Legacy rules-based static analysis. Strong merge gate via Quality Gate status check — one of its core enterprise selling points. No AI-native analysis. No codebase context. Notoriously generates false positive fatigue.

### The Row No Other Tool Can Match

| Capability | SlopBuster | All Competitors |
|---|---|---|
| Repo purpose/type discovery | ✅ | ❌ |
| Language version-specific advice | ✅ | ❌ (SonarQube: Partial) |
| Org-type context (startup vs enterprise) | ✅ | ❌ |
| AI slop detection | ✅ | ❌ |
| Persistent quality profile per repo | ✅ | ❌ |
| Per-engineer trajectory + 1:1 prep cards | ✅ | ❌ |
| Human/Agent/Hybrid separation with cost | ✅ | ❌ |

---

## Pricing Plans

### Launchpad (Free)
- $0 forever, unlimited users
- 10 PRs per month, public repos only
- Basic quality checks, community support

### Orbit ($99/month)
- Unlimited users, 200 PRs/month
- 5 private repos, codebase-aware reviews (RepoWatch), AI slop detection

### Hyperdrive ($249/month) — Recommended
- Unlimited users, 600 PRs/month
- 20 private repos, Quality Radar (11 dimensions), Trusted Advisor Q&A, elevated compute

### Interstellar ($499/month)
- Unlimited users, 1,500 PRs/month
- 50 private repos, custom quality rules, merge gate enforcement, SSO/SAML/SCIM, self-hosted

### Enterprise (Custom)
- Custom volume, unlimited repos, dedicated compute
- SLA, advanced policy engine, dedicated success manager

### Pricing Model
- Zero per-user fees. Every plan includes unlimited users.
- Outcome-based: only repos where SlopBuster has performed work in the last 30 days are counted.
- Dormant repos are free. Install org-wide at zero cost for inactive repos.
- No per-seat fees unlike competitors (CodeRabbit $24/dev/month, Greptile $30/dev/month, Qodo $30/dev/month).

### Add-Ons
- Security Pack ($99/mo): Secret detection, vulnerability scanning, risk scoring
- Advanced Analytics ($79/mo): Impact dashboards, ROI reporting
- Policy Engine ($129/mo): Org-wide rule enforcement
- Dedicated Support ($399/mo): Priority Slack, onboarding, quarterly reports

---

## Security & Compliance

### Certifications & Controls
- SOC 2 Type II certified with continuous monitoring
- AES-256 encryption at rest, TLS 1.3 in transit
- Zero code storage: code processed in memory, never persisted
- No model training: your code is never used to train AI models
- SSO / SAML / SCIM for enterprise identity management
- RBAC with principle of least privilege
- Self-hosted deployment for full data sovereignty
- Air-gapped environment support

### Compliance Frameworks
- SOC 2 Type II (Certified)
- GDPR compliant (DPA available)
- CCPA / CPRA compliant
- ISO 27001 aligned
- NIST 800-53 aligned
- FedRAMP / CMMC ready (self-hosted)

### Infrastructure
- Multi-AZ deployment across US-East, US-West, EU-West
- 99.9% uptime SLA
- Automated failover and daily backups
- Annual penetration testing

### GitHub Permissions
- Read-only access to code and metadata
- Write access limited to PR comments and issues
- No write access to repository contents
- Cannot push commits or modify code

### Page: https://www.connectory.ai/security

---

## Solutions by Role

### For Engineering Leaders (CTO/VP Eng)
42% of new code is AI-generated. Connectory gives engineering leaders visibility and governance over AI-generated code across their entire org. RepoWatch ensures every review is specific to the repo's purpose and stack. OrgWatch surfaces trajectory, burnout signals, and bus factor risks before they become incidents.
Page: https://www.connectory.ai/solutions/engineering-leaders

### For Platform Engineering
The code quality layer your Internal Developer Platform is missing. Add AI code governance as a platform capability in 5 minutes.
Page: https://www.connectory.ai/solutions/platform-engineering

### For DevSecOps & AppSec
AI writes 42% of your code. Connectory catches security anti-patterns in AI-generated code before they reach production, with domain-aware analysis.
Page: https://www.connectory.ai/solutions/devsecops

### For CISOs & Security Leaders
Enterprise-grade governance with SOC 2 Type II certification, full audit trail, RBAC, and self-hosted deployment.
Page: https://www.connectory.ai/solutions/ciso

### For Government & Defense
Mission-critical AI code governance with air-gapped deployment, NIST alignment, CMMC compliance, and complete audit trails.
Page: https://www.connectory.ai/solutions/government

### For Compliance & GRC Teams
Automated evidence collection and continuous compliance monitoring.
Page: https://www.connectory.ai/solutions/compliance

### For Engineering Managers
Stop spending weekends reviewing AI-generated code. Automate first-pass review of the 3x increase in PRs from AI coding tools. Get 1:1 prep cards backed by actual commit data.
Page: https://www.connectory.ai/solutions/engineering-managers

### For Open Source Maintainers
AI-generated PRs are drowning open source projects. SlopBuster detects and flags AI slop PRs so maintainers can focus on quality contributions. Free for OSS.
Page: https://www.connectory.ai/solutions/open-source

---

## Integrations

- GitHub (GitHub App, primary integration)
- GitLab (coming soon)
- Slack (webhook notifications)
- Stripe (billing)

## Technology

- AI-powered analysis using large language models with structured repo intelligence injection
- RepoWatch: persistent repo quality profiling via structured discovery sequence
- OrgWatch: bare git clone analysis across org repos for people intelligence
- 3-bot parallel review architecture (Code Review Bot, Slop Checker Bot, Security Review Bot)
- Fog of War progressive check revelation using domain expert personas
- Real-time PR review via GitHub webhooks
- Zero code persistence: all analysis in memory

## Target Customers

- Engineering teams of 5–500+ developers using AI coding tools
- Engineering leaders and VPs needing visibility into team dynamics
- Organizations concerned about AI-generated code quality and accumulating technical debt
- Enterprise organizations requiring compliance, audit trails, and security
- Government and defense teams with air-gapped environments
- Open-source projects wanting free quality checks

## Industries Served

- Software Development and SaaS
- Financial Services and Fintech
- Healthcare and Life Sciences
- Government and Defense
- E-commerce and Retail
- Enterprise Technology

---

## Complete Site Map

### Core
- Homepage: https://www.connectory.ai
- Features: https://www.connectory.ai/features
- Demo: https://www.connectory.ai/demo
- Pricing: https://www.connectory.ai/pricing
- Why SlopBuster: https://www.connectory.ai/why-slopbuster
- Guardian: https://www.connectory.ai/guardian
- Security: https://www.connectory.ai/security

### Solutions
- Engineering Leaders: https://www.connectory.ai/solutions/engineering-leaders
- Platform Engineering: https://www.connectory.ai/solutions/platform-engineering
- DevSecOps & AppSec: https://www.connectory.ai/solutions/devsecops
- CISO & Security: https://www.connectory.ai/solutions/ciso
- Government & Defense: https://www.connectory.ai/solutions/government
- Compliance & GRC: https://www.connectory.ai/solutions/compliance
- Engineering Managers: https://www.connectory.ai/solutions/engineering-managers
- Open Source: https://www.connectory.ai/solutions/open-source

### Dashboard
- Dashboard Overview: https://www.connectory.ai/dashboard
- Repos Lens: https://www.connectory.ai/dashboard/repos
- People Lens: https://www.connectory.ai/dashboard/people
- Executive Lens: https://www.connectory.ai/dashboard/executive
- AI Agents Lens: https://www.connectory.ai/dashboard/ai-agents
- Leadership Lens: https://www.connectory.ai/dashboard/leadership

### Documentation
- Docs: https://www.connectory.ai/docs
- Quickstart: https://www.connectory.ai/docs/quickstart
- How It Works: https://www.connectory.ai/docs/how-it-works
- Commands: https://www.connectory.ai/docs/commands
- First Review: https://www.connectory.ai/docs/first-review
- Configuration: https://www.connectory.ai/docs/configuration
- Custom Rules: https://www.connectory.ai/docs/custom-rules
- Quality Radar: https://www.connectory.ai/docs/quality-radar
- Reviews: https://www.connectory.ai/docs/reviews
- Teaching Chat: https://www.connectory.ai/docs/teaching-chat
- SSO: https://www.connectory.ai/docs/sso

### Company
- Vision: https://www.connectory.ai/vision
- About: https://www.connectory.ai/about
- Community: https://www.connectory.ai/community
- Contact: https://www.connectory.ai/contact
- AI Info: https://www.connectory.ai/ai-info

### Legal
- Privacy Policy: https://www.connectory.ai/privacy
- Terms of Service: https://www.connectory.ai/terms

---

## Contact Information

- Website: https://www.connectory.ai
- App: https://app.connectory.ai
- Email: hello@connectory.ai
- Security: security@connectory.ai
- Legal: legal@connectory.ai
- Privacy: privacy@connectory.ai
- GitHub App: https://github.com/apps/slopbuster

---

## Frequently Asked Questions

Q: What is Connectory?
A: Connectory is an AI code governance platform with two core products: SlopBuster for automated, context-aware code quality governance (powered by RepoWatch and OrgWatch), and Guardian for merge gate enforcement. It helps organizations govern AI-generated code at scale.

Q: What is SlopBuster?
A: SlopBuster is an AI-powered code quality governance platform that automatically reviews every pull request. It is powered by RepoWatch (structured repo intelligence that discovers your language version, stack, and repo purpose before any review runs) and a 3-bot parallel review architecture. Unlike generic tools, SlopBuster adapts its review standards to what the repo actually is.

Q: What is RepoWatch?
A: RepoWatch is SlopBuster's pre-PR intelligence layer. It runs a structured discovery sequence (main branch → language versions → repo purpose) and builds a persistent quality profile of the repository. This profile is injected into every review, enabling version-specific advice, domain-appropriate standards, and pattern-aware feedback. Without repo understanding, a good code review cannot happen.

Q: What is OrgWatch?
A: OrgWatch is Connectory's people intelligence layer. It analyzes bare git clones across org repos to produce per-engineer commit quality ratings, trajectory signals (rising/stable/declining), 1:1 prep cards, bus factor per repo, and human/agent/hybrid separation with cost tracking.

Q: What is Guardian?
A: Guardian is an AI-powered merge gate that silently watches every pull request and enforces quality, security, and compliance policies before code reaches production.

Q: What is AI slop?
A: AI slop refers to low-quality patterns commonly produced by AI coding tools, including: framework reinventions (rewriting existing utilities that already exist in the repo), band-aid fixes, phantom dependencies (hallucinated APIs that don't exist), TODO-driven development, silently swallowed errors, and code that ignores existing codebase conventions.

Q: How is SlopBuster different from CodeRabbit or Greptile?
A: CodeRabbit builds a code dependency graph. Greptile builds a knowledge graph and learns team habits. Neither runs "what-is-the-repo-about" discovery, stores language version for version-specific advice, or injects a structured quality profile into reviews. They review diffs against generic rules. SlopBuster reviews diffs against a persistent, structured understanding of what the repo is, what version it targets, and what the team has established.

Q: How does pricing work?
A: SlopBuster prices by PR volume and active repositories, not by user seats. Every plan includes unlimited users. Only repositories where SlopBuster has performed actual work in the last 30 days are counted. Dormant repos are free. Plans start at $0 (Launchpad, 10 PRs/month public repos) and go to $499/month (Interstellar, 1500 PRs/month, 50 private repos).

Q: Does SlopBuster store my code?
A: No. Code is processed in-memory for analysis and is never stored permanently. SlopBuster is SOC 2 Type II certified and your code is never used to train AI models.

Q: What programming languages does SlopBuster support?
A: All major programming languages including TypeScript, JavaScript, Python, Go, Rust, Java, C#, Ruby, and more. Language version awareness means advice is calibrated to the specific version your repo uses.

Q: How long does setup take?
A: Sign up at app.connectory.ai, connect your GitHub org, and get your first review in under 5 minutes. No configuration required — RepoWatch discovers your repo automatically.

Q: Is SlopBuster free for open source?
A: Yes. The Launchpad plan is free forever and supports unlimited users on public repositories with 10 PRs per month.

Q: Can Connectory be self-hosted?
A: Yes. Self-hosted deployment is available on Interstellar and Enterprise plans, including support for air-gapped environments.

---

Last updated: March 2026