SkillAgentSearch skills...

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-coding

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

90/100

Category

Operations

Supported Platforms

Claude Code
Cursor
GitHub Copilot
Windsurf

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.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
14/20
Freshness
11/15

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 found

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.

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.

SkillScoreStarsUpdatedFormat
Vibe Coding Mastery (this skill)by LeoYeAI902.1k4mo agoSKILL.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md
pptxby anthropics100177.9k55d agoSKILL.md
designby nextlevelbuilder100149.0k6d agoSKILL.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.

name: 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:

  1. Architecture & planning → Claude Code or Claude chat (largest context, best reasoning)
  2. Implementation → Cursor or Claude Code (fast iteration, multi-file edits)
  3. Quick fixes & completions → Copilot (inline, zero friction)
  4. 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

  1. Scaffolding: "Create the project structure with empty files and type definitions. Don't implement yet."
  2. Incremental: "Implement only [specific function]. Don't touch other files."
  3. Explain-then-build: "Explain how you'd architect this, then implement after I approve."
  4. Test-first: "Write the tests first based on these requirements. Then implement to make them pass."
  5. Refactor: "Refactor [file] to [goal]. Keep the same behavior. Don't add features."
  6. Debug: [paste error] "This happens when [action]. Expected [behavior]. The relevant code is in [files]."
  7. Review: "Review this code for [security/performance/readability]. Be specific about issues and fixes."
  8. Migrate: "Convert this from [old pattern] to [new pattern]. Show me the plan first."
  9. Document: "Add JSDoc/docstrings to all public functions in [file]. Include param types and examples."
  10. Optimize: "This function is slow with >10K items. Profile, identify bottleneck, optimize. Keep same API."
  11. Parallel session: "Read [these files] and summarize the architecture. Don't change anything."
  12. 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:

  1. Which files you'll create/modify
  2. What changes in each file
  3. What order you'll implement
  4. 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

View on GitHub
GitHub Stars2.1k
CategoryOperations
Updated4mo ago
Forks325

Languages

Python

Trust signals

98/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info