vibeworks-library

Create an Architecture Decision Record documenting a technical decision with context and alternatives

Run a comprehensive audit covering security, dependencies, performance, and code quality

Cancel active Ralph Loop

Code review a pull request

Guided end-to-end plugin creation workflow with component design, implementation, and validation

Systematically debug an issue using hypothesis-driven investigation and binary search isolation

Complete a design review of the pending changes on the current branch

Generate a high-quality UI design from a natural language brief using autonomous multi-agent orchestration

Generate documentation for code, APIs, or project structure

Guided feature development with codebase understanding and architecture focus

Git workflow assistance — create branches, write commit messages, prepare PRs, resolve conflicts

Create an implementation plan for a feature with architecture design and task breakdown

Conduct a comprehensive code review of the pending changes on the current branch based on the Pragmatic Quality framework.

Explain Ralph Loop plugin and available commands

Start Ralph Loop in current session

Safely refactor code using named patterns with test verification at each step

Analyze recent work for a retrospective — what went well, what could improve, action items

Review and improve an existing UI design using the multi-agent quality pipeline

Code review current changes with multi-aspect analysis and confidence scoring

Complete a security review of the pending changes on the current branch

Start a TDD workflow — writes failing test first, then implements, then refactors

Creates and manages photorealistic 3D scenes and models using Three.js and React Three Fiber. Autonomously iterates to achieve photorealism through visual self-critique.

Performs comprehensive accessibility evaluation beyond WCAG contrast, including touch targets, keyboard navigation, screen reader compatibility, form accessibility, and ARIA usage. Use this agent for deep accessibility audits. Implements autonomous quality refinement through an internal Ralph Wiggum Loop.

You are an elite AI agent architect specializing in crafting high-performance agent configurations. Your expertise lies in translating user requirements into precisely-tuned agent specifications that maximize effectiveness and reliability.

Designs and implements complex, self-improving animations using GSAP. Creates fluid, expressive, and performant animations with autonomous refinement.

Designs software architecture by analyzing existing patterns, proposing solutions with trade-offs, and creating implementation blueprints. Use for system design, feature planning, or architecture review.

Evaluates design alignment with brand guidelines including personality consistency, visual identity coherence, tone matching, and sector appropriateness. Use this agent when reviewing brand consistency. Implements autonomous quality refinement through an internal Ralph Wiggum Loop.

Designs feature architectures by analyzing existing codebase patterns and conventions, then providing comprehensive implementation blueprints with specific files to create/modify, component designs, data flows, and build sequences

Deeply analyzes existing codebase features by tracing execution paths, mapping architecture layers, understanding patterns and abstractions, and documenting dependencies to inform new development

Reviews code for bugs, logic errors, security vulnerabilities, code quality issues, and adherence to project conventions, using confidence-based filtering to report only high-priority issues that truly matter

Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.

Color design critic that evaluates contrast ratios, color harmony, emotional impact, sector appropriateness, and uniqueness. Use this agent to audit color choices and accessibility.

Specialized agent for code refactoring that improves code quality while preserving functionality

Systematic debugging agent that isolates bugs through hypothesis-driven investigation, binary search, strategic logging, and root cause analysis. Use when tracking down errors, unexpected behavior, or test failures.

UI implementation specialist that creates production-ready HTML, CSS, and design tokens. Implements accessibility-first layouts, smart component generation, and design system creation. Use this agent when generating new designs or implementing improvements from review feedback.

THE PRIMARY UI DESIGN AGENT. Use this agent for ANY UI design task including: creating landing pages, dashboards, components, forms, design systems, web pages, mobile layouts, or any visual interface work. Also use for UI reviews, design critiques, improving existing UIs, accessibility audits, and design system creation. This is the ONLY agent to use when the user mentions UI, UX, design, interface, layout, styling, components, pages, screens, or visual design.

Evaluates design performance including CSS efficiency, asset optimization, loading strategies, and runtime performance. Use this agent to ensure generated designs are fast and efficient. Implements autonomous quality refinement through an internal Ralph Wiggum Loop.

Design research specialist that gathers sector-specific patterns, competitor analysis, emerging trends, and creative direction. Use this agent at the start of a design project or when pivoting to a new approach.

Use this agent when you need to conduct a comprehensive design review on front-end pull requests or general UI changes. This agent should be triggered when a PR modifying UI components, styles, or user-facing features needs review; you want to verify visual consistency, accessibility compliance, and user experience quality; you need to test responsive design across different viewports; or you want to ensure that new UI changes meet world-class design standards. The agent requires access to a live preview environment and uses Playwright for automated interaction testing. Example - "Review the design changes in PR 234"

Design review orchestrator that runs the parallel critic pipeline (spatial, color, typography, vibe-code) and synthesizes feedback into actionable insights. Use this agent after generating a design to evaluate quality and identify improvements.

Technical writer that creates clear documentation — READMEs, API docs, inline comments, changelogs, and architecture docs. Use for any documentation task.

Implements user interactions with 3D scenes, including camera controls, mouse tracking, and responsive behaviors. Bridges user input with 3D environments.

A critic agent that analyzes web performance using Lighthouse and browser developer tools. Use to get performance reports on running websites or built applications.

You are an expert plugin validator specializing in comprehensive validation of Claude Code plugin structure, configuration, and components.

Use this agent when you need a thorough code review that balances engineering excellence with development velocity. This agent should be invoked after completing a logical chunk of code, implementing a feature, or before merging a pull request. The agent focuses on substantive issues but also addresses style. Examples: - <example> Context: After implementing a new API endpoint user: "I've added a new user authentication endpoint" assistant: "I'll review the authentication endpoint implementation using the pragmatic-code-review agent" <commentary> Since new code has been written that involves security-critical functionality, use the pragmatic-code-review agent to ensure it meets quality standards. </commentary> </example> - <example> Context: After refactoring a complex service user: "I've refactored the payment processing service to improve performance" assistant: "Let me review these refactoring changes with the pragmatic-code-review agent" <commentary> Performance-critical refactoring needs review to ensure improvements don't introduce regressions. </commentary> </example> - <example> Context: Before merging a feature branch user: "The new dashboard feature is complete and ready for review" assistant: "I'll conduct a comprehensive review using the pragmatic-code-review agent before we merge" <commentary> Complete features need thorough review before merging to main branch. </commentary> </example>

Safe refactoring agent that identifies code smells, applies named refactoring patterns, and verifies correctness through tests. Use for code cleanup, simplification, or structural improvement.

Thorough code reviewer that checks correctness, readability, security, performance, and project convention adherence. Uses confidence scoring to filter noise. Use for code review of any changes.

Security-focused auditor that checks for OWASP vulnerabilities, authentication issues, authorization gaps, injection flaws, and secrets exposure. Use for security review of code or architecture.

Creates and refines custom WebGL shaders for unique visual effects. Specializes in realistic atmospheric effects, materials, and GPU-accelerated visuals.

You are an expert skill architect specializing in reviewing and improving Claude Code skills for maximum effectiveness and reliability.

Spatial design critic that evaluates grid consistency, spacing relationships, alignment, visual balance, and whitespace usage. Use this agent to audit layout and spacing quality.

Guides test-driven development by writing failing tests first, then minimal implementations, then refactoring. Use for any TDD workflow, writing tests before code, or implementing features test-first.

Designs testing strategies including test pyramid balance, coverage gaps, mocking approaches, and test infrastructure. Use when planning test suites or evaluating test quality.

Typography design critic that evaluates font pairing, visual hierarchy, readability, line length, and typographic consistency. Use this agent to audit typography quality.

Design originality critic that detects generic AI-generated patterns, stock design elements, and "vibe-coded" aesthetics. Use this agent to ensure designs feel human-crafted and unique.

This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.

REST and API design principles — resource naming, HTTP methods, status codes, pagination, versioning, and error responses. Reference when designing or reviewing APIs.

ADR format and methodology for documenting significant technical decisions with context, alternatives considered, and consequences. Use when making or documenting architectural decisions.

Branch naming conventions, Git Flow vs trunk-based development, feature branch lifecycle, and release strategies. Reference when creating branches, planning releases, or choosing a branching model.

Comprehensive code review criteria covering correctness, readability, maintainability, security, performance, and testing. Reference when reviewing code changes or preparing code for review.

This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.

Perform thorough, constructive code reviews on pull requests and code changes. Use when the user asks to review code, review a PR, check code quality, or provide code feedback.

Generate well-formatted conventional commit messages from staged changes. Use when the user asks to commit changes, write a commit message, or follows the conventional commits standard.

Database migration best practices — schema changes, zero-downtime migrations, rollback strategies, and data migration patterns. Reference when modifying database schemas.

Systematic debugging methodology — binary search isolation, hypothesis-driven debugging, reproducing issues, and root cause analysis. Use when debugging errors, unexpected behavior, or test failures.

Dependency management and auditing — evaluating new dependencies, security vulnerability scanning, update strategies, and license compliance. Use when adding or auditing dependencies.

Reference library of proven UI design patterns, component templates, and sector-specific conventions for high-quality design generation.

This skill should be used when the user asks to "design a UI", "create a landing page", "build a dashboard", "generate a website design", "make a product page", or needs guidance on UI design patterns, accessibility standards, design tokens, or eliminating generic AI-generated design patterns (vibe-code).

Manage your Discord server - post announcements, create events, moderate, and more. Use when the user mentions Discord, wants to post announcements, manage events, moderate channels, or check server status.

Documentation best practices — README structure, inline code comments, API docs, changelogs, and technical writing principles. Reference when writing any documentation.

Error handling best practices across languages — error types, recovery strategies, user-facing messages, and logging. Reference when implementing error handling or designing error flows.

End-of-day wrap up - analyzes all work done, creates detailed daily update log, commits all changes, and pushes to remote. Use when user says "finish the day", "end of day", "wrap up", or at end of work session.

Git best practices including commit message conventions, interactive rebase, conflict resolution, and repository hygiene. Reference for all git operations.

This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.

Incident response procedures — triage, communication, investigation, mitigation, and post-incident review. Use when handling production incidents or writing runbooks.

Logging and observability best practices — structured logging, log levels, correlation IDs, metrics, tracing, and alerting. Reference when implementing logging or monitoring.

This skill should be used when the user asks to "add MCP server", "integrate MCP", "configure MCP in plugin", "use .mcp.json", "set up Model Context Protocol", "connect external service", mentions "${CLAUDE_PLUGIN_ROOT} with MCP", or discusses MCP server types (SSE, stdio, HTTP, WebSocket). Provides comprehensive guidance for integrating Model Context Protocol servers into Claude Code plugins for external tool and service integration.

Performance analysis methodology — identifying bottlenecks, profiling techniques, benchmarking, and common optimization patterns. Use when investigating or improving performance.

This skill should be used when the user asks about "plugin settings", "store plugin configuration", "user-configurable plugin", ".local.md files", "plugin state files", "read YAML frontmatter", "per-project plugin settings", or wants to make plugin behavior configurable. Documents the .claude/plugin-name.local.md pattern for storing plugin-specific configuration with YAML frontmatter and markdown content.

This skill should be used when the user asks to "create a plugin", "scaffold a plugin", "understand plugin structure", "organize plugin components", "set up plugin.json", "use ${CLAUDE_PLUGIN_ROOT}", "add commands/agents/skills/hooks", "configure auto-discovery", or needs guidance on plugin directory layout, manifest configuration, component organization, file naming conventions, or Claude Code plugin architecture best practices.

Pull request authoring standards — structured descriptions, linking issues, providing test evidence, and writing good summaries. Reference when creating or describing pull requests.

Quality gate definitions, scoring rubrics, and acceptance criteria for the Agentic UI Designer system.

Safe refactoring techniques — extract method, rename, move, inline, and structural patterns. Includes code smell identification and transformation recipes. Use when refactoring code or improving structure.

Security review checklist covering OWASP Top 10, authentication, authorization, input validation, secrets management, and common vulnerability patterns. Reference when reviewing code for security.

This skill should be used when the user wants to "create a skill", "add a skill to plugin", "write a new skill", "improve skill description", "organize skill content", or needs guidance on skill structure, progressive disclosure, or skill development best practices for Claude Code plugins.

Comprehensive daily project sync - checks git repos, analyzes all code, reads documentation, and provides status report. Use when user says "start of day", "daily sync", "project status", or at beginning of work session.

Test-driven development methodology — red-green-refactor cycle, writing failing tests first, minimal implementation, and iterative refinement. Use when implementing features test-first, when the user asks for TDD, or when writing tests before code.

Test pyramid and testing strategy — unit, integration, and end-to-end test ratios, mocking strategies, test isolation, and what to test. Reference when planning test coverage or evaluating test quality.

UI/UX design intelligence. 50 styles, 21 palettes, 50 font pairings, 20 charts, 9 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, mobile app, .html, .tsx, .vue, .svelte. Elements: button, modal, navbar, sidebar, card, table, form, chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, flat design. Topics: color palette, accessibility, animation, layout, typography, font pairing, spacing, hover, shadow, gradient. Integrations: shadcn/ui MCP for component search and examples.

5 hooks across 3 events