Works with Claude Code, GitHub Copilot, Cursor & more

AI Code Verification
for Engineering Teams

Pre-commit agents that catch security vulnerabilities, enforce code quality, and prevent issues before they reach production. One CLI, any AI tool.

bash

npm install -g @autodevops/verifier

Security-first verification

Team policies & dashboards

Works with any AI coding tool

How It Works

AI agents that live in your existing workflow

No new platforms. No migrations. Just intelligent automation that plugs into the tools you already use.

Hook into existing events

Agents trigger on git commits, PR merges, issue creation—wherever work happens.

Execute focused micro-tasks

Each agent masters one thing: linting, security scanning, doc generation, test creation.

Review and approve results

Agents suggest changes. Engineers stay in control. Build trust incrementally.

yaml

# .autodevops.yml
agents:
  pre-commit:
    - name: polyglot-linter
      auto_fix: true
      languages: ["js", "py", "go"]
    
    - name: security-scanner
      block_on_critical: true
      
  post-merge:
    - name: doc-updater
      targets: ["README", "API_DOCS"]
    
    - name: adr-writer
      template: "decisions/template.md"
      
  on-issue-created:
    - name: spec-generator
      output: "specs/"

How It Works

Visual overview from local hooks to AI agents and CI/CD orchestration.

diagram

Features

Agents that developers actually want to use

Start with the most painful tasks. See immediate value. Scale as trust grows.

Polyglot Linter

Auto-fix style issues across all languages. No more nitpicky PR comments.

Saves 45min per PR cycle

Security Scanner

Catch vulnerabilities and secrets before they hit production.

Prevents 89% of security incidents

Test Generator

Creates test skeletons and edge cases based on your code changes.

3x faster test coverage

Skill Auto-Activation

Detects intent, loads the right Claude skills, and injects guidance before coding begins.

Consistent patterns across 300k+ LOC

Dev Docs Guardrails

Keeps plans, context, and task checklists in sync so agents never lose the plot.

Zero lost planning sessions

PM2 Observability

Managed microservices with automatic log streaming, restarts, and Claude-ready diagnostics.

Debug time cut by 60%

Pre-Commit Analytics

OpenTelemetry-powered dashboards track token costs, issues prevented, and verification performance in real-time.

Complete visibility into AI verification

Open Source CLI

Start automating in minutes

Our open-source CLI brings AI automation to your terminal. Run locally or in CI—your choice, your control.

Zero config setup

Works out of the box with sensible defaults

Language agnostic

JavaScript, Python, Go, Rust—we support them all

Privacy first

Your code never leaves your infrastructure

terminal

bash

# Install globally
npm install -g @autodevops/verifier

# Initialize in your repo
verifier init

# Run your first agent
verifier run lint --auto-fix

# See all available agents
verifier list

# Run in watch mode
verifier watch

Universal AI Tool Support

One verifier. Every AI coding tool.

Portable abstractions that work with Claude Code today, and GitHub Copilot, Cursor, Windsurf, and whatever comes next. No vendor lock-in.

Best-in-Class

C
Claude Code

Deep integration via Skills, MCP tools, and native hooks. The gold standard for agentic verification.

Native Skills integration

MCP server with 6 tools

SessionStart hooks

GitHub Copilot

Git hooks integration. Verify AI-generated code before commit with unified policies.

Pre-commit verification

VS Code extension

Agent workspace (Q1)

Cursor & Others

Universal CLI integration. Works in any terminal-based AI coding environment.

CLI-first design

Git hooks integration

CI/CD pipelines

portable hook abstraction

typescript

// Portable hook system - works with any AI tool
import { VerifierHook, HookContext } from '@autodevops/verifier';

export const securityCheck: VerifierHook = {
  id: 'pre-commit-security',
  events: ['PreToolUse', 'UserPromptSubmit'],

  // Portable across Claude, Copilot, Cursor
  async execute(context: HookContext) {
    const findings = await runSecurityScan(context.files);

    if (findings.critical > 0) {
      return { block: true, reason: 'Critical vulnerabilities detected' };
    }
    return { continue: true, context: { securityScore: findings.score } };
  }
};

Agent Ecosystem

Marketplace of verification agents

Install community agents, share your own, or build custom verification workflows. The ecosystem grows with the AI tool landscape.

Built-in Agents

security-scan

OWASP Top 10, secrets detection, dependency vulnerabilities

lint

Polyglot linting - ESLint, Ruff, Go fmt, and more

test-coverage

Enforce coverage thresholds, detect untested paths

code-complexity

Cyclomatic complexity, maintainability index

+ 6 more built-in agents: cleanup-guard, todo-auditor, code-audit, secure-dependency, claude-agent, streaming-example

Community & Custom

terminal

bash

# Install community agents
verifier plugins install @community/sql-injection-scanner
verifier plugins install @company/compliance-checker

# List installed plugins
verifier plugins list

# Create your own agent
verifier create-agent accessibility-checker

# Publish to registry
verifier plugins publish

SDK

TypeScript, Python, Go, Kotlin

Open

MIT Licensed Core

For Teams & Enterprise

Free for individuals. Premium for teams.

Open source CLI for everyone. Team dashboards, shared policies, and enterprise features for organizations.

Open Source

For individual developers

Free

All 10+ verification agents

Claude Code, Copilot, Cursor support

Local metrics & caching

Community plugins

SDKs: TS, Python, Go, Kotlin

Team

For engineering teams

$29/user/mo

Everything in Open Source

Team dashboard & analytics

Shared policies & config

Developer leaderboards

Slack/Discord notifications

Enterprise

For large organizations

Custom

Everything in Team

SSO & SCIM provisioning

On-premise deployment

Compliance & audit logs

Dedicated support

Pre-Commit Analytics

Complete visibility into AI-generated code verification

OpenTelemetry-powered observability gives you real-time dashboards for token costs, issues prevented, and verification performance.

Know exactly what your AI agents are doing

Every pre-commit verification is instrumented with OpenTelemetry traces, metrics, and events. Export to Grafana, Datadog, or any OTel-compatible backend for enterprise-grade observability.

Cost Management

Track token usage and LLM costs per agent, repository, and team. Set budget alerts before you exceed limits.

Issues Prevented

Measure ROI by tracking security vulnerabilities, lint violations, and bugs caught before they reach production.

Performance Insights

Monitor agent execution times, cache hit rates, and API latencies. Optimize your verification pipeline with data.

grafana dashboard

127

Sessions Today

342

Issues Prevented

Commits Blocked

$12.47

Cost (24h)

Verification activity over time

AgentTokensCostSuccess

security-scan52K$3.6787%

lint-agent45K$4.2394%

.verifier/config.yaml

yaml

# Enable OpenTelemetry export
telemetry:
  enabled: true
  serviceName: verifier-precommit

  # Export to your observability stack
  otlpEndpoint: http://localhost:4317
  protocol: grpc

  # Or use Grafana Cloud
  # otlpEndpoint: https://otlp.grafana.net

  # Team attribution
  resourceAttributes:
    department: engineering
    team.id: platform
    cost_center: eng-123

metrics exported

yaml

# Metrics streamed to your dashboard
verifier.session.count        # Verification sessions
verifier.agent.tokens         # Token usage by agent
verifier.agent.cost           # Cost per execution
verifier.issues.count         # Issues by severity
verifier.commit.blocked       # Blocked commits
verifier.cache.hits           # Cache performance
verifier.budget.utilization   # Budget tracking

# Events for detailed analysis
verifier.session_start
verifier.agent_result
verifier.security_finding
verifier.commit_blocked

Enterprise Ready

Export to any OTel-compatible backend: Grafana, Datadog, New Relic, Honeycomb, or self-hosted Prometheus.

Team Attribution

Track costs by team, project, or cost center with custom resource attributes. Enable chargeback and usage reporting.

ROI Measurement

Quantify value: issues prevented × estimated fix time = development hours saved. Prove AI verification ROI.

Claude Skills for CI/CD

Supercharge your pipeline with Agent Skills

Package domain expertise as modular Skills. Claude loads exactly what each CI/CD stage needs—no context bloat, unlimited scale.

Progressive Disclosure

Skills load in stages: metadata at startup (~100 tokens), instructions when triggered (<5k tokens), resources on-demand (effectively unlimited).

Install hundreds of Skills with zero context penalty

Only relevant Skills activate in each pipeline stage

Bundle unlimited reference docs without token cost

Filesystem-Based Architecture

Skills are directories with SKILL.md instructions, executable scripts, templates, and docs. Claude accesses via bash—like an onboarding guide.

Scripts execute outside context—results only

Version control Skills like code

Share custom Skills across teams and repos

.claude/skills/security-audit/SKILL.md

yaml

---
name: security-audit
description: Comprehensive security scanning for CI/CD pipelines. Use when validating code before deployment or when security review is required.
---

# Security Audit Skill

## Quick Start
Run the security scanner on staged files:

```bash
bash scripts/scan.sh --staged
```

## Resources
- [CWE_DATABASE.md](CWE_DATABASE.md) - Common weakness enumeration
- [OWASP_TOP10.md](OWASP_TOP10.md) - Security best practices
- [schemas/findings.json](schemas/findings.json) - Output format

## Pipeline Integration
Triggers: pre-deploy, on-PR
Blocks: critical vulnerabilities (CVSS ≥ 9.0)
Outputs: .security-report.json

CI/CD Pipeline Integration

Claude Skills transform generic agents into CI/CD specialists. Each pipeline stage triggers relevant Skills—lint, test, security, deploy—without manual prompting.

Pre-commit: Lint & Test Skills

Load code quality Skills before commit

Pre-deploy: Security & Compliance Skills

Validate against regulatory requirements

Post-merge: Documentation Skills

Auto-generate docs with PowerPoint, Word, PDF Skills

Pre-built Skills

PowerPoint, Excel, Word, PDF Skills work immediately in CI/CD. No setup required.

pptx

xlsx

docx

pdf

Custom Skills

Package your team’s workflows as Skills. Share across repos, version control like code.

SKILL.md

scripts/

templates/

Token Efficiency

Metadata: ~100 tokens. Instructions: <5k. Resources: effectively unlimited via filesystem.

Progressive Loading

No Context Bloat

AI Code Verificationfor Engineering Teams

AI agents that live in your existing workflow

Hook into existing events

Execute focused micro-tasks

Review and approve results

How It Works

Agents that developers actually want to use

Polyglot Linter

Security Scanner

Test Generator

Skill Auto-Activation

Dev Docs Guardrails

PM2 Observability

Pre-Commit Analytics

Start automating in minutes

One verifier. Every AI coding tool.

CClaude Code

GitHub Copilot

Cursor & Others

Marketplace of verification agents

Built-in Agents

Community & Custom

Free for individuals. Premium for teams.

Open Source

Team

Enterprise

Complete visibility into AI-generated code verification

Know exactly what your AI agents are doing

Enterprise Ready

Team Attribution

ROI Measurement

Supercharge your pipeline with Agent Skills

Progressive Disclosure

Filesystem-Based Architecture

CI/CD Pipeline Integration

Pre-built Skills

Custom Skills

Token Efficiency

AI Code Verification
for Engineering Teams

C
Claude Code