name: antivibe description: Anti-vibecoding learning framework. Generate detailed explanations of code written by AI with curated external resources for deeper learning. Use when the user wants to understand WHAT and WHY behind AI-generated code, not just accept it. triggers:

• phrase: "/antivibe"
• phrase: "deep dive"
• phrase: "anti-vibecode"
• phrase: "why did AI write"
• phrase: "learn from this code"
• phrase: "understand what AI wrote"
• phrase: "explain what AI wrote"

AntiVibe - AI Code Learning Framework

Purpose

AntiVibe generates learning-focused explanations of AI-written code. Not generic summaries - actual educational content that helps developers understand:

• What the code does (functionality)
• Why it was written this way (design decisions)
• When to use these patterns (context)
• What alternatives exist (broader knowledge)

When to Use

Use AntiVibe when:

1. Manual invocation: User types /antivibe or "deep dive"
2. Post-task learning: After a feature/phase completes, user wants to learn from it
3. Proactive: User says "explain what AI wrote", "learn from this code", or "understand what AI wrote"

What AntiVibe Produces

Output saved to deep-dive/ folder as markdown:

deep-dive/
├── auth-system-2026-01-15.md
├── api-layer-2026-01-15.md
└── database-models-2026-01-15.md

Each file contains:

• Overview: What this code does and why it exists
• Code Walkthrough: File-by-file explanation with line-by-line notes
• Concepts Explained: Design patterns, algorithms, CS concepts used
• Learning Resources: Curated docs, tutorials, videos
• Related Code: Links to other files in the codebase

Workflow

Step 1: Identify Code to Analyze

• Check for explicit file list in user request
• Or use git diff to find recently modified/created files
• Or ask user which files/components they want to understand

Step 2: Analyze Code Structure

For each file:

• Identify main purpose and responsibilities
• Note key functions, classes, modules
• Identify design patterns used (factory, singleton, observer, etc.)
• Find any complex logic or algorithms

Step 3: Explain Concepts

For each concept/pattern found:

• What: Plain-language explanation
• Why: Why this approach was chosen over alternatives
• When: When to use this pattern (with context)
• Alternatives: Other approaches and trade-offs

Step 4: Find External Resources

Search for and include:

• Official documentation for libraries/frameworks used
• Quality tutorials or blog posts
• Video resources (if available)
• Related concepts for further learning

Step 5: Generate Output

Create markdown file in deep-dive/ folder:

• Name format: [component]-[timestamp].md
• Follow the template in templates/deep-dive.md
• Include code snippets where helpful
• Make it educational, not just descriptive

Configuration

AntiVibe can be configured to auto-trigger via hooks:

• SubagentStop: After a Task completes a feature
• Stop: At session end

To enable auto-trigger, configure hooks in your project (see hooks/hooks.json).

Principles

1. Why over what - Always explain design decisions
2. Context matters - Explain when/why to use patterns
3. Curated resources - Quality links, not random Google results
4. Phase-aware - Group by implementation phase
5. Learning path - Suggest next steps for deeper study
6. Concept mapping - Connect code to underlying CS concepts

Dependencies

Optional scripts in scripts/ folder:

• capture-phase.sh - Detect implementation phase boundaries
• analyze-code.sh - Parse code structure
• find-resources.sh - Search for external resources
• generate-deep-dive.sh - Create markdown output

These are helpers - you can also do everything via direct code analysis.

Examples

Input: "Explain the auth system Claude wrote" Output: deep-dive/auth-system-2026-01-15.md containing:

• JWT structure explanation
• Password hashing rationale
• Session management concepts
• Learning resources for auth patterns

Input: "I want to understand this API layer" Output: deep-dive/api-layer-2026-01-15.md containing:

• REST design decisions
• Middleware explanation
• Error handling patterns
• Further reading on API design

AntiVibe

✨ What is AntiVibe?

AntiVibe is a learning-focused code explanation framework that transforms AI-generated code into educational content. Unlike generic code summaries, AntiVibe helps you understand:

• What the code does (functionality)
• Why it was written this way (design decisions)
• When to use these patterns (context)
• What alternatives exist (broader knowledge)

⚡ The Problem: AI writes code, developers copy-paste it, nobody learns anything.

🛡️ The Solution: AntiVibe explains the reasoning so you actually understand.

🎯 Features

| Feature | Description | |---------|-------------| | Deep Dives | Generate comprehensive learning guides from AI code | | Concept Mapping | Connect code to underlying CS principles | | Curated Resources | Quality links to docs, tutorials, videos | | Phase-Aware | Group explanations by implementation phase | | Auto-Trigger | Optional hooks for automatic generation | | Multi-Language | Works with any language/framework |

🚀 Quick Start

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
"deep dive"                      # Analyze recently written code
"learn from this code"           # Generate learning guide
"explain what AI wrote"          # Explain specific files
"understand what AI wrote"       # Understand design decisions

📁 Output Example

Generate a deep dive and get a file like:

# Deep Dive: Authentication System

## Overview
This auth system uses JWT tokens with refresh token rotation...

## Code Walkthrough
### auth/service.ts
- **Purpose**: Token generation and validation
- **Key Components**: 
  - `generateTokens()`: Creates access/refresh tokens
  - `verifyToken()`: Validates JWT signatures

## Concepts Explained
### JWT (JSON Web Tokens)
- **What**: Stateless authentication tokens...
- **Why**: Server doesn't need to store sessions...
- **When**: APIs, SPAs, microservices...

## Learning Resources
- [JWT.io](https://jwt.io): Official documentation
- [Auth0 Guide](https://auth0.com/blog): Best practices

Saved to: deep-dive/auth-system-2026-04-10.md

🔧 Configuration

Auto-Trigger Hooks

Enable automatic deep-dive generation after task completion:

# Copy hooks to your project
cp framework/hooks/hooks.json your-project/.claude/hooks.json

| Hook | When | Use Case | |------|------|----------| | SubagentStop | Task completes | Phase-based learning | | Stop | Session ends | End-of-session summary |

Customize Output Directory

Edit scripts/generate-deep-dive.sh:

OUTPUT_DIR="your-folder"  # Default: "deep-dive"

📂 File Structure

antivibe/
├── SKILL.md                     # Main skill definition
├── README.md                    # This file
├── hooks/
│   └── hooks.json              # Auto-trigger configuration
├── scripts/
│   ├── capture-phase.sh        # Detect implementation phases
│   ├── analyze-code.sh         # Parse code structure
│   ├── find-resources.sh       # Find external resources
│   └── generate-deep-dive.sh   # Generate markdown output
├── agents/
│   └── explainer.md            # Subagent for detailed analysis
├── templates/
│   └── deep-dive.md            # Output template
├── reference/
│   ├── language-patterns.md    # Framework-specific patterns
│   └── resource-curation.md    # Curated learning resources
└── docs/
    ├── PLAN.md                  # Planning document
    └── setup.md                 # Detailed setup guide

📚 Principles

1. Why over what - Always explain design decisions
2. Context matters - Explain when/why to use patterns
3. Curated resources - Quality links, not random results
4. Phase-aware - Group by implementation phase
5. Learning path - Suggest next steps for deeper study
6. Concept mapping - Connect code to underlying CS concepts

🛠️ Supported Languages & Frameworks

• JavaScript/TypeScript: React, Node.js, Express
• Python: Django, FastAPI, Flask
• Go: Standard library, Gin, Echo
• Rust: Standard library, Actix
• Java: Spring Boot
• And more - Extensible pattern system

🤝 Contributing

Contributions welcome! To extend AntiVibe:

1. Add patterns to reference/language-patterns.md
2. Add resources to reference/resource-curation.md
3. Customize the template in templates/deep-dive.md

📖 Documentation

• Setup Guide - Detailed installation
• Skill Format - Claude Code skills

⚠️ License

MIT License - Use it, learn from it, share it.