What it does
Learn what AI writes, not just accept it. A Claude Code skill that turns AI-generated code into educational deep dives.
- Connects Instruction files the AI reads
- Account or key No key found in README or SKILL.md
- Category Coding
For makers: add a badge to your README
If you made this, paste this code into your README. The badge links back to this page.
[](https://mcp.popnx.com/en/skills/mohi-devhub-antivibe)Use together with
MCP servers that connect the AI to services for the same work
Fallow
Codebase intelligence for TypeScript and JavaScript, exposed as structured MCP analysis tools.
Desktop Commander
MCP server for terminal commands, file operations, and process management
Similar Skills
Same kind of work, ordered like the Skills list
| This one antivibe | rea | andrej-karpathy-skills | graphify | MoneyPrinterTurbo | |
|---|---|---|---|---|---|
| Maker | mohi-devhub | morluto | multica-ai | Graphify-Labs | harry0703 |
| Skills | 1 | 1 | 1 | 1 | 1 |
| GitHub stars | 1,138 | 467,235 | 234,125 | 149,873 | 144,332 |
| Last code change | Jul 31, 2026 | Nov 18, 2026 | Apr 20, 2026 | Nov 18, 2026 | Nov 18, 2026 |
| License | MIT | MIT | – | Apache-2.0 | MIT |
1 skills (instruction sets) by mohi-devhub that an AI reads and follows · not an MCP server
How a Skill differs from MCP
MCP = the hands
Connects the AI to an outside service or data, such as reading Notion or creating an invoice. A program or server has to be running.
Skill = the manual
A text file that teaches the AI how to do a task. It connects to nothing.
Some overlap: a few Skills run scripts that call tools, and a few MCP servers only send knowledge. Start from the task you want done.
Works with
Claude Code
From the maker’s README and the folders in the repo
Install
Is it safe?
- Who made it
GitHub account mohi-devhub (person), 2 years old
- Use and upkeep
★ 1,138 stars · code last changed Jul 31, 2026
- Any scripts?
4 scripts that can run on a computer: scripts/analyze-code.sh, scripts/capture-phase.sh, scripts/find-resources.sh, scripts/generate-deep-dive.sh
- Uses the internet?
No internet calls found in the scripts
- Changes machine-wide settings?
Installing the maker’s way adds hooks that run without you asking: run every time a sub-agent finishes · run every time the AI finishes a reply and adds 2 sub-agents
Checked automatically from the repo files at commit 9991d12 (read only, nothing was run). Not a safety guarantee: read it and decide for yourself
First: which AI do you use?
Pick your app and this page shows only how to install it there
Option 1Upload to claude.ai (web and app)
Uploading to claude.ai would fail: the description is over 200 characters (238). Use "Let the AI install it" instead
Option 1Let Claude Code install it
Copy this sentence and paste it into a Claude Code chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Restart Claude Code, then type /antivibe or ask for a matching task and Claude picks it up
Checked against official docs Nov 12, 2026 · Source: code.claude.com
For Terminal users
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Open Terminal
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
Copy the skill folder to ~/.claude/skills
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
git clone --depth 1 https://github.com/mohi-devhub/antivibe.git /tmp/popnx-skill-mohi-devhub-antivibe-9991d12 && mkdir -p ~/.claude/skills && cp -R '/tmp/popnx-skill-mohi-devhub-antivibe-9991d12/.' ~/.claude/skills/antivibeRestart Claude Code, then type /antivibe or ask for a matching task and Claude picks it up
ChatGPT desktop app
The ChatGPT desktop app has Codex built in, and Codex reads skills from ~/.agents/skills
Option 1Let ChatGPT install it
Open Codex in the ChatGPT desktop app and paste this sentence into the chat
The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Option 2Put the folder there yourself
Put the antivibe folder at ~/.agents/skills/antivibe
~ is your home folder ($HOME)
For Terminal users
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Open Terminal
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
Copy the skill folder to ~/.agents/skills
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
git clone --depth 1 https://github.com/mohi-devhub/antivibe.git /tmp/popnx-skill-mohi-devhub-antivibe-9991d12 && mkdir -p ~/.agents/skills && cp -R '/tmp/popnx-skill-mohi-devhub-antivibe-9991d12/.' ~/.agents/skills/antivibe
After installing
- ChatGPT desktop app: open Skills in the sidebar to see that the skill is there
- To use it: in ChatGPT type @ and pick the skill · in Codex CLI or the IDE extension run /skills or type $ and the skill name
- Codex picks up newly installed skills by itself; if one does not show up, restart Codex
Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com
ChatGPT on the web and mobile
Skills you install yourself do not work here; only skills that come with a plugin from the directory
To use this skill with ChatGPT, use the ChatGPT desktop app as above
Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com
Option 1Let Codex install it
Copy this sentence and paste it into a Codex chat · Works in Codex inside the ChatGPT desktop app, Codex CLI and the IDE extension
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Codex picks up newly installed skills by itself; if one does not show up, restart Codex · To use it: in ChatGPT type @ and pick the skill · in Codex CLI or the IDE extension run /skills or type $ and the skill name
Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com
For Terminal users
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Open Terminal
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
Copy the skill folder to ~/.agents/skills
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
git clone --depth 1 https://github.com/mohi-devhub/antivibe.git /tmp/popnx-skill-mohi-devhub-antivibe-9991d12 && mkdir -p ~/.agents/skills && cp -R '/tmp/popnx-skill-mohi-devhub-antivibe-9991d12/.' ~/.agents/skills/antivibeRestart Codex, then ask for a matching task; Codex lists the skill
Option 1Let Cursor install it
Copy this sentence and paste it into a Cursor chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
In Cursor’s Agent chat, type / and pick antivibe
Checked against official docs Nov 12, 2026 · Source: cursor.com
For Terminal users
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Open Terminal
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
Copy the skill folder to ~/.cursor/skills
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
git clone --depth 1 https://github.com/mohi-devhub/antivibe.git /tmp/popnx-skill-mohi-devhub-antivibe-9991d12 && mkdir -p ~/.cursor/skills && cp -R '/tmp/popnx-skill-mohi-devhub-antivibe-9991d12/.' ~/.cursor/skills/antivibeIn Cursor’s Agent chat, type / and pick antivibe
Option 1Let the AI install it
For other apps that read skills. The sentence gives the paths for Claude Code, Codex and Cursor so the AI picks the one for your app · Copy this sentence into the app’s chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Checked against official docs Nov 12, 2026 · Source: code.claude.com, learn.chatgpt.com, cursor.com
For Terminal users
Other apps that support Agent Skills (such as Gemini CLI or GitHub Copilot) use different folders. Check that app’s guide, then copy the folder with the SKILL.md there.
Skill folders checked against the official Claude Code, Codex and Cursor guides on Nov 11, 2026
✓ Commands checked Nov 18, 2026
View the original SKILL.md
The text below comes from the maker’s repo, not from PopNx MCP
Showing the first 8,000 characters · Open the full file on GitHub
---
name: antivibe
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.
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"
- phrase: "walk me through"
- phrase: "explain this file"
- phrase: "explain this codebase"
- phrase: "analyze this module"
- phrase: "audit this"
- phrase: "just the trade-offs"
- phrase: "what should I worry about"
- phrase: "code review"
---
# AntiVibe - Code Learning & Audit Framework
## Purpose
AntiVibe generates **learning-focused explanations or architectural audits** of any code — AI-generated, legacy, or otherwise. It 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)
Works on any codebase — you don't need recent git history or AI-authored files.
## 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. **Legacy codebases**: User wants to understand existing code they didn't write
4. **Proactive**: User says "explain what AI wrote", "walk me through", "audit this", or points at a file/directory
## 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
```
The exact sections depend on the output mode (see [Output Mode](#output-mode)):
| Section | `compact` (default) | `full` |
|---------|:---:|:---:|
| **Overview** — what the code does and why it exists | ✅ | ✅ |
| **Key Components / Concepts** — design patterns, algorithms, CS concepts used | ✅ | ✅ |
| **Code Walkthrough** — file-by-file, line-by-line notes | — | ✅ |
| **Learning Resources** — curated docs, tutorials, videos | — | ✅ |
| **Related Code** — links to other files in the codebase | — | ✅ |
## Configuration
### Known Concepts (Skip List)
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.
```yaml
known_concepts:
- async/await
- React hooks
- REST APIs
```
### Output Mode
Controls how much detail is generated per run. Default is `compact` to keep token costs low.
```yaml
output_mode: compact
```
| Mode | What's included |
|------|----------------|
| `compact` (default) | Overview, key components (function-level, one line each), concepts (what + why only). No resources. No line-by-line. Max 5 files. |
| `full` | Everything in compact, plus: line-by-line walkthrough, prerequisites, curated resources, Next Steps. |
Override inline in your request:
- `"/antivibe full"`, `"full deep dive"`, `"include resources"` → `full` mode
- Default: `compact`
### Default Skill Level
Sets the explanation depth when no level is specified in the request. Options: `junior`, `mid`, `senior`. Default: `mid`.
```yaml
default_level: mid
```
| Level | Behavior |
|-------|----------|
| `junior` | Define all terms. Use analogies. Explain language features. Show full code snippets with inline comments. |
| `mid` | Skip basics. Focus on design decisions and trade-offs. Brief code references only. |
| `senior` | Skip obvious patterns. Focus only on non-obvious choices, edge cases, and architectural trade-offs. |
Level can also be specified inline in the request:
- `"explain for a junior"`, `"I'm new to this"` → `junior`
- `"I know the basics"`, `"mid level"` → `mid`
- `"senior mode"`, `"skip the basics"`, `"just the trade-offs"` → `senior`
---
## Workflow
### Step 0: Apply User Configuration
Before analyzing, read the configuration above:
- Load the `known_concepts` skip list. Any concept in this list will be acknowledged in one sentence instead of fully explained.
- 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.
- If level = `senior`, route to `agents/auditor.md` instead of continuing this workflow.
### Step 1: Identify Code to Analyze
Use the first applicable mode:
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`".
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).
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.
> The code does not need to be AI-generated. AntiVibe analyzes any code.
### 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
- **Prerequisites**: 2–4 foundational concepts the developer must understand first (e.g., "To understand JWT, you need: HTTP request/response, Base64 encoding, cryptographic signing")
### Step 4: Find External Resources
**Only run this step in `full` mode.** Skip entirely in `compact` mode.
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`
- Detect output mode from the request or `output_mode` config (default: `compact`)
- **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.
- **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.
- Make it educational, not just descriptive
## Auto-Trigger 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" *(recent AI code)*
→ Mode: Recent (git diff). Output: `deep-dive/auth-system-2026-0Discussion
Ask, share a tip or report that it does not work. Sorted by what people marked helpful.
No posts yet. Be the first to ask or share.
Posts here are written by users, not the PopNx team.
From GitHub
- GitHub stars
- 1,138
- Maker
- mohi-devhub
- License
- MIT
- Last code change
- Jul 31, 2026
- SKILL.md files in the repo (including translated copies and templates)
- 1
- Topics
- ai, claude-code, claude-code-skill, code-explanation, education, learning, vibecoding