vibe-check is on Product Hunt. If it helped you, an upvote or a comment there means a lot.
vibe-check
A skill for AI coding tools that guides complete beginners from a vague app idea to a buildable blueprint.
Every coding skill out there is great… if you already know what you’re building. That’s the catch. Most of them start the moment you’ve decided what to make. The hard part, the part that sinks most projects, happens before that.
That’s the part I spent 12-plus years doing as a product manager, taking things from zero to one. vibe-check is that work, turned into a skill.
You come in with a vague idea. It helps you dig out the real problem hiding underneath it, then pressure-tests whether that problem is even worth solving, against what real people actually struggle with and not just your gut. From there it maps the whole experience, the real screens and flows, and turns the lot into a plan and a buildable blueprint your AI can follow. And before you write a line of code, it works out your growth loop, so the thing has a shot at pulling in its own next users instead of you dragging in every one by hand.
Every other skill helps you build it right. This one makes sure you’re building the right thing.
Want it done for you?
The method below is free, and it works. If you’d rather have the person who wrote it drive it, that’s my day job. I validate ideas before they cost you money, audit AI-built apps that got scary to touch, and turn ideas into validated blueprints your AI agent builds from.
Idea Validation · Vibe-Code Rescue Audit · Validated MVP Blueprint · or just write to [email protected]
See a real sample: the AuDHD validation report, produced on a real idea with real research.
Start wherever you are
vibe-check has three on-ramps, so you don’t repeat work you’ve already done:
- The full journey: vague idea in, evidence-checked buildable plan out. The default.
- Validate only: “Is this worth building?” gets a straight, evidence-backed answer, a findings summary, and a cheap real-world test to run next. No blueprint for a dead idea.
- Plan only: already validated it? Bring your research (or your findings summary) and jump straight to planning the build.
And one way back in: “I ran the test.” Come back with your results and it reads them against the pass/fail line you set, then tells you what’s next.
How strong is your proof? The evidence ladder
Most idea validation stops at what people say. vibe-check tells you which rung you’re actually on, and hands you the script to climb to the next one:
- People complain (verified quotes, in their own words)
- People work around it (they already spend time or money on a clumsy fix)
- People sign up (strangers raised a hand)
- People commit (a pre-order, a deposit, a signed letter)
- People pay
Desk research gets you to rung 2. The built-in test kit (ready-to-send DMs, interview questions, a waitlist page, pass/fail numbers written down before the test) gets you the rest of the way. Along the way it walks the graveyard (who already tried this, and why it died), lists every assumption your idea rests on, and for anyone chasing real money, runs a bottom-up size-and-price check.
It all lands on one shareable Verdict Card. And if you want the strongest honest case against your own idea, just say “roast it.”
What it does
When someone who’s never coded before says “I want to build an app that does X,” this skill turns their AI tool into a patient mentor that:
- Discovers what they actually need: not features, but the real problem they’re solving (Reddit pain-mining, a competitor gap analysis, and ODI opportunity scoring)
- Maps the entire user experience: happy flows, failure flows, and edge cases
- Surfaces decisions they don’t know they need to make: auth, databases, payments, hosting, legal
- Recommends a modern tech stack: with plain-language explanations of what each piece does and why
- Produces a complete plan document: structured as the AI coding tool’s onboarding manual, plus an interactive PRD the human opens in their browser, the whole session in one navigable, self-contained file
- Includes build checkpoints: so the beginner is never lost during construction. The AI stops after each phase to explain what was just built, why, and what’s next.
- Teaches the build-time basics in language for someone who has never touched code: local vs. GitHub vs. live, how to save and back up code (commit/push/deploy), and keeping secret keys safe.
- Finds a growth loop: how the app recruits its next user on its own, preferably viral and organic, built into the core flow rather than bolted on, so growth compounds instead of needing a constant push.
- Handles marketplaces honestly: when the idea is two-sided, it discovers both sides (not just the one the founder happens to be), and helps brainstorm a cold-start plan so the product doesn’t launch into an empty room.
- Keeps the app healthy as it grows: a Checkup Mode that gently looks over a messy, grown codebase and tidies it safely, so the AI keeps building cleanly instead of breaking things.
Who it’s for
- People who have an app idea but have never built software
- “Vibe coders” who can get something working on their screen but need help thinking through the full picture
- Anyone who wants to go from idea → structured plan before touching code
How to use it
With Claude Code
The easiest way, installs via the open skills CLI, and works across agents:
npx skills add TexasBedouin/vibe-check
Or clone it straight into your project:
git clone https://github.com/TexasBedouin/vibe-check .claude/skills/vibe-check
Then tell Claude:
Use the vibe-check skill to help me plan my app.
Or pick your on-ramp directly:
Is my idea worth building? Reality-check it with vibe-check.
I already validated my idea. Use vibe-check to plan the build.
To update later: run npx skills update if you installed via the CLI, or git pull inside .claude/skills/vibe-check if you cloned.
Copy the contents of SKILL.md into your AI tool’s system prompt or project instructions.
What the skill produces
By the end of a vibe-check session, you’ll have a plan document that includes:
- Problem statement: in your own words
- The evidence boards: an Opportunity Map of scored, evidence-tagged needs, a Competitor Matrix showing exactly where the gap is, and a Verdict Card with your rung on the evidence ladder and the next test to run
- A save file:
vibe-check-session.md, refreshed as you go, so a cut-off chat never loses the session
- The chosen experience: Crazy 8 sketches, the converged direction, and the Experience Blueprint (the future-state board the whole session fills in)
- Story Map: the user journey with every capability sorted into V1 / V2 / Later lanes
- User flows: happy path, failure path, and edge cases, drawn in the engine’s visual style (with mermaid as the fallback)
- Feature breakdown: V1 (build now) vs V2+ (build later)
- System architecture: visual diagram with beginner-friendly labels
- Tech stack: every tool, what it does, why it was chosen, what it costs
- Data model: what gets stored, in plain language
- Cost breakdown: monthly estimates with free tier details
- Riskiest assumption as Build Phase 0: the cheap test that runs before any real code
- Distribution: your first 10 users, where they gather, and the first concrete move
- Pre-launch checklists: security, legal, accessibility
- Growth loop: the one way the app brings in its next user on its own, plus the number that proves it’s working
- Build phases with checkpoints: numbered phases with guided explanations at every step
- “Words You Now Know”: the plain-language glossary that grew through your session
This plan is designed to be handed directly to your AI coding tool to start building. It arrives twice: as the markdown instruction manual for the AI, and as an interactive PRD, one self-contained HTML file with every board embedded live, for you.
Example output
Wondering what a session actually looks like? Three examples in examples/. The two session transcripts walk the full journey (discovery, ODI opportunity scoring, the five-lens gut-check, growth loops, the lot); the third shows what the validate-only path surfaces. The ClearList example shows the full current flow, ending with the markdown plan and the interactive PRD. The plant example predates the PRD and ends with the older visual blueprint instead.
- A full ClearList session (+ the interactive PRD it produces): the complete back-and-forth from a one-line idea to the finished plan, including the wide-net reality-check. The interactive PRD is the final deliverable, tabs, live boards, the whole session in one navigable file. ClearList is a real, live product that was built with vibe-check (clearlist.me).
- Idea → plan: a plant-care app (+ visual blueprint): one sentence in (“an app that reminds me to water my plants”), a full buildable plan out.
- The AuDHD validation report: what the discovery and gut-check surface on a harder idea, real research on a real brief, ending in a verdict instead of a blueprint. This is the validate-only ending in the wild.
Version
Current version: 2.7.0 (see VERSION and CHANGELOG.md).
When you use vibe-check, it does a quick best-effort check for a newer version and tells you if you’re behind. To update, run git pull inside .claude/skills/vibe-check. Versioning is semantic (MAJOR.MINOR.PATCH).
Who made this
Built by Amer Arab. I spent 12-plus years as a product manager, most of it taking products from zero to one. Discovery is the part I care about most: working out whether a problem is real before anyone writes a line of code, then shaping something people actually want instead of something that merely works. Those years were also spent shoulder to shoulder with engineers, which is where the “you’re the PM, the AI is the engineer” idea at the heart of this skill comes from. vibe-check is me handing a first-timer the instincts I had to learn the hard way.
Inspiration
- grill-me by Matt Pocock: the relentless questioning energy
- improve-codebase-architecture by Matt Pocock: the deep-vs-shallow module wisdom and the visual HTML report, translated here into beginner metaphors (Checkup Mode + the navigability guidance)
- andrej-karpathy-skills by multica-ai: the four “how your AI should behave” ground rules (think before coding, keep it simple, surgical changes, goal-driven), translated here for beginners
- autoresearch by Udit Goenka: the verify-and-iterate loop (one change, check it, keep or revert, repeat), translated here as the beginner’s supervised improvement loop
- /office-hours by Garry Tan: the problem reframing and premise challenging
- The Design Sprint by Jake Knapp / Google Ventures: the future press release (vision extraction) and Crazy 8s, adapted here with a confidence-dial sketch count (four to eight) plus sharing and voting
- User Story Mapping by Jeff Patton: walking the chosen journey step by step to surface the features each step requires
- Bob Moesta / The Rewired Group (Jobs to be Done): demand is born in the struggling moment, the demand-side lens behind the worst-moment question
- Tony Ulwick / Strategyn (Outcome-Driven Innovation): the opportunity-scoring engine, and the competitor gap matrix used here as the beginner stand-in for ODI’s satisfaction survey
- FrontierCode by Cognition: quality over mere correctness, the fail-first test idea and the “working is the floor, not the bar” definition of done
- design-shotgun by Garry Tan / gstack: the side-by-side comparison board, adapted here as plain static HTML
- Continuous Discovery Habits by Teresa Torres (opportunity solution trees): evidence-tagging opportunities, the framing-issues honesty pass, and the riskiest-assumption test
- Growth Loops by Brian Balfour / Reforge (with Casey Winters and Kevin Kwok): the funnel-to-loop reframe and the loop taxonomy, translated here into three buildable shapes a beginner can act on (Phase 6.6)
- The Last Mile Playbook by Amer Arab: the PM vs Engineer mindset, payment processor gotchas, and the hard-won lessons of shipping a real product as a non-developer
License
MIT licensed. Use it however you want.
评论