---
title: "Vibe Check: The Linter That Catches AI Slop Before It Ships"
description: "Introducing vibe-check, a CLI tool that catches common AI-generated code issues like any types, lazy comments, generic variable names, console spam, and empty catch blocks."
date: "2026-02-01"
tags: [ai, developer-tools, typescript, linting, code-quality, cli, open-source]
---
**Tags:** ai, developer-tools, typescript, linting, code-quality, cli, open-source

If you've been using AI coding assistants like Claude, GitHub Copilot, or ChatGPT to write code, you've probably noticed a pattern: the code *works*, but something feels off.

Maybe it's the `any` types sprinkled everywhere. Or the comments that just repeat what the code does. Or variable names like `data`, `result`, and `temp` that tell you nothing.

This is **AI slop**—code that technically functions but violates the craftsmanship that makes codebases maintainable.

I built **vibe-check** to catch it before it ships.

## What is AI Slop?

AI slop is the coding equivalent of fast food—it fills the gap, but it's not good for you long-term.

When AI generates code, it optimizes for:
- **Getting something that works** (not something maintainable)
- **Completing the request quickly** (not thinking through edge cases)
- **Using common patterns** (even when they're lazy patterns)

The result? Code that passes your tests but makes your tech debt compound.

### Real Examples of AI Slop

```typescript
// AI loves this (bad)
function processData(data: any): any {
  const result = data.map((item: any) => item.value);
  return result;
}

// What you actually want (good)
function extractValues(users: User[]): string[] {
  return users.map(user => user.email);
}
```

```typescript
// AI-generated comment (useless)
// This function processes the data
function processData() { ... }

// Useful comment
// Filters inactive users and sorts by last login for the admin dashboard
function getRecentActiveUsers() { ... }
```

## What vibe-check Catches

vibe-check scans your TypeScript/JavaScript codebase for the most common AI slop patterns:

### 1. `any` Types
The laziest type annotation. AI loves it because it makes everything "work."

```typescript
// Caught by vibe-check
function handleResponse(data: any) { ... }
const result: any = fetchData();
```

### 2. Lazy Comments
Comments that just describe what the code does (which you can already see).

```typescript
// Caught by vibe-check
// Loop through the array
for (const item of items) { ... }

// Increment counter
counter++;
```

### 3. Generic Variable Names
Names like `data`, `result`, `temp`, `value`, `item` that convey no meaning.

```typescript
// Caught by vibe-check
const data = fetchUsers();
const result = data.filter(d => d.active);
const temp = result.map(r => r.name);
```

### 4. Console Spam
`console.log` statements left in production code.

```typescript
// Caught by vibe-check
console.log('here');
console.log(data);
console.log('debugging');
```

### 5. Empty Catch Blocks
Silently swallowing errors—a classic AI move.

```typescript
// Caught by vibe-check
try {
  await riskyOperation();
} catch (e) {
  // AI: "I'll just leave this empty"
}
```

## Installation & Usage

### Option 1: VS Code Extension (Recommended)

The easiest way to use vibe-check is with the VS Code extension:

1. Download [vibe-check.vsix](https://github.com/hereshecodes/vibe-check-vscode/releases)
2. In VS Code: `Cmd+Shift+P` → "Extensions: Install from VSIX"
3. Select the downloaded file

**Features:**
- Inline squiggles on violations (like ESLint)
- Vibe score in status bar (🔥 90+ / ✨ 70+ / 😐 50+ / 💀 <50)
- Runs automatically on save
- No terminal required

### Option 2: CLI

Install globally via npm:

```bash
npm install -g vibe-check
```

### Run on your project

```bash
# Check current directory
vibe-check

# Check specific directory
vibe-check ./src

# Check specific file
vibe-check ./src/utils/helpers.ts
```

### Output

vibe-check gives you a clear report:

```
vibe-check v1.0.0
Scanning ./src...

src/api/handlers.ts:15 - any type detected
src/api/handlers.ts:23 - generic variable name: data
src/utils/helpers.ts:8 - lazy comment: "// Loop through items"
src/utils/helpers.ts:42 - empty catch block
src/components/Dashboard.tsx:156 - console.log detected

Found 5 issues in 3 files
```

## Configuration

Create a `.vibecheck.json` in your project root to customize:

```json
{
  "rules": {
    "any-types": true,
    "lazy-comments": true,
    "generic-names": true,
    "console-logs": true,
    "empty-catches": true
  },
  "ignore": [
    "node_modules",
    "dist",
    "**/*.test.ts",
    "**/*.spec.ts"
  ],
  "allowedGenerics": ["item", "index"]
}
```

### Rule-by-rule control

Disable specific rules if they don't fit your codebase:

```json
{
  "rules": {
    "console-logs": false
  }
}
```

## CI/CD Integration

Add vibe-check to your pipeline to prevent AI slop from getting merged.

### GitHub Actions

```yaml
name: Code Quality
on: [push, pull_request]

jobs:
  vibe-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm install -g vibe-check
      - run: vibe-check ./src --ci
```

The `--ci` flag returns exit code 1 if any issues are found, failing the build.

### Self-Hosted CI Runners

For faster builds and more control, consider running your CI on [DigitalOcean](https://m.do.co/c/b0afdad57754) droplets. A $6/month droplet can handle most vibe-check workloads, and you get consistent performance without GitHub Actions queue times.

### Pre-commit Hook

```bash
# .husky/pre-commit
npx vibe-check --staged
```

## Why I Built This

I use AI coding assistants every day. They're incredible productivity boosters.

But I noticed a pattern: I'd accept AI suggestions, then spend time cleaning them up. The same cleanup, over and over:
- Adding proper types
- Renaming vague variables
- Removing debug statements
- Writing meaningful comments

vibe-check automates that code review. It's not replacing ESLint or TypeScript's compiler—it's catching the *patterns* that slip through those tools but still hurt code quality.

Think of it as **Grammarly for AI-generated code**.

## Try It Out

```bash
npm install -g vibe-check
cd your-project
vibe-check
```

Or check out the [live demo](https://vibe-check-lilac-five.vercel.app) to paste code directly and see what it catches.

**GitHub:** [github.com/hereshecodes/vibe-check](https://github.com/hereshecodes/vibe-check)

---

## Support the Project

If vibe-check saves you time cleaning up AI-generated code, consider [buying me a coffee](https://buymeacoffee.com/hereshecodes). It helps fund more open-source developer tools.

---

*vibe-check is open source under MIT. PRs welcome—especially for new slop patterns to catch.*

---

*Source: hereshecodes.app by Danielle Hoopes*