rafayels-engineering

Run comprehensive agent-native architecture review with scored principles

Create engaging changelogs for recent merges to main branch

Delegate a coding task to the OpenAI Codex CLI agent. Use when you want Codex to write, review, or refactor code for you.

Create or edit Claude Code skills with expert guidance on structure and best practices

Enhance a plan with parallel research agents for each section to add depth, best practices, and implementation details

Validate and prepare documentation for GitHub Pages deployment

Record a video walkthrough of a feature and add it to the PR description

Create a new custom slash command following conventions and best practices

Fix incorrect SKILL.md files when a skill has wrong instructions or outdated API references

Full autonomous engineering workflow

Configure the rafayels-engineering plugin for an existing repository — sets up documentation paths, project details, and installs skills with repo-specific context baked in.

End-to-end feature pipeline — from idea to merged PR with documentation updates. Orchestrates brainstorm, plan, work, review, and compound workflows.

Audit the memory layer case bank — view stats, prune stale cases, inspect patterns, and trigger auto-PR generation for learned patterns.

Create a new repository from scratch with the rafayels-engineering plugin installed, documentation structure, and project-specific skills baked in.

Run frontend design improvement loop — assess, improve, document, repeat

Pull the latest rafayels-engineering plugin and refresh repo-specific skills with current project context. Run after plugin updates or when CLAUDE.md changes.

Build and update the documentation site with current plugin components

Report a bug in the compound-engineering plugin

Reproduce and investigate a bug using logs, console inspection, and browser screenshots

Resolve all TODO comments using parallel processing

Resolve all pending CLI todos using parallel processing

Full autonomous engineering workflow using swarm mode for parallel execution

Have multiple specialized agents review the technical approach and architecture of a plan in parallel

Run browser tests on pages affected by current PR or branch

Build and test iOS apps on simulator using XcodeBuildMCP

Triage and categorize findings for the CLI todo system

Explore requirements and approaches through collaborative dialogue before planning implementation

Document a recently solved problem to compound your team's knowledge

Transform feature descriptions into well-structured project plans following conventions

Perform exhaustive code reviews using multi-agent analysis, ultra-thinking, and worktrees

Execute work plans efficiently while maintaining quality and finishing features

You are a specialized agent whose sole purpose is to delegate coding tasks to OpenAI Codex and report back the results to the team lead (Claude).

Visually compares live UI implementation against Figma designs and provides detailed feedback on discrepancies. Use after writing or modifying HTML/CSS/React components to verify design fidelity.

Iteratively refines UI design through N screenshot-analyze-improve cycles. Use PROACTIVELY when design changes aren't coming together after 1-2 attempts, or when user requests iterative refinement.

Detects and fixes visual differences between a web implementation and its Figma design. Use iteratively when syncing implementation to match Figma specs.

Creates or updates README files following Effective Go style and conventions. Use when writing Go project documentation with clear, idiomatic prose and standard section ordering.

Researches and synthesizes external best practices, documentation, and examples for any technology or framework. Use when you need industry standards, community conventions, or implementation guidance.

Gathers comprehensive documentation and best practices for frameworks, libraries, or dependencies. Use when you need official docs, version-specific constraints, or implementation patterns.

Performs archaeological analysis of git history to trace code evolution, identify contributors, and understand why code patterns exist. Use when you need historical context for code changes.

Searches docs/solutions/ for relevant past solutions by frontmatter metadata. Use before implementing features or fixing problems to surface institutional knowledge and prevent repeated mistakes.

Conducts thorough research on repository structure, documentation, conventions, and implementation patterns. Use when onboarding to a new codebase or understanding project conventions.

Searches Obsidian vault for organizational context — ADRs, dev logs, meeting notes, project docs. Use when planning, brainstorming, or when user asks about vault contents, notes, knowledge base, or past decisions.

Reviews code to ensure agent-native parity — any action a user can take, an agent can also take. Use after adding UI features, agent tools, or system prompts.

Analyzes code changes from an architectural perspective for pattern compliance and design integrity. Use when reviewing PRs, adding services, or evaluating structural refactors.

Brutally honest Go/Chi code review. Use when reviewing Go code for anti-patterns, overengineering, or violations of Go and Chi router conventions.

Reviews CLI code for agent-friendliness — structured output, --json flags, deterministic behavior, parseable errors. Use when PRs add or modify CLI commands, scripts, or automation code.

Final review pass to ensure code is as simple and minimal as possible. Use after implementation is complete to identify YAGNI violations and simplification opportunities.

Reviews database migrations, data models, and persistent data code for safety. Use when checking migration safety, data constraints, transaction boundaries, or privacy compliance.

Validates data migrations, backfills, and production data transformations against reality. Use when PRs involve ID mappings, column renames, enum conversions, or schema changes.

Produces Go/No-Go deployment checklists with SQL verification queries, rollback procedures, and monitoring plans. Use when PRs touch production data, migrations, or risky data changes.

Reviews JavaScript and Stimulus code for race conditions, timing issues, and DOM lifecycle problems. Use after implementing or modifying frontend controllers or async UI code.

Analyzes code for design patterns, anti-patterns, naming conventions, and duplication. Use when checking codebase consistency or verifying new code follows established patterns.

Analyzes code for performance bottlenecks, algorithmic complexity, database queries, memory usage, and scalability. Use after implementing features or when performance concerns arise.

Reviews Go code with an extremely high quality bar for conventions, clarity, and maintainability. Use after implementing features, modifying code, or creating new Go packages.

Reviews Python code with an extremely high quality bar for Pythonic patterns, type safety, and maintainability. Use after implementing features, modifying code, or creating new Python modules.

Reviews SvelteKit code with an extremely high quality bar for conventions, patterns, and maintainability. Use after implementing features, modifying code, or creating new SvelteKit components.

Reviews TypeScript code with an extremely high quality bar for type safety, modern patterns, and maintainability. Use after implementing features, modifying code, or creating new TypeScript components.

Detects unrelated schema.rb changes in PRs by cross-referencing against included migrations. Use when reviewing PRs with database schema changes.

Performs security audits for vulnerabilities, input validation, auth/authz, hardcoded secrets, and OWASP compliance. Use when reviewing code for security issues or before deployment.

Systematically reproduces and validates bug reports to confirm whether reported behavior is an actual bug. Use when you receive a bug report or issue that needs verification.

Runs linting and code quality checks on Go and TypeScript files. Use before pushing to origin.

Addresses PR review comments by implementing requested changes and reporting resolutions. Use when code review feedback needs to be resolved with code changes.

Analyzes specifications and feature descriptions for user flow completeness and gap identification. Use when a spec, plan, or feature description needs flow analysis, edge case discovery, or requirements validation.

Browser automation using Vercel's agent-browser CLI. Use when you need to interact with web pages, fill forms, take screenshots, or scrape data. Alternative to Playwright MCP - uses Bash commands with ref-based element selection. Triggers on "browse website", "fill form", "click button", "take screenshot", "scrape page", "web automation".

Upload, sync, and manage files across cloud storage providers using rclone. Use when uploading files (images, videos, documents) to S3, Cloudflare R2, Backblaze B2, Google Drive, Dropbox, or any S3-compatible storage. Triggers on "upload to S3", "sync to cloud", "rclone", "backup files", "upload video/image to bucket", or requests to transfer files to remote storage.

Resolve all PR comments using parallel processing. Use when addressing PR review feedback, resolving review threads, or batch-fixing PR comments.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Build applications where agents are first-class citizens. Use this skill when designing autonomous agents, creating MCP tools, implementing self-modifying systems, or building apps where features are outcomes achieved by agents operating in a loop.

This skill should be used before implementing features, building components, or making changes. It guides exploring user intent, approaches, and design decisions before planning. Triggers on "let's brainstorm", "help me think through", "what should we build", "explore approaches", ambiguous feature requests, or when the user's request has multiple valid interpretations that need clarification.

Run all quality checks (Go lint, frontend lint, typecheck). Use before committing, creating PRs, or when you need to verify code quality passes.

Capture solved problems as categorized documentation with YAML frontmatter for fast lookup

Expert guidance for creating Claude Code skills and slash commands. Use when working with SKILL.md files, authoring new skills, improving existing skills, creating slash commands, or understanding skill structure and best practices.

Delegate coding tasks to the OpenAI Codex CLI agent. Use when the user explicitly asks to use Codex, for quick code generation spikes, or when parallelizing implementation work across multiple AI agents.

Create or update today's dev log entry in the Obsidian vault. Use after merging a PR or completing significant work.

This skill should be used to refine brainstorm or plan documents before proceeding to the next workflow step. It applies when a brainstorm or plan document exists and the user wants to improve it.

This skill should be used when reviewing or editing copy to ensure adherence to Every's style guide. It provides a systematic line-by-line review process for grammar, punctuation, mechanics, and style guide compliance.

This skill should be used when managing the file-based todo tracking system in the todos/ directory. It provides workflows for creating todos, managing status and dependencies, conducting triage, and integrating with slash commands and code review processes.

Auto-fix lint and formatting issues in Go and frontend code. Use when /check reports fixable violations or after writing new code.

This skill should be used when creating distinctive, production-grade frontend interfaces with high design quality. It applies when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

This skill should be used when generating and editing images using the Gemini API (Nano Banana Pro). It applies when creating images from text prompts, editing existing images, applying style transfers, generating logos with text, creating stickers, product mockups, or any image generation/manipulation task. Supports text-to-image, image editing, multi-turn refinement, and composition from multiple reference images.

Set up a fresh clone for development. Run when node_modules/ is missing, git hooks are not configured, or after first clone.

This skill manages Git worktrees for isolated parallel development. It handles creating, listing, switching, and cleaning up worktrees with a simple interactive interface, following KISS principles.

Manage GitHub repositories, issues, pull requests, releases, actions, and more using the gh CLI. Use when creating repos, managing issues/PRs, checking CI status, creating releases, or any GitHub operations.

Detects emerging patterns in the memory case bank and proposes skill updates as reviewable draft PRs. Depends on the `memory` skill. Use when the user wants to surface recurring successful patterns and optionally encode them into skill files.

Persistent cross-session case-based memory for rafayels-engineering. Records successful patterns, failed attempts, user corrections, and review outcomes as cases in a local sqlite-vec database. Inject relevant past cases into workflows at runtime. Use when the user asks to remember something, recall prior context, review the case bank, or runs workflows that benefit from learned patterns.

This skill should be used when orchestrating multi-agent swarms using Claude Code's TeammateTool and Task system. It applies when coordinating multiple agents, running parallel code reviews, creating pipeline workflows with dependencies, building self-organizing task queues, or any task benefiting from divide-and-conquer patterns.

Frontend design improvement loop — autonomous evaluate-improve harness using Claude Agent SDK. Assesses pages with deterministic metrics (Lighthouse, axe, CSS) and subjective quality scoring (impeccable.style /audit + /critique methodology), then iteratively improves them. Triggers on 'improve design', 'design loop', 'ralph lauren', 'frontend quality'.

Run all tests (Go unit tests + frontend tests). Use after implementing features, fixing bugs, or before creating PRs to verify correctness.

Use when designing, planning, or implementing features — requires checking existing Architecture Decision Records via semantic search and graph traversal before making decisions. Also use when making architectural decisions that should be recorded as new ADRs.

gopls

pyright-langserver

svelteserver

typescript-language-server