Antivibe
Learn what AI writes, not just accept it. A Claude Code skill that turns AI-generated code into educational deep dives.
mohi-devhub · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add mohi-devhub/antivibe技能说明
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:
- Manual invocation: User types
/antivibeor "deep dive" - Post-task learning: After a feature/phase completes, user wants to learn from it
- Legacy codebases: User wants to understand existing code they didn't write
- 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):
| 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.
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.
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"→fullmode- Default:
compact
Default Skill Level
Sets the explanation depth when no level is specified in the request. Options: junior, mid, senior. Default: mid.
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_conceptsskip 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 toagents/auditor.mdinstead of continuing this workflow.
Step 1: Identify Code to Analyze
Use the first applicable mode:
-
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 throughapi/routes.py". -
Recent — No explicit target given, project is a git repo, and
git diff HEADhas output → use those changed files (current behavior for post-AI-task learning). -
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 mod