By ysainson
The VIBE core: a stack-agnostic orchestration engine. /vibe:conduct builds test-first with model-tiered doers, reviews every diff, and gates completion through an independent fresh-context verifier. Pure process - no framework knowledge.
Turn a rough idea into a written spec - wraps superpowers' brainstorming, applies VIBE's project heuristics, and saves the result to docs/specs/.
Generate a conventional commit message from the staged (or unstaged) changes and copy it to the clipboard.
Orchestrate a coding task - failing test contract first, numbered plan, model-tiered doers, review every diff in two passes, independent fresh-context verify
Auto-fix only the safe, mechanical issues in changed files - formatters/linters and project-local auto-fixers. Never touches security or behavior.
Fast pre-commit sanity check on changed files - a secrets scan plus the enabled overlay's quick guardians and project-local lightweight checks. Use /vibe:review for the full pass.
Mechanical-edit subagent for exact, low-judgment transformations - renames, codemods, boilerplate, lint fixes, applying a precisely described change across files. Dispatched by the conduct skill. Anything requiring a design decision goes to doer instead.
Implementation subagent for delegated, well-specified coding subtasks. Dispatched by the conduct skill with a contract (tests to pass), exact scope, and guardrails. Not for open-ended exploration or design decisions.
Code-quality review of a subtask diff. Checks craft - simplicity, idioms, conventions, no scope creep or needless abstraction - independently of whether the spec is met. Dispatched by the conduct skill in the review step, before a subtask is accepted. The second of two separate review passes; spec compliance is the other reviewer's job.
Spec-compliance review of a subtask diff. Checks that the change does exactly what its contract and the spec require - nothing missing, nothing gamed - independently of code quality. Dispatched by the conduct skill in the review step, before a subtask is accepted. The first of two separate review passes; craft is the other reviewer's job.
Security review lens for changed code. Checks secrets, injection, authn/authz, unsafe data handling, and dependency risk on a diff. Dispatched by the conduct skill when a change touches auth, input handling, endpoints, storage, or dependencies.
How to ask the user clarifying questions - always via the AskUserQuestion tool with concrete options and a recommended default. Use when a request is underspecified in ways that change the outcome.
Orchestrate a coding task end-to-end - consume the spec, write failing test contracts, plan it as numbered commit-per-task work, delegate implementation to model-tiered doer subagents, review every diff in two passes, and gate completion through an independent fresh-context verifier. Wraps the superpowers phase skills and layers model-tiering, mandatory review, and independent verification on top. Use for features, fixes, or refactors with more than a couple files of work, or whenever the user asks to orchestrate, delegate, or build something test-first.
Authoring constraints for every skill, command, and agent in this marketplace, so they run well on frontier models (Fable 5 today) and never silently fall back. Use when writing or editing any skill, command, or agent, or any orchestrator prompt that dispatches a subagent.
How model routing works across this marketplace - the PROFILE tiers, the one global Opus<->Fable switch, and the rule that no role is ever tied to a model name. Background knowledge for orchestrating, authoring agents, or switching the whole kit to a different model.
Uses power tools
Uses Bash, Write, or Edit tools
No model invocation
Executes directly as bash, bypassing the AI model
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
It looks like vibe coding. It's the opposite.
A personal Claude Code plugin marketplace that turns "vibe coding" into a disciplined, model-adaptive pipeline: idea → brief → scaffold → test-first build, where every diff is reviewed and an independent fresh-context verifier signs off before anything is called done. Same casual, one-command surface as vibe coding — TDD-first, mandatory review, and a separate verifier underneath.
The bet is on process, not a bigger model: tight contracts, staged review, and model-tiering are what make it good, and the whole kit flips from Opus 4.8 today to Fable 5 later with one environment variable and zero file edits.
/plugin marketplace add ysainson/vibe
/plugin install vibe@ysainson
Local development of the plugins themselves:
/plugin marketplace add /absolute/path/to/vibe
vibe — the core (stack-agnostic)The orchestration engine. Pure process — no framework knowledge.
| Component | What it is |
|---|---|
/vibe:setup | Brief-driven scaffolder: reads a project brief, asks only the gaps via vibe:clarify, detects the stack, scaffolds the skeleton + tooling baseline + CLAUDE.md (not features), and writes .claude/settings.json enabling the VIBE core and the matching stack overlay. User-only (disable-model-invocation: true). |
/vibe:brainstorm | Turn an idea into a written spec in docs/specs/ — wraps superpowers' brainstorming and applies VIBE's heuristics (two-phase build for visual-hero apps; numbered, test-first, commit-per-task plans). User-only. |
/vibe:conduct | Orchestrated coding flow: the session model plans, writes a failing test contract, lays out a numbered commit-per-task plan, delegates implementation to model-tiered doer subagents, reviews every diff in two passes, and gates completion through an independent fresh-context verifier. A thin command wrapper over the conduct skill — commands display namespaced (/vibe:*) in autocomplete while the backing skill carries user-invocable: false to stay model-invocable without a duplicate menu entry. |
/vibe:review | Comprehensive review of changed files — reviewer-quality + security-verifier, the enabled overlay's guardians (by file type), and any project-local .claude/agents/, plus a CLAUDE.md convention check. |
/vibe:commit | Conventional commit message from the diff → clipboard. User-only. |
/vibe:fix | Auto-fix only safe, mechanical issues (formatters/linters + project-local fixers); never security or behavior. User-only. |
/vibe:quick-check | Fast pre-commit sanity check on changed files — secrets scan + the overlay's quick guardians + project-local lightweight checks. |
vibe:doer | Implementation subagent (Sonnet by default). |
vibe:doer-mechanical | Mechanical-edit subagent (Haiku by default) — renames, codemods, boilerplate. |
vibe:reviewer-spec | Review pass 1: spec compliance — does the diff meet the contract, nothing gamed? |
vibe:reviewer-quality | Review pass 2: craft — simplicity, idioms, conventions, no scope creep. Kept separate from pass 1 because a blended review is easier to game. |
vibe:verifier | Fresh-context final gate — adversarial spec check on the diff with no implementation history. |
vibe:security-verifier | Security lens: secrets, injection, authz, data handling, dependencies. |
vibe:clarify | Hidden behavior skill: clarifying questions go through the AskUserQuestion tool (concrete options, recommended default, self-contained); defines when to ask vs state an assumption and proceed. |
vibe:profile-policy | Hidden knowledge skill: how model routing works — the PROFILE tiers and the one global Opus↔Fable switch. |
vibe:fable-safe-authoring | Hidden knowledge skill: authoring constraints so every skill/command/agent runs well on frontier models and never silently falls back. |
vibe-swift — Swift / macOS overlayThe first stack overlay. Enable it (via /vibe:setup or .claude/settings.json) when scaffolding or building a Swift / macOS project.
| Component | What it is |
|---|---|
vibe-swift:swift-concurrency | Reviews concurrency under Swift 6 mode + Approachable Concurrency — actor isolation, Sendable, safe async boundaries. |
vibe-swift:swift-testability | Reviews the single-source-of-truth + injected-protocol pattern that makes logic unit-testable without real system APIs. |
vibe-swift:swift-signing | Pre-flights Developer ID signing, notarization, and Sparkle auto-update before a release. |
vibe-swift:swift-scaffold | Hidden knowledge skill: the canonical macOS project shape (single-target SwiftUI, @Observable source of truth, Swift Testing, Developer ID + Sparkle release pipeline), with testability and distribution references. |
Depends on the re-exported swiftui-expert and swift-testing-expert skills.
VIBE overlay for Swift / macOS. Ships concurrency, testability, and signing guardian agents and the Swift scaffold knowledge /vibe:setup uses. Resolves the latest stable Swift/Xcode/macOS toolchain at scaffold time.
npx claudepluginhub ysainson/vibe --plugin vibeComplete creative writing suite with 10 specialized agents covering the full writing process: research gathering, character development, story architecture, world-building, dialogue coaching, editing/review, outlining, content strategy, believability auditing, and prose style/voice analysis. Includes genre-specific guides, templates, and quality checklists.
Unity Development Toolkit - Expert agents for scripting/refactoring/optimization, script templates, and Agent Skills for Unity C# development
Comprehensive .NET development skills for modern C#, ASP.NET, MAUI, Blazor, Aspire, EF Core, Native AOT, testing, security, performance optimization, CI/CD, and cloud-native applications
Complete collection of battle-tested Claude Code configs from an Anthropic hackathon winner - agents, skills, hooks, and rules evolved over 10+ months of intensive daily use
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Tools to maintain and improve CLAUDE.md files - audit quality, capture session learnings, and keep project memory current.