Vibe Coding Skill

---
name: vibe-coding
description: Rapid prototyping and creative coding. Use for exploring ideas, building demos, and turning concepts into working code quickly. Prioritizes speed and iteration over perfection.
allowed-tools: read_file write_file run_command list_files
---

# Skill: Vibe coding

## Purpose

Move fast from idea to working prototype. This skill prioritizes getting something working over getting it perfect, making reasonable assumptions to maintain momentum, and iterating based on feedback.

## When to use this skill

- You have a **rough idea** and want to see if it works.
- You are **exploring a new library or API** for the first time.
- You need a **quick demo** for a meeting or presentation.
- You are in the **early stages of product discovery**.
- You want to **experiment creatively** without worrying about production concerns.

## Inputs

- **Rough idea or concept**: what you want to build (can be vague).
- **Target platform**: web, CLI, mobile, etc.
- **Constraints**: time limits, specific technologies to use or avoid.
- **Feedback**: iterative refinements based on what you see.

## Out of scope

- Production-ready code with **full test coverage**.
- Comprehensive **error handling and edge cases**.
- Performance optimization and **scalability concerns**.
- Security hardening and **compliance requirements**.

## Conventions

- **Ship something** before asking clarifying questions.
- Use the **simplest approach** that demonstrates the idea.
- **Inline dependencies** when it speeds things up.
- Skip tests and docs for **initial prototypes**.
- Make **reasonable assumptions** and note them for later.

## Required behavior

1. Get something working as fast as possible.
2. Show the result immediately so you can iterate.
3. Make reasonable assumptions rather than blocking on questions.
4. Prioritize the core idea over polish and edge cases.
5. Respond quickly to feedback with new iterations.
6. Note any shortcuts taken for later cleanup.

## Required artifacts

- **Working prototype**: runnable code that demonstrates the idea.
- **Run instructions**: how to see it working.
- **Known limitations**: shortcuts and assumptions made.
- **Next steps**: what would need to change for production.

## Implementation checklist

1. Understand the core idea (spend minimal time here).
2. Pick the fastest path to something working.
3. Build the minimum viable version.
4. Run it and show the result.
5. Iterate based on feedback.
6. Note shortcuts for potential future cleanup.

## Verification

The prototype is ready when:

- It **demonstrates the core idea**.
- You can **run it and see results**.
- Feedback loops are **fast enough to iterate**.

Skip verification when:

- Tests would slow down initial exploration.
- Edge cases are not relevant to the core concept.
- You are still figuring out if the idea is worth pursuing.

## Safety and escalation

- If the prototype needs **real credentials or data**, use mock data first.
- If the idea could **incur costs** (API calls, cloud resources), flag it.
- When transitioning to production, switch to a **more structured skill**.
- Note any **security shortcuts** taken for later review.

# Explore an idea
autohand --skill vibe-coding --prompt "I want to build something that lets users draw on a canvas and share it"

# Quick prototype
autohand --skill vibe-coding --prompt "Make a CLI tool that converts markdown to a static website"

# Creative experiment
autohand --skill vibe-coding --prompt "Build something cool with the Web Audio API"

# Rapid iteration
autohand --skill vibe-coding --prompt "That's close but make it more playful and add some animations"

# Explore a new library
autohand --skill vibe-coding --prompt "Show me what HTMX can do with a simple todo app"