# anti-hallucination

Adopt this skill: https://proskills.md/skills/other/a-ariff-ariff-claude-plugins-plugins-anti-hallucination-skills-anti-hallucinatio

Page: https://proskills.md/skills/other/a-ariff-ariff-claude-plugins-plugins-anti-hallucination-skills-anti-hallucinatio
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: plugins/anti-hallucination/skills/anti-hallucination/SKILL.md
size: 3135
sha: 6fc5fc76c51c05b991dc03291c580b41cf5c2ce2
upstream: https://github.com/a-ariff/ariff-claude-plugins/blob/main/plugins/anti-hallucination/skills/anti-hallucination/SKILL.md

```text
---
name: anti-hallucination
description: Complete methodology for preventing AI hallucinations. Use when accuracy is critical and you need Claude to verify before claiming, cite before asserting, and admit uncertainty instead of guessing.
---

# Anti-Hallucination Methodology

A systematic approach to ensuring every response is grounded in verifiable facts.

## Core principle

Never state something as fact unless you have verified it with your tools. If you cannot verify, say so explicitly.

## The verification hierarchy

Before making any factual claim, follow this hierarchy:

### Level 1: Direct evidence (strongest)
You read the actual file and saw the code.
"The function validateToken at src/auth.ts:42 returns false when the token is expired."

### Level 2: Search evidence
You searched and found matching results.
"Grep found 3 references to validateToken across the codebase."

### Level 3: Inference from evidence
You didn't find the exact thing but can reasonably infer from what you found.
"Based on the error handling pattern in src/auth.ts, expired tokens likely return a 401 status." (Mark this as inference.)

### Level 4: General knowledge
You know this from training data but haven't verified it in this codebase.
"Express middleware typically calls next() to pass control." (Mark this as general knowledge, not specific to this project.)

### Level 5: Uncertainty
You don't know and haven't checked.
"I'm not sure how this handles token refresh. Let me check." (Then actually check.)

## Hallucination patterns to avoid

### Invented file paths
Wrong: "The config is at src/config/database.ts"
Right: Use Glob to find it first, then reference the actual path.

### Assumed function signatures
Wrong: "The function takes a userId and returns a Promise<User>"
Right: Read the file and quote the actual signature.

### Phantom dependencies
Wrong: "Since you're using lodash..."
Right: Check package.json first.

### Memory-based version numbers
Wrong: "React 18.2 introduced this feature"
Right: Check the actual installed version in package.json.

### Confident wrong answers
Wrong: "This will definitely fix the issue"
Right: "Based on the error pattern, this should fix the issue. Let's verify after applying."

## Phrases to use

Instead of: "This function does X"
Say: "Looking at src/auth.ts:42, this function does X"

Instead of: "You're using library X"
Say: "Based on package.json, the project uses library X at version Y"

Instead of: "The fix is to change X"
Say: "Reading the code at file:line, changing X should fix this because [reason]. Let me verify."

Instead of: "This is a common pattern"
Say: "I see this pattern used in [specific files in this codebase]"

## When to say "I don't know"

Always say "I don't know" or "Let me check" when:
- You haven't read the relevant file
- You're going from memory about this specific codebase
- The question is about runtime behavior you can't verify statically
- The question involves external services or APIs you can't access
- You're not confident in your answer

Saying "I don't know, let me check" and then checking is always better than guessing.
```

## File: README.md
upstream: https://github.com/a-ariff/ariff-claude-plugins/blob/main/README.md

````text
# Claude Code Plugin Marketplace

<div align="center">

[![Plugins](https://img.shields.io/badge/plugins-65-blue?style=for-the-badge)](./marketplace.json)
[![Agents](https://img.shields.io/badge/agents-24-green?style=for-the-badge)](./plugins)
[![Skills](https://img.shields.io/badge/skills-34-orange?style=for-the-badge)](./plugins)
[![Hooks](https://img.shields.io/badge/hooks-5-red?style=for-the-badge)](./plugins)
[![License](https://img.shields.io/badge/license-MIT-purple?style=for-the-badge)](./LICENSE)
[![Stars](https://img.shields.io/github/stars/a-ariff/ariff-claude-plugins?style=for-the-badge)](https://github.com/a-ariff/ariff-claude-plugins/stargazers)

**65 production-ready plugins for Claude Code -- autonomous agents, power skills, anti-hallucination suite, smart hooks, and custom commands**

Compatible with Claude Opus 4.6, Sonnet 4.6, and Haiku 4.5

[Quick Start](#quick-start) | [What's Inside](#whats-inside) | [How to Install](#how-to-install-step-by-step) | [Usage Guide](#usage-guide) | [Documentation](#documentation) | [Contributing](#contributing)

</div>

---

## What is this?

Claude Code is Anthropic's CLI tool for coding with AI. **Plugins** extend what Claude Code can do by adding specialized agents, skills, and automation hooks.

This marketplace gives you **53 ready-to-use plugins** that turn Claude Code into an autonomous development powerhouse. Instead of telling Claude what to do step by step, you delegate entire tasks to specialized agents that know exactly how to handle them.

**Before plugins:**
```
You: "Read the auth module, check for SQL injection, review the error handling,
     look at the input validation, check the session management..."
```

**After plugins:**
```
You: "Run a security review on the auth module"
Claude: *security-analyst agent handles everything autonomously*
```

---

## Quick Start

**Prerequisites:** [Claude Code](https://claude.ai/code) and [Git](https://git-scm.com) installed.

**macOS / Linux:**
```bash
git clone https://github.com/a-ariff/ariff-claude-plugins.git
cd ariff-claude-plugins && bash scripts/install.sh
```

**Windows (PowerShell):**
```powershell
git clone https://github.com/a-ariff/ariff-claude-plugins.git
cd ariff-claude-plugins; .\scripts\install.ps1
```

Done. Start a new Claude Code session and all 65 plugins are available.

---

## What's Inside

### 65 Plugins in 4 Categories

```
ariff-claude-plugins/
|
|-- 24 Agents      autonomous workers that handle entire tasks
|-- 34 Skills      methodologies and knowledge you can apply on demand
|--  5 Hooks       automatic safeguards that run without you asking
|--  2 Commands    slash commands for common workflows
|
|-- includes 12-plugin Anti-Hallucination Suite
```

### Agents (22) -- delegate entire tasks

Agents are autonomous workers. You give them a task, they figure out the approach, use tools, read files, and deliver results.

| Category | Agents | What they do |
|----------|--------|-------------|
| **Development** | architect, backend-dev, frontend-dev, performance-engineer, qa-engineer, security-analyst, refactorer, autonomous-dev-assistant | Build, optimize, test, and secure code |
| **Analysis** | sequential-thinker, project-planner, analyzer, mentor | Plan, analyze, reason through problems |
| **Safety** | context-validator, intent-clarifier, pre-action-verifier, scope-boundary-checker, fact-checker, dependency-validator, rollback-planner | Validate before acting, catch mistakes early |
| **Specialized** | smithery-deployment-agent, smart-routing, setup-orchestrator | Deploy MCP servers, route to optimal models, configure environments |

### Skills (26) -- apply proven methodologies

Skills are knowledge and methodology files that Claude loads when relevant. They teach Claude how to approach specific types of problems.

**Superpowers (9):** brainstorming, writing-plans, executing-plans, subagent-driven-development, verification-before-completion, root-cause-tracing, defense-in-depth, when-stuck, using-superpowers

**Development (12):** github, plugin-creator, plugin-checker, canvas-api, api-docs-generator, ci-cd-helper, code-reviewer, commit-message-generator, error-explainer, performance-optimizer, pr-analyzer, refactor-assistant

**Testing (3):** security-scanner, tdd-workflow, test-writer

**Debugging (2):** systematic-debugger, memory-sync

### Hooks (3) -- automatic safeguards

Hooks run automatically at specific points during Claude's workflow. You don't invoke them -- they watch and act.

| Hook | Event | What it does |
|------|-------|-------------|
| assumption-checker | PreToolUse | Warns when Claude makes assumptions instead of checking |
| memory-sync | Stop | Prompts to save learnings at session end |
| hooks-reference | PreToolUse | Reference implementation for building your own hooks |

### Anti-Hallucination Suite (12 plugins) -- stop AI from guessing

A complete system to prevent Claude from making things up. Hooks catch problems automatically, agents cross-verify claims, and skills teach verification methodology.

**Why this matters:** AI can confidently state things that aren't true -- wrong file paths, invented function names, assumed behavior. These plugins catch that before it reaches you.

| Plugin | Type | What it does |
|--------|------|-------------|
| hallucination-guard | Hook | Scans every response for speculative language and unverified claims |
| answer-validator | Hook | Checks that tool outputs match the claims Claude makes about them |
| truth-finder | Agent | Cross-references claims against actual code, docs, and git history |
| answer-analyzer | Agent | Reviews Claude's own response for accuracy before delivery |
| anti-hallucination | Skill | Complete methodology: verify before claiming, cite before asserting |
| cross-checker | Skill | Verify from multiple angles: code, tests, git, docs, config |
| source-verifier | Skill | Every claim must have a file:line citation or be flagged |
| confidence-scorer | Skill | Assigns 0-100 confidence score to each claim |
| citation-enforcer | Skill | Forces file:line references for every code claim |
| uncertainty-detector | Skill | Catches when Claude is guessing but sounding certain |
| output-auditor | Skill | 4-angle review: accuracy, logic, completeness, safety |
| context-grounding | Skill | Forces reading actual code before making claims about it |

### Commands (2) -- slash commands

| Command | Usage | What it does |
|---------|-------|-------------|
| deep-search | `/deep-search "query"` | Multi-source semantic search across GitHub, Reddit, docs |
| task-folder-manager | `/task-folder-manager` | Create dated, organized task folders |

---

## How to Install (Step by Step)

This guide assumes you've never installed a Claude Code plugin before. Pick your platform below.

### Step 1: Make sure Claude Code is installed

Open any terminal and run:
```
claude --version
```

If you see a version number (e.g., `2.1.76`), you're good. If not, install Claude Code first from [claude.ai/code](https://claude.ai/code).

### Step 2: Clone this repository

```
git clone https://github.com/a-ariff/ariff-claude-plugins.git
cd ariff-claude-plugins
```

### Step 3: Run the installer for your platform

<details>
<summary><strong>macOS / Linux (Terminal, iTerm, Warp)</strong></summary>

```bash
bash scripts/install.sh
```
</details>

<details>
<summary><strong>Windows (PowerShell)</strong></summary>

```powershell
# Run from PowerShell (not CMD)
cd ariff-claude-plugins

# Create plugin directories
$claudeDir = "$env:USERPROFILE\.claude"
New-Item -ItemType Directory -Force -Path "$claudeDir\agents"
New-Item -ItemType Directory -Force -Path "$claudeDir\skills"
New-Item -ItemType Directory -Force -Path "$claudeDir\hooks"
New-Item -ItemType Directory -Force -Path "$claudeDir\commands"
New-Item -ItemType Directory -Force -Path "$claudeDir\scripts"

# Copy all plugins
Get-ChildItem plugins -Directory | ForEach-Object {
    $plugin = $_
    # Agents
    if (Test
````
