Skip to main content
skill CX Codex

vibe-coding · jamditis — Claude Code skill: methodology, install guide

A skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that loads a practical vibe-coding methodology into the agent's context. Covers planning, version control, testing, and bug-fixing with AI assistants.

MIT 203 installs ★ 458 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jamditis/claude-skills-journalism --skill vibe-coding -a claude-code
Open on GitHub

What vibe-coding does

The skill gives the agent a concrete workflow: draft an implementation plan in a markdown file before writing any code, work section by section, and commit each finished part to git before moving on.

For version control, the methodology favours reversible commands — git restore . or git stash to discard a bad AI attempt, rather than stacking new fixes on broken code. git reset --hard HEAD appears as a last resort, with the caveat that it skips reflog and can swallow uncommitted experiments. On testing, the skill argues for end-to-end tests over unit tests because LLMs frequently touch unrelated logic, and integration tests catch those regressions early.

The instruction-file section explains how to keep canonical project context in AGENTS.md and reference it from tool-specific files (CLAUDE.md, .cursor/rules/, .github/copilot-instructions.md). That prevents the same guidance from drifting out of sync across tools sharing one repo. The tool table is current as of 2026-05.

What it helps with

  • draft a section-by-section feature plan in markdown before coding starts
  • discard a failed AI attempt without losing working tree changes
  • sync instruction files across Claude Code, Cursor, and Copilot in one repo
  • catch regressions an agent introduced in unrelated code
  • unblock a stuck model by switching providers mid-session

Example prompts for the agent

  • Write a detailed implementation plan for the auth feature in plan.md, split it into sections, and mark anything complex as won't-do
  • Run the end-to-end tests and list every regression introduced since the last commit
  • Which instruction file does Cursor need, and how do I reference it from CLAUDE.md?

How to install vibe-coding

1Skills CLI (Vercel)

npx skills add jamditis/claude-skills-journalism --skill vibe-coding -a claude-code

2Manually: put the files in place

~/.claude/skills/vibe-coding/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/vibe-coding/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about vibe-coding

How do I install vibe-coding in Claude Code?

Run npx skills add jamditis/claude-skills-journalism --skill vibe-coding -a claude-code. The skill lands at ~/.claude/skills/vibe-coding/SKILL.md.

What does the vibe-coding skill do?

It loads a structured methodology for working with AI coding assistants — planning, git discipline, test-first guardrails, and a bug-fixing protocol — directly into the agent's context so the guidance is active during the session.

Can I install it for Cursor and Claude Code in the same project?

Yes. Each platform gets its own install command with the matching -a flag, so both can be active in one repo without conflict.

Source text

SKILL.md · MIT
---
name: vibe-coding
description: AI-assisted coding with Claude Code, Cursor, Copilot, Codex, Aider, or Windsurf. Use to build or debug generated code.
---

# Vibe coding methodology

Practical strategies for building software effectively with AI coding assistants.

> **Tool landscape moves fast.** This skill was last swept 2026-05-08. The methodology (planning, version control, testing, bug-fixing) is stable; the specific tool names, instruction-file conventions, and pricing details drift quarterly. Treat the named tools as representative, not exhaustive.

## Planning process

Start by working with the AI to write a detailed implementation plan in a markdown file.

**Scope management**: Review and refine the plan, delete unnecessary items, mark complex features as "won't do," and keep a separate section for ideas to implement later. This prevents scope creep and maintains focus.

**Incremental implementation**: Work section by section rather than building everything at once. Have the AI mark sections complete after successful implementation, and commit each working section to git before moving to the next.

**Track progress visibly**: Use todo lists, markdown checklists, or inline status markers so both you and the AI can see what's done and what remains. This prevents re-implementing completed work and keeps sessions focused.

## Version control strategies

Git is your safety net, don't rely solely on the AI tool's revert functionality.

**Branch per attempt**: Begin each new feature on a fresh feature branch (`git switch -c feature/xyz`) and commit small chunks as the AI makes progress. The branch boundary is your "if this goes off the rails, throw it away" boundary, you discard the branch, not your working tree.

**When the AI goes down a bad path**: Prefer reversible commands. `git restore .` discards uncommitted changes; `git stash` parks them; `git switch -` jumps back to your previous branch. Reach for `git reset --hard HEAD` only when you've confirmed there's nothing in the working tree worth keeping, destructive commands skip the reflog niceties and can swallow uncommitted experiments. (If the agent has been creating new files, a separate `git clean -fd` is also part of "really, throw it all away", same caveats.)

**Clean re-implementation**: When you finally find a working solution after several attempts, branch from main, implement it fresh, and discard the throwaway branch. Multiple failed AI attempts leave layers of dead code that compound future confusion, a clean re-implementation of a known-good solution is faster and more maintainable than untangling the spaghetti.

## Testing framework

Prioritize end-to-end integration tests over unit tests. Focus on simulating user behavior, testing features by simulating someone clicking through the site or app.

**Regression prevention**: LLMs often make unnecessary changes to unrelated logic. Tests catch these regressions before they compound.

**Tests as guardrails**: Consider starting with test cases to provide clear boundaries for what the AI should and shouldn't change. Ensure tests pass before moving to the next feature.

## Effective bug fixing

**Error messages**: Simply copy-pasting error messages is often enough context for the AI to identify and fix issues.

**Analyze before coding**: Ask the AI to consider multiple possible causes before jumping to implementation. This prevents chasing the wrong problem.

**Reset after failures**: Start with a clean slate after each unsuccessful fix attempt rather than layering fixes on top of broken code.

**Strategic logging**: Add logging statements to better understand what's happening when bugs are opaque.

**Switch models**: Try different AI models when one gets stuck on a problem.

## AI tool landscape (as of 2026-05)

The current tools cluster into four shapes. Pick by where you work, not by hype.

| Shape | Examples | When |
|---|---|---|
| CLI agents | Claude Code, Aider, Codex CLI, Gemini CLI, GitHub Copilot CLI, opencode, Goose | Repo-wide changes, multi-file refactors, automation, headless / cron use |
| Standalone IDEs | Cursor, Windsurf, Zed, Kiro | Day-to-day editing with chat + autocomplete tightly integrated |
| IDE extensions | GitHub Copilot, Continue, Cline, Roo Code, Amazon Q | Stay in your existing editor (VS Code, JetBrains, Neovim) |
| Cloud agents | Devin, OpenHands, Jules, GitHub Copilot Coding Agent | Async / background work via PR, no local terminal needed |

A common stack many developers converge on: **Cursor or Copilot for daily editing + Claude Code (or Codex CLI) for repo-wide / agentic tasks**. They're complementary, fast inline edits in the IDE, longer agentic loops at the terminal.

## AI tool optimization

**Instruction files**: Write project-specific context for your AI assistants. Conventions have splintered, but several tools converge on `AGENTS.md` as a shared format. Current naming as of 2026-05:

| Tool | File(s) | Notes |
|---|---|---|
| Claude Code | `CLAUDE.md` (per-directory, nested) | Loaded automatically; see [docs.anthropic.com/en/docs/claude-code/memory](https://docs.anthropic.com/en/docs/claude-code/memory) |
| Cursor | `.cursor/rules/*.mdc` (modern), Markdown + YAML frontmatter (`description`, `globs`, `alwaysApply`) | Legacy `.cursorrules` single-file still works but Cursor recommends migrating |
| Windsurf | `.windsurfrules` or `.windsurf/rules/*.md` | Same dual pattern as Cursor |
| GitHub Copilot | `.github/copilot-instructions.md` | Single repo-level file, ~4k char practical cap |
| Cline | `.clinerules` | Single file |
| Aider | `.aider.conf.yml` (config) + chat history files | Git-native; reads `CONVENTIONS.md` if you point it there |
| Continue | `.continue/config.json` | JSON config; per-repo |
| Codex CLI / Gemini CLI / Aider / Continue | `AGENTS.md` (vendor-neutral fallback) | Becoming the cross-tool common denominator |

When working across multiple tools, keep the canonical guidance in `AGENTS.md` and reference it from tool-specific files (`CLAUDE.md`: "Also read AGENTS.md."). That avoids drift between siblings.

**Local documentation**: Download API documentation to your project folder. AI tools work more accurately against local docs than against recalled training data, especially for libraries that release breaking changes faster than training cutoffs (e.g. Sentry SDK, Google GenAI SDK, Selenium).

**Run multiple tools**: There's no penalty for running Cursor for inline edits while a Claude Code or Codex CLI session works in another terminal on a separate task. Different shapes for different work.

**Compare outputs**: For high-stakes decisions, generate solutions with models from two different providers and compare them against the same requirements. Different model families make different mistakes.

## Complex feature development

**Standalone prototypes**: Build complex features in a clean codebase first, then integrate once working. This isolates problems and makes debugging easier.

**Reference implementations**: Point the AI to working examples to follow. Existing code patterns provide concrete guidance.

**Clear boundaries**: Maintain consistent external APIs while allowing internal changes. Service-based architectures with clear boundaries work better than monorepos for AI-assisted development.

## Tech stack considerations

**Established frameworks**: Ruby on Rails and similar mature frameworks work well due to 20+ years of consistent conventions in training data.

**Training data matters**: Newer languages like Rust or Elixir may have less training data, leading to more errors or outdated patterns.

**Modularity**: Small, modular files are easier for both humans and AIs to work with. Avoid files with thousands of lines, they exceed context windows and create confusion.

## Beyond coding

AI assistants help with more than writing code:

- **DevOps**: Configuring servers, DNS, and hosting
- **Design**: Generating favicons and other design elements
- **Documentation**: Drafting docs and marketing materials
- **Education**: Explaining implementations line by line
- **Visual input**: Share screenshots for UI bugs or design inspiration. Most modern assistants (Claude Code via paste, Cursor, Copilot Chat) accept image input directly.
- **Voice input**: Whisper-based transcription tools (Whispr Flow, Superwhisper, MacWhisper, Aqua) reach 130-180 wpm with current OpenAI / Whisper.cpp models. Useful for long-form prompting and rubber-ducking.

## Continuous improvement

**Regular refactoring**: Once tests are in place, refactor frequently. Ask the AI to identify refactoring candidates.

**Stay current**: Try every new model release. Different models excel at different tasks, experiment to find which works best for your use case.

## Reference files

Read [Complexity and readability](references/complexity-and-readability.md) before a complexity pass or a substantial branching change.

Read [Invariants and proportional care](references/invariants-and-proportional-care.md) when a change affects stored state, trust boundaries, error recovery, or a reported bug.

© jamditis · MIT · jamditis/claude-skills-journalism

Similar skills

All skills for Agent setup: memory, context, orchestration →

vibe-coding by other authors comes first.

vibe-coding shareAI-lab vibe-coding sets how a coding agent behaves on a codebase: read before editing, match verification to the risk, lead the write-up with the outcome. CX Codex +1 1installs Vibe Coding Master xuzihan1 Vibe Coding Master sets the AI to act as a lead engineer for building commercial applications via vibe coding. Helps turn initial ideas into PRDs, code, interfaces, and test suites. GP ChatGPT ★ 178,201repo stars vibe-coding-advisor uxuiprinciples vibe-coding-advisor injects relevant UX principles into your AI coding session before you generate UI components. CX Codex +1 ★ 33repo stars Vibe Coding with Commands and Skills amvicioushecs Vibe Coding with Commands and Skills configures the model as a vibe coding assistant with slash commands and design skills. Helps debug code, optimize performance, and map user flows in chat. GP ChatGPT ★ 178,201repo stars vibe-build KhazP The vibe-build skill takes a new-project slice from the brief to a working user journey and relevant checks. Use it when a passing build alone is not enough. CX Codex +1 ★ 3,267repo stars vibe-review KhazP vibe-review checks proposed changes against requirements, regressions, verification evidence, and security concerns before they move forward. CX Codex +1 ★ 3,267repo stars grounding-before-coding riekelt The grounding-before-coding skill makes the agent inspect code and data before changing a project or explaining a bug. It fits unfamiliar repositories and non-trivial work. CX Codex +1 25,600installs

From the same set35

The whole set →
story-pitch This skill shapes story pitches for editors, query letters, and opinion pieces. Use it when an idea needs a clear angle, evidence plan, and outlet fit. CX Codex +1 215installs web-archiving web-archiving teaches the agent to pull archived copies of pages from Wayback Machine and Archive.today, and to save fresh snapshots before content changes. CX Codex +1 215installs security-checklist security-checklist runs a pre-deployment security review structured around OWASP Top 10:2025 before shipping to production. CX Codex +1 210installs secure-auth secure-auth — a skill for designing authentication with passwords, sessions, JWT, OAuth, MFA, and passkeys. Use it when adding sign-in or registration. CX Codex +1 207installs content-access content-access is a Claude Code skill that describes ethical and legal workflows for journalists and researchers to access paywalled publications and research papers through open access APIs. CX Codex +1 201installs digital-archive Design a digital archive that brings material from different sources into one schema, adds AI-assisted classification, and connects referenced entities. CX Codex +1 198installs zero-build-frontend zero-build-frontend — a skill for building frontend code that runs directly in the browser without a build step. Covers static sites, browser extensions, maps, and lightweight data-backed interfaces. CX Codex +1 198installs free-apis-catalog free-apis-catalog is a Claude Code skill listing free APIs and verified free-tier limits for news, weather, US public records, and social platforms. It helps agents choose a data source instead of inventing an endpoint. CX Codex +1 191installs

Project sponsors

Companies that keep this analytics open