Skip to content
Back to search

antivibe

Code learning and audit framework. Analyze any codebase — new, legacy, or AI-generated — and produce educational explanations or architectural audits. Use when the user wants to understand WHAT and WHY behind any code, not just accept it.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mohi-devhub-antivibe/badge.svg)](/listings/mohi-devhub-antivibe)

HTML

<a href="/listings/mohi-devhub-antivibe"><img src="/api/listings/mohi-devhub-antivibe/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installation

# Clone the repository
git clone https://github.com/mohi-devhub/antivibe.git

# Install as a global Claude Code skill
cp -r antivibe ~/.claude/skills/antivibe

Usage

/antivibe                        # Start a deep dive (compact, mid-level by default)
/antivibe full                   # Full deep dive with resources + line-by-line
"deep dive"                      # Analyze recently written code (git diff)
"walk me through src/auth/"      # Explain an explicit file or directory
"explain this codebase"          # Understand existing / legacy code
"learn from this code"           # Generate learning guide

Tune the depth and detail inline:

"explain for a junior"           # Define terms, analogies, full snippets
"I know the basics"              # Mid level — focus on design decisions
"audit this, just the trade-offs"  # Senior mode — routes to the auditor agent

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 206 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: antivibe
  3. description: Code learning and audit framework. Analyze any codebase — new, legacy, or AI-generated — and produce educational explanations or architectural audits. Use when the user wants to understand WHAT and WHY behind any code, not just accept it.
  4. triggers:
  5. - phrase: "/antivibe"
  6. - phrase: "deep dive"
  7. - phrase: "anti-vibecode"
  8. - phrase: "why did AI write"
  9. - phrase: "learn from this code"
  10. - phrase: "understand what AI wrote"
  11. - phrase: "explain what AI wrote"
  12. - phrase: "walk me through"
  13. - phrase: "explain this file"
  14. - phrase: "explain this codebase"
  15. - phrase: "analyze this module"
  16. - phrase: "audit this"
  17. - phrase: "just the trade-offs"
  18. - phrase: "what should I worry about"
  19. - phrase: "code review"
  20. ---
  21. # AntiVibe - Code Learning & Audit Framework
  22. ## Purpose
  23. AntiVibe generates **learning-focused explanations or architectural audits** of any code — AI-generated, legacy, or otherwise. It helps developers understand:
  24. - **What** the code does (functionality)
  25. - **Why** it was written this way (design decisions)
  26. - **When** to use these patterns (context)
  27. - **What alternatives** exist (broader knowledge)
  28. Works on any codebase — you don't need recent git history or AI-authored files.
  29. ## When to Use
  30. Use AntiVibe when:
  31. 1. **Manual invocation**: User types `/antivibe` or "deep dive"
  32. 2. **Post-task learning**: After a feature/phase completes, user wants to learn from it
  33. 3. **Legacy codebases**: User wants to understand existing code they didn't write
  34. 4. **Proactive**: User says "explain what AI wrote", "walk me through", "audit this", or points at a file/directory
  35. ## What AntiVibe Produces
  36. Output saved to `deep-dive/` folder as markdown:
  37. ```
  38. deep-dive/
  39. ├── auth-system-2026-01-15.md
  40. ├── api-layer-2026-01-15.md
  41. └── database-models-2026-01-15.md
  42. ```
  43. The exact sections depend on the output mode (see [Output Mode](#output-mode)):
  44. | Section | `compact` (default) | `full` |
  45. |---------|:---:|:---:|
  46. | **Overview** — what the code does and why it exists | ✅ | ✅ |
  47. | **Key Components / Concepts** — design patterns, algorithms, CS concepts used | ✅ | ✅ |
  48. | **Code Walkthrough** — file-by-file, line-by-line notes | — | ✅ |
  49. | **Learning Resources** — curated docs, tutorials, videos | — | ✅ |
  50. | **Related Code** — links to other files in the codebase | — | ✅ |
  51. ## Configuration
  52. ### Known Concepts (Skip List)
  53. Concepts listed here will not be explained in full — the explainer will only note that they were used and in what context. Edit this list to match your current knowledge.
  54. ```yaml
  55. known_concepts:
  56. - async/await
  57. - React hooks
  58. - REST APIs
  59. ```
  60. ### Output Mode
  61. Controls how much detail is generated per run. Default is `compact` to keep token costs low.
  62. ```yaml
  63. output_mode: compact
  64. ```
  65. | Mode | What's included |
  66. |------|----------------|
  67. | `compact` (default) | Overview, key components (function-level, one line each), concepts (what + why only). No resources. No line-by-line. Max 5 files. |
  68. | `full` | Everything in compact, plus: line-by-line walkthrough, prerequisites, curated resources, Next Steps. |
  69. Override inline in your request:
  70. - `"/antivibe full"`, `"full deep dive"`, `"include resources"` → `full` mode
  71. - Default: `compact`
  72. ### Default Skill Level
  73. Sets the explanation depth when no level is specified in the request. Options: `junior`, `mid`, `senior`. Default: `mid`.
  74. ```yaml
  75. default_level: mid
  76. ```
  77. | Level | Behavior |
  78. |-------|----------|
  79. | `junior` | Define all terms. Use analogies. Explain language features. Show full code snippets with inline comments. |
  80. | `mid` | Skip basics. Focus on design decisions and trade-offs. Brief code references only. |
  81. | `senior` | Skip obvious patterns. Focus only on non-obvious choices, edge cases, and architectural trade-offs. |
  82. Level can also be specified inline in the request:
  83. - `"explain for a junior"`, `"I'm new to this"` → `junior`
  84. - `"I know the basics"`, `"mid level"` → `mid`
  85. - `"senior mode"`, `"skip the basics"`, `"just the trade-offs"` → `senior`
  86. ---
  87. ## Workflow
  88. ### Step 0: Apply User Configuration
  89. Before analyzing, read the configuration above:
  90. - Load the `known_concepts` skip list. Any concept in this list will be acknowledged in one sentence instead of fully explained.
  91. - Detect the skill level: check the user's request first (inline phrases take priority), then fall back to `default_level`. Apply this level consistently throughout the entire output.
  92. - If level = `senior`, route to `agents/auditor.md` instead of continuing this workflow.
  93. ### Step 1: Identify Code to Analyze
  94. Use the first applicable mode:
  95. 1. **Explicit** — User named specific files, a directory, or a module in their request → use those directly. No git needed. Example: "explain `src/auth/`" or "walk me through `api/routes.py`".
  96. 2. **Recent** — No explicit target given, project is a git repo, and `git diff HEAD` has output → use those changed files (current behavior for post-AI-task learning).
  97. 3. **Scan** — No explicit target, no usable git diff (legacy project, no recent changes, or not a git repo) → ask the user: "Which file, directory, or module would you like to analyze?" Do not attempt to guess.
  98. > The code does not need to be AI-generated. AntiVibe analyzes any code.
  99. ### Step 2: Analyze Code Structure
  100. For each file:
  101. - Identify main purpose and responsibilities
  102. - Note key functions, classes, modules
  103. - Identify design patterns used (factory, singleton, observer, etc.)
  104. - Find any complex logic or algorithms
  105. ### Step 3: Explain Concepts
  106. For each concept/pattern found:
  107. - **What**: Plain-language explanation
  108. - **Why**: Why this approach was chosen over alternatives
  109. - **When**: When to use this pattern (with context)
  110. - **Alternatives**: Other approaches and trade-offs
  111. - **Prerequisites**: 2–4 foundational concepts the developer must understand first (e.g., "To understand JWT, you need: HTTP request/response, Base64 encoding, cryptographic signing")
  112. ### Step 4: Find External Resources
  113. **Only run this step in `full` mode.** Skip entirely in `compact` mode.
  114. Search for and include:
  115. - Official documentation for libraries/frameworks used
  116. - Quality tutorials or blog posts
  117. - Video resources (if available)
  118. - Related concepts for further learning
  119. ### Step 5: Generate Output
  120. Create markdown file in `deep-dive/` folder:
  121. - Name format: `[component]-[timestamp].md`
  122. - Detect output mode from the request or `output_mode` config (default: `compact`)
  123. - **Compact mode**: Use the compact template. No line-by-line, no resources, no Next Steps. Max 5 files — if more are in scope, summarize extras in one line each and offer to go deeper.
  124. - **Full mode**: Use the full template from `templates/deep-dive.md`. Include all sections. No 5-file limit — analyze every file in scope; for very large inputs, split the output across multiple deep-dive files rather than truncating.
  125. - Make it educational, not just descriptive
  126. ## Auto-Trigger Configuration
  127. AntiVibe can be configured to auto-trigger via hooks:
  128. - **SubagentStop**: After a Task completes a feature
  129. - **Stop**: At session end
  130. To enable auto-trigger, configure hooks in your project (see `hooks/hooks.json`).
  131. ## Principles
  132. 1. **Why over what** - Always explain design decisions
  133. 2. **Context matters** - Explain when/why to use patterns
  134. 3. **Curated resources** - Quality links, not random Google results
  135. 4. **Phase-aware** - Group by implementation phase
  136. 5. **Learning path** - Suggest next steps for deeper study
  137. 6. **Concept mapping** - Connect code to underlying CS concepts
  138. ## Dependencies
  139. Optional scripts in `scripts/` folder:
  140. - `capture-phase.sh` - Detect implementation phase boundaries
  141. - `analyze-code.sh` - Parse code structure
  142. - `find-resources.sh` - Search for external resources
  143. - `generate-deep-dive.sh` - Create markdown output
  144. These are helpers - you can also do everything via direct code analysis.
  145. ## Examples
  146. **Input**: "Explain the auth system Claude wrote" *(recent AI code)*
  147. → Mode: Recent (git diff). Output: `deep-dive/auth-system-2026-01-15.md`
  148. **Input**: "Walk me through `src/payments/`" *(explicit target — legacy codebase)*
  149. → Mode: Explicit. Analyzes files in that directory directly, no git needed.
  150. **Input**: "Deep dive" *(no target, legacy project with no recent changes)*
  151. → Mode: Scan. Asks: "Which file or module would you like to analyze?"
  152. **Input**: "Audit this, just the trade-offs" *(senior mode)*
  153. → Routes to `agents/auditor.md`. Produces architectural audit, not an explanation.
README.md · README · 236 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # AntiVibe
  2. <p align="center">
  3. <img src="https://img.shields.io/badge/Anti--Vibecoding-Learning-orange?style=for-the-badge" alt="Anti-Vibecoding">
  4. <img src="https://img.shields.io/badge/Claude_Code-Skill-blue?style=for-the-badge" alt="Claude Code">
  5. <img src="https://img.shields.io/badge/Mintlify-OSS_Program-2b9348?style=for-the-badge" alt="Mintlify OSS">
  6. <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" alt="License">
  7. </p>
  8. <p align="center">
  9. <strong>Understand any code, not just accept it.</strong><br>
  10. A code learning &amp; audit framework for Claude Code that turns any codebase — new, legacy, or AI-generated — into educational deep dives or senior-level architectural audits.
  11. </p>
  12. ---
  13. ## ✨ What is AntiVibe?
  14. AntiVibe is a **code learning & audit framework** that transforms any code — AI-generated, legacy, or otherwise — into educational content or architectural audits. You don't need recent git history or AI-authored files; point it at any file, directory, or module. Unlike generic code summaries, AntiVibe helps you understand:
  15. - **What** the code does (functionality)
  16. - **Why** it was written this way (design decisions)
  17. - **When** to use these patterns (context)
  18. - **What alternatives** exist (broader knowledge)
  19. > ⚡ **The Problem**: AI writes code, developers copy-paste it, nobody learns anything.
  20. >
  21. > 🛡️ **The Solution**: AntiVibe explains the reasoning so you actually understand — and for code you already know, it audits the trade-offs instead.
  22. ---
  23. ## 🎯 Features
  24. | Feature | Description |
  25. |---------|-------------|
  26. | **Deep Dives** | Generate comprehensive learning guides from any code |
  27. | **Audit Mode** | Senior-level architectural audit — decisions, flags, edge cases, testability |
  28. | **Skill Levels** | Tune depth to `junior`, `mid`, or `senior` |
  29. | **Output Modes** | `compact` (default, low token cost) or `full` (resources + line-by-line) |
  30. | **Known Concepts** | Skip list so familiar concepts get a one-line note, not a full explanation |
  31. | **Prerequisites** | Maps each concept to the foundations you need to understand it first |
  32. | **Legacy-Friendly** | Works on existing codebases — no git history or AI authorship required |
  33. | **Concept Mapping** | Connect code to underlying CS principles |
  34. | **Curated Resources** | Quality links to docs, tutorials, videos |
  35. | **Auto-Trigger** | Optional hooks for automatic generation |
  36. | **Multi-Language** | Works with any language/framework |
  37. ---
  38. ## 🚀 Quick Start
  39. ### Installation
  40. ```bash
  41. # Clone the repository
  42. git clone https://github.com/mohi-devhub/antivibe.git
  43. # Install as a global Claude Code skill
  44. cp -r antivibe ~/.claude/skills/antivibe
  45. ```
  46. ### Usage
  47. ```
  48. /antivibe # Start a deep dive (compact, mid-level by default)
  49. /antivibe full # Full deep dive with resources + line-by-line
  50. "deep dive" # Analyze recently written code (git diff)
  51. "walk me through src/auth/" # Explain an explicit file or directory
  52. "explain this codebase" # Understand existing / legacy code
  53. "learn from this code" # Generate learning guide
  54. ```
  55. Tune the depth and detail inline:
  56. ```
  57. "explain for a junior" # Define terms, analogies, full snippets
  58. "I know the basics" # Mid level — focus on design decisions
  59. "audit this, just the trade-offs" # Senior mode — routes to the auditor agent
  60. ```
  61. ---
  62. ## 📁 Output Example
  63. Run a `full` deep dive (`/antivibe full`) and get a file like the one below. The default `compact` mode produces a shorter version — Overview, Key Components, and Concepts (what + why) — without the walkthrough or resources.
  64. ```markdown
  65. # Deep Dive: Authentication System
  66. ## Overview
  67. This auth system uses JWT tokens with refresh token rotation...
  68. ## Code Walkthrough
  69. ### auth/service.ts
  70. - **Purpose**: Token generation and validation
  71. - **Key Components**:
  72. - `generateTokens()`: Creates access/refresh tokens
  73. - `verifyToken()`: Validates JWT signatures
  74. ## Concepts Explained
  75. ### JWT (JSON Web Tokens)
  76. - **What**: Stateless authentication tokens...
  77. - **Why**: Server doesn't need to store sessions...
  78. - **When**: APIs, SPAs, microservices...
  79. ## Learning Resources
  80. - [JWT.io](https://jwt.io): Official documentation
  81. - [Auth0 Guide](https://auth0.com/blog): Best practices
  82. ```
  83. Saved to: `deep-dive/auth-system-2026-04-10.md`
  84. ---
  85. ## 🔧 Configuration
  86. ### Behavior (in `SKILL.md`)
  87. Tune how AntiVibe analyzes code by editing the config blocks in `SKILL.md`:
  88. ```yaml
  89. output_mode: compact # compact (default) or full
  90. default_level: mid # junior, mid, or senior
  91. known_concepts: # skipped in explanations (one-line note only)
  92. - async/await
  93. - React hooks
  94. - REST APIs
  95. ```
  96. | Setting | Options | Effect |
  97. |---------|---------|--------|
  98. | `output_mode` | `compact` / `full` | `compact` keeps token cost low (no resources, no line-by-line); `full` adds curated resources, prerequisites, and a line-by-line walkthrough |
  99. | `default_level` | `junior` / `mid` / `senior` | Sets explanation depth; `senior` routes to the auditor agent for an architectural audit |
  100. | `known_concepts` | list | Concepts you already know — acknowledged in one line instead of fully explained |
  101. All three can also be overridden inline in a request (e.g. `"/antivibe full"`, `"explain for a junior"`, `"just the trade-offs"`).
  102. ### Auto-Trigger Hooks
  103. Enable automatic deep-dive generation after task completion:
  104. ```bash
  105. # Copy hooks to your project
  106. cp hooks/hooks.json your-project/.claude/hooks.json
  107. ```
  108. | Hook | When | Use Case |
  109. |------|------|----------|
  110. | `SubagentStop` | Task completes | Phase-based learning |
  111. | `Stop` | Session ends | End-of-session summary |
  112. ### Customize Output Directory
  113. Edit `scripts/generate-deep-dive.sh`:
  114. ```bash
  115. OUTPUT_DIR="your-folder" # Default: "deep-dive"
  116. ```
  117. ---
  118. ## 📂 File Structure
  119. ```
  120. antivibe/
  121. ├── SKILL.md # Main skill definition
  122. ├── README.md # This file
  123. ├── hooks/
  124. │ └── hooks.json # Auto-trigger configuration
  125. ├── scripts/
  126. │ ├── capture-phase.sh # Detect implementation phases
  127. │ ├── analyze-code.sh # Parse code structure
  128. │ ├── find-resources.sh # Find external resources
  129. │ └── generate-deep-dive.sh # Generate markdown output
  130. ├── agents/
  131. │ ├── explainer.md # Subagent for learning-focused explanations
  132. │ └── auditor.md # Subagent for senior-level architectural audits
  133. ├── templates/
  134. │ └── deep-dive.md # Output template
  135. ├── reference/
  136. │ ├── language-patterns.md # Framework-specific patterns
  137. │ └── resource-curation.md # Curated learning resources
  138. └── docs/
  139. ├── PLAN.md # Planning document
  140. └── setup.md # Detailed setup guide
  141. ```
  142. ---
  143. ## 📚 Principles
  144. 1. **Why over what** - Always explain design decisions
  145. 2. **Context matters** - Explain when/why to use patterns
  146. 3. **Curated resources** - Quality links, not random results
  147. 4. **Phase-aware** - Group by implementation phase
  148. 5. **Learning path** - Suggest next steps for deeper study
  149. 6. **Concept mapping** - Connect code to underlying CS concepts
  150. ---
  151. ## 🛠️ Supported Languages & Frameworks
  152. - **JavaScript/TypeScript**: React, Node.js, Express
  153. - **Python**: Django, FastAPI, Flask
  154. - **Go**: Standard library, Gin, Echo
  155. - **Rust**: Standard library, Actix
  156. - **Java**: Spring Boot
  157. - **And more** - Extensible pattern system
  158. ---
  159. ## 🤝 Contributing
  160. Contributions welcome! To extend AntiVibe:
  161. 1. Add patterns to `reference/language-patterns.md`
  162. 2. Add resources to `reference/resource-curation.md`
  163. 3. Customize the template in `templates/deep-dive.md`
  164. ---
  165. ## 📖 Documentation
  166. - [Setup Guide](docs/setup.md) - Detailed installation
  167. - [Skill Format](https://docs.anthropic.com/en/docs/claude-code/skills) - Claude Code skills
  168. ---
  169. ## ⚠️ License
  170. MIT License - Use it, learn from it, share it.
  171. ---
  172. <p align="center">
  173. <sub>Built with 🔥 for developers who actually want to understand code.</sub>
  174. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.