Vibe Coding Mastery
The complete operating system for building software with AI. From first prompt to production deployment — prompting frameworks, architecture patterns, testing strategies, debugging playbooks, and production graduation checklists.
Install / Use
npx skills add LeoYeAI/openclaw-master-skills --skill afrexai-vibe-codingInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
OperationsSupported Platforms
Our assessment of Vibe Coding Mastery
Vibe Coding Mastery scores 90/100 on our quality scale, 324th of 746 Operations skills we index (top 44%).
Its SKILL.md is 26 KB long, well organised into 61 sections with 14 code examples: a thorough specification that gives an agent plenty to work with.
With 2,149 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-10-30 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 98/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-30. Automated pattern scan on 2026-09-30. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
Vibe Coding Mastery compared with similar skills
All 4 of these similar skills score higher than Vibe Coding Mastery; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| Vibe Coding Mastery (this skill)by LeoYeAI | 90 | 2.1k | 4mo ago | SKILL.md |
| x402by browser-use | 100 | 121.0k | 3d ago | SKILL.md |
| algorithmic-artby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| pptxby anthropics | 100 | 177.9k | 55d ago | SKILL.md |
| designby nextlevelbuilder | 100 | 149.0k | 6d ago | SKILL.md |
Frequently asked questions
- How do I install Vibe Coding Mastery?
- Run
npx skills add LeoYeAI/openclaw-master-skills --skill "Vibe Coding Mastery". The install tabs above show the steps for each supported agent. - Which AI agents does Vibe Coding Mastery work with?
- It is written for Claude Code, Cursor, GitHub Copilot and Windsurf, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is Vibe Coding Mastery safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 98/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is Vibe Coding Mastery still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: Vibe Coding Mastery slug: afrexai-vibe-coding version: 1.0.0 description: The complete operating system for building software with AI. From first prompt to production deployment — prompting frameworks, architecture patterns, testing strategies, debugging playbooks, and production graduation checklists. Works with Claude Code, Cursor, Windsurf, Copilot, and any AI coding tool. metadata: {"openclaw":{"emoji":"🎸","requires":{"bins":[]},"os":["linux","darwin","win32"]}}
Vibe Coding Mastery
The complete system for building software with AI — from zero to production. Not tips. Not theory. A full operating methodology.
What is vibe coding? Programming where you describe what you want and let AI generate code. You evaluate by results, not by reading every line. Coined by Andrej Karpathy (Feb 2025).
Key distinction (Simon Willison): If you review, test, and explain the code — that's AI-assisted software development. Vibe coding means accepting AI output without fully understanding every function. This skill covers both modes and the spectrum between them.
Phase 1: When to Vibe (Decision Matrix)
Before starting, classify your project:
| Factor | Vibe ✅ | Don't Vibe ❌ | |--------|---------|---------------| | Stakes | Low (prototype, internal, learning) | High (payments, auth, compliance) | | Timeline | Hours to days | Months+ | | Team size | Solo or pair | Large team with standards | | Domain knowledge | You understand the domain | Unfamiliar territory | | Reversibility | Easy to rewrite | Hard to change later | | Data sensitivity | Public/test data | PII, financial, health |
Scoring: Count ✅ checks.
- 5-6: Full vibe mode. Ship fast.
- 3-4: Vibe with guardrails. Review critical paths.
- 1-2: AI-assisted development, not vibe coding. Review everything.
- 0: Write it yourself or hire someone who understands the domain.
Vibe Coding Maturity Levels
| Level | Description | Who | |-------|-------------|-----| | L1 — Passenger | Copy-paste AI output, hope it works | Beginners | | L2 — Navigator | Guide AI with context, catch obvious errors | Intermediate | | L3 — Pilot | Architecture decisions, AI implements, you review | Experienced devs | | L4 — Conductor | Orchestrate multiple AI sessions, parallel streams | Power users |
Target: L3 minimum for anything going to production.
Phase 2: Tool Selection
Primary Tools Matrix
| Tool | Best For | Context Window | Multi-file | Terminal | Cost | |------|----------|---------------|------------|----------|------| | Claude Code | Full-stack, complex refactors, CLI | 200K | Excellent | Native | API usage | | Cursor | Editor-integrated, rapid iteration | 128K | Good | Via terminal | $20/mo + API | | Windsurf | Beginner-friendly, guided flows | 128K | Good | Limited | $10/mo + API | | GitHub Copilot | Inline completions, small edits | 8-32K | Limited | No | $10-19/mo | | Aider | Git-aware, open source, CLI | Varies | Good | Native | API only | | Cline (VS Code) | VS Code native, plan mode | Varies | Good | Via terminal | API only |
Multi-Tool Strategy
Use tools in combination:
- Architecture & planning → Claude Code or Claude chat (largest context, best reasoning)
- Implementation → Cursor or Claude Code (fast iteration, multi-file edits)
- Quick fixes & completions → Copilot (inline, zero friction)
- Code review → Claude chat (paste diffs, get thorough review)
Phase 3: Rules Files (Your Persistent Context)
Rules files teach AI your conventions once. Without them, every session starts from zero.
Universal Rules File Template
# Project Rules
## Stack
- Language: [TypeScript/Python/Go/etc.]
- Framework: [Next.js/FastAPI/etc.]
- Database: [PostgreSQL/SQLite/etc.]
- Styling: [Tailwind/CSS Modules/etc.]
- Package manager: [pnpm/npm/poetry/etc.]
## Code Style
- Max function length: 50 lines
- Max file length: 300 lines
- One export per file (prefer)
- Use [const/let, never var] / [type hints always]
- Error handling: [explicit try/catch, never swallow errors]
- Naming: [camelCase functions, PascalCase components, UPPER_SNAKE constants]
## Architecture
- File structure: [describe or reference]
- API pattern: [REST/tRPC/GraphQL]
- State management: [Zustand/Redux/signals/etc.]
- Auth pattern: [JWT/session/OAuth provider]
## Testing
- Framework: [Vitest/Jest/Pytest/etc.]
- Minimum coverage: [80%/90%/etc.]
- Test file location: [co-located/__tests__/tests/]
- Run before committing: [command]
## Do NOT
- Do not use `any` type in TypeScript
- Do not install new dependencies without asking
- Do not modify database schema without migration
- Do not hardcode secrets, URLs, or config values
- Do not remove existing tests
## When Unsure
- Ask before making architectural decisions
- Show the plan before implementing changes >100 lines
- Flag security-adjacent code for manual review
Where to Put It
| Tool | File | Notes |
|------|------|-------|
| Claude Code | CLAUDE.md in repo root | Also reads .claude/ directory |
| Cursor | .cursor/rules/*.mdc | Supports conditional rules with globs |
| Windsurf | .windsurfrules in repo root | Single file |
| Aider | .aider.conf.yml + conventions in chat | YAML config + initial prompt |
| Generic | AGENTS.md or CONVENTIONS.md | Any tool can be told to read it |
Cursor Conditional Rules (.mdc)
---
description: React component standards
globs: src/components/**/*.tsx
alwaysApply: false
---
# Component Rules
- Functional components only (no class components)
- Props interface above component, named [Component]Props
- Use forwardRef for components that accept ref
- Co-locate styles in [component].module.css
- Co-locate tests in [component].test.tsx
- Export component as named export, not default
Rules File Quality Checklist
- [ ] Stack and versions specified
- [ ] File/function size limits defined
- [ ] Naming conventions documented
- [ ] "Do NOT" section with common AI mistakes
- [ ] Testing expectations clear
- [ ] Architecture patterns described or referenced
- [ ] Security-sensitive areas flagged
- [ ] Dependencies policy stated
Phase 4: Prompt Engineering for Code
The 5-Level Prompt Quality Hierarchy
Level 1 — Wish (bad)
"Build a todo app"
Level 2 — Request (okay)
"Build a todo app with React and Tailwind"
Level 3 — Specification (good)
"Build a todo app: React 18, TypeScript, Tailwind. Features: add/edit/delete/toggle todos. Store in localStorage. Responsive. Under 200 lines total."
Level 4 — Brief (great)
"Build a todo app. Here's the spec:
- Stack: React 18 + TS + Tailwind + Vite
- Features: CRUD todos, toggle complete, filter (all/active/done), persist to localStorage
- Constraints: Single component file, under 200 lines, no external deps beyond stack
- Done when: All features work, page refresh preserves state, mobile responsive
- Start with the data types, then build up."
Level 5 — Contract (production-grade)
task: Todo application
stack:
runtime: React 18 + TypeScript strict
styling: Tailwind CSS 3.x
build: Vite 5
test: Vitest + Testing Library
features:
- CRUD operations on todos
- Toggle completion status
- Filter: all | active | completed
- Bulk actions: complete all, clear completed
- Persist to localStorage with versioned schema
constraints:
- Max 3 component files
- Max 200 lines per file
- No external state management library
- Keyboard accessible (tab, enter, escape)
- Mobile responsive (min 320px)
acceptance:
- All features functional
- Page refresh preserves state
- 90%+ test coverage
- No TypeScript errors (strict mode)
- Lighthouse accessibility score > 90
approach: Start with types/interfaces, then hooks, then components, then tests.
12 Proven Prompt Patterns
- Scaffolding: "Create the project structure with empty files and type definitions. Don't implement yet."
- Incremental: "Implement only [specific function]. Don't touch other files."
- Explain-then-build: "Explain how you'd architect this, then implement after I approve."
- Test-first: "Write the tests first based on these requirements. Then implement to make them pass."
- Refactor: "Refactor [file] to [goal]. Keep the same behavior. Don't add features."
- Debug: [paste error] "This happens when [action]. Expected [behavior]. The relevant code is in [files]."
- Review: "Review this code for [security/performance/readability]. Be specific about issues and fixes."
- Migrate: "Convert this from [old pattern] to [new pattern]. Show me the plan first."
- Document: "Add JSDoc/docstrings to all public functions in [file]. Include param types and examples."
- Optimize: "This function is slow with >10K items. Profile, identify bottleneck, optimize. Keep same API."
- Parallel session: "Read [these files] and summarize the architecture. Don't change anything."
- Recovery: "The codebase is in a broken state. [describe symptoms]. Help me understand what went wrong before we fix it."
Anti-Patterns (What NOT to Prompt)
| Anti-Pattern | Why It Fails | Fix | |-------------|-------------|-----| | "Build me an app" | Too vague, AI guesses everything | Use Level 4+ prompts | | "Fix it" (no context) | AI doesn't know what "it" is | Paste error + expected behavior | | "Rewrite everything" | Nukes working code, introduces regressions | Incremental refactors | | "Make it better" | Subjective, AI changes random things | Specify what "better" means | | "Use best practices" | AI's "best practices" may not match your stack | Specify the practices you want | | Multiple unrelated asks | Context bleed, partial implementations | One task per prompt | | Long conversation chains | Context degrades after 10+ turns | Start fresh sessions |
Phase 5: The RPIV Workflow
Research → Plan → Implement → Validate
Step 1: Research
"Read [files/docs/codebase]. Explain how [feature/module] works. Don't modify anything."
Purpose: Load context. Catch misunderstandings before they cascade. AI explains back to you — if the explanation is wrong, the implementation will be wrong too.
Step 2: Plan
"Based on your understanding, write a plan:
- Which files you'll create/modify
- What changes in each file
- What order you'll implement
- What could go wrong"
Purpose: Review the approach before committing to it. 10x cheaper to fix a plan than debug cascading implementation errors.
Plan Review Checklist:
- [ ] Does it touch files it shouldn't?
- [ ] Is the change order logical (types → utils → components → tests)?
- [ ] Are there missing files or steps?
- [ ] Does it respect existing patterns?
- [ ] Did it flag risks/unknowns?
Step 3: Implement
"Proceed with the plan. Implement step by step. Stop after each file for me to verify."
The 200-Line Rule: If any single implementation step is >200 lines of changes, break it down further. Large changes = large bugs.
Checkpoint System:
- After each file: quick scan for obvious issues
- After each feature: run tests
- After each milestone: manual test + commit
Step 4: Validate
"Run the tests. Show me the output. If anything fails, explain why and fix it."
Then manually verify:
- [ ] Feature works as specified
- [ ] Edge cases handled (empty state, max length, special chars)
- [ ] No console errors
- [ ] Mobile responsive (if UI)
- [ ] Existing features still work (regression check)
Phase 6: Architecture for Vibe Coding
AI generates better code when your architecture is clear and consistent.
Recommended Project Structure
project/
├── CLAUDE.md (or .cursorrules) # AI rules
├── README.md # What this is
├── src/
│ ├── types/ # Shared types (AI reads these first)
│ │ ├── index.ts
│ │ └── [domain].ts
│ ├── lib/
Truncated for display — read the full file on GitHub.
Related Skills
x402
121.0kSet up Browser Use Cloud payments with x402 — pay per request from a crypto wallet (USDC on Base mainnet), no signup or API key.
algorithmic-art
177.9kCreating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems.
pptx
177.9kUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an em…
design
149.0kComprehensive design skill: brand identity, design tokens, UI styling, logo generation (55 styles, Gemini, Atlas Cloud, or MuAPI AI), corporate identity program (50 deliverables, CIP mockups), HTML presentations (Chart.js), banner design (22 styles, social/ads/web/print), icon design (15 styles, SVG…
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
