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

📁 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.