Frontend

Comprehensive guide for initializing or reorganizing agent memory and project context. Use when setting up a new project, when the user asks you to learn about the codebase, or when you need to create effective memory blocks for project conventions, preferences, and workflows.

Creates unique, production-grade frontend interfaces with exceptional design quality. Use when user asks to build web components, pages, materials, posters, or applications (e.g., websites, landing pages, dashboards, React components, HTML/CSS layouts, or styling/beautifying any web UI). Generates creative, polished code and UI designs that avoid mediocre AI aesthetics.

Guides systematic code refactoring following the DRY (Don't Repeat Yourself) principle. Use when user asks to eliminate code duplication, refactor repetitive code, apply DRY principle, or mentions code smells like copy-paste, magic numbers, or repeated logic. Implements a 4-step workflow from identifying repetition to verified refactoring.

This skill should be used when the user asks to "analyze my product", "research competitors", "find feature gaps", "create feature request", "prioritize backlog", "generate PRD", "plan roadmap", "what should we build next", "competitive analysis", "gap analysis", "sync issues", or mentions product management workflows. Provides AI-native PM capabilities for startups with signal-based feature tracking, the WINNING prioritization filter, and GitHub Issues integration with deduplication.

Systematic approach for creating minimal-change, reversible implementation plans. Claude invokes this skill when transforming requirements/research into executable blueprints. Emphasizes simplicity, safety, and clear verification steps.

Systematic validation methodology for ResearchPacks and Implementation Plans. Provides scoring rubrics and quality gates to ensure outputs meet standards before proceeding to next phase. Prevents garbage-in-garbage-out scenarios.

Complete guide for writing Claude Code and SDK hooks with security-first design. Triggers: hook creation, hook writing, PreToolUse, PostToolUse, UserPromptSubmit, tool validation, logging hooks, context injection, workflow automation Use when: creating new hooks for tool validation, logging operations for audit, injecting context before prompts, enforcing project-specific workflows, preventing dangerous operations in production DO NOT use when: logic belongs in core skill - use Skills instead. DO NOT use when: complex multi-step workflows needed - use Agents instead. DO NOT use when: behavior better suited for custom tool. Use this skill BEFORE writing any hook. Check even if unsure.

Foundational workflow for preparing and structuring detailed reviews (architecture, API, code quality). Triggers: review workflow, structured review, review scaffolding, evidence capture, review preparation, analysis framework, review template Use when: starting any detailed review workflow, needing consistent structure for capturing context and findings, ensuring comparable review outputs DO NOT use when: quick catchup without formal review - use catchup. DO NOT use when: diff-focused analysis - use diff-analysis. Use this skill at the BEGINNING of any detailed review for consistent structure.

Update and maintain tests following TDD/BDD principles with detailed quality assurance. Triggers: test updates, test maintenance, test generation, TDD workflow, BDD patterns, test coverage, pytest, test enhancement, quality assurance Use when: updating existing tests, generating new tests for features, enhancing test quality, ensuring detailed coverage, pre-commit validation DO NOT use when: auditing test suites - use pensive:test-review. DO NOT use when: writing production code - focus on implementation first. Run git-workspace-review first to understand which tests need updates.

Analyze and enhance Makefiles for complete user functionality coverage. Triggers: Makefile analysis, Makefile gaps, missing targets, plugin release, Makefile coverage, build targets, make dogfood, plugin quality Use when: analyzing Makefile completeness before releasing plugins, identifying gaps during plugin maintenance, scoring Makefiles against best practices, verifying Makefiles support standard developer workflows DO NOT use when: writing initial Makefiles from scratch. DO NOT use when: debugging specific build target failures. DO NOT use when: creating custom non-standard build systems. Use this skill BEFORE releasing any plugin to verify Makefile coverage.

Methodology for summarizing changes, extracting insights, and identifying follow-up actions. Triggers: catchup, what changed, summarize changes, context acquisition, handoff, progress review, recent changes, git log analysis, sprint summary Use when: resuming work after absence, preparing handoff documentation, reviewing sprint progress, analyzing git history for context DO NOT use when: doing detailed diff analysis - use diff-analysis instead. DO NOT use when: full code review needed - use review-core instead. Use this skill to quickly understand "what changed and what matters".

Workflow for capturing evidence and citations to create reproducible analyses and audit trails. Triggers: evidence capture, citations, reproducible analysis, audit trail, documentation, evidence logging, findings documentation Use when: conducting any review that needs evidence trails, creating audit documentation, ensuring reproducibility of analyses DO NOT use when: quick informal checks without documentation needs. DO NOT use when: structured output is the focus - use structured-output. Use this skill as foundation for all evidence-based review workflows.

Design and construct virtual memory palaces for spatial knowledge organization using mnemonic techniques. Triggers: memory palace, spatial organization, mnemonic, knowledge architecture, domain mapping, layout design, memory structure, recall enhancement Use when: creating new memory palace structures, organizing complex domains, designing spatial layouts for knowledge retention DO NOT use when: quick knowledge search - use knowledge-locator instead. DO NOT use when: session-specific context - use session-palace-builder. Consult this skill when designing permanent memory palace structures.

Reusable patterns and templates for Claude Code skill and hook development. Triggers: validation patterns, error handling, testing templates, workflow patterns, shared patterns, reusable templates, DRY patterns, common workflows Use when: creating new skills or hooks that need consistent patterns, implementing validation logic, setting up error handling, creating test scaffolding, referencing standard workflow structures DO NOT use when: pattern is specific to one skill only. DO NOT use when: pattern is still evolving - wait for stability. DO NOT use when: pattern is context-dependent requiring variations. Reference these patterns to validate consistency across the ecosystem.

Python testing with pytest, fixtures, mocking, and TDD workflows. Triggers: pytest, unit tests, test fixtures, mocking, TDD, test suite, coverage, test-driven development, testing patterns, parameterized tests Use when: writing unit tests, setting up test suites, implementing TDD, configuring pytest, creating fixtures, async testing DO NOT use when: evaluating test quality - use pensive:test-review instead. DO NOT use when: infrastructure test config - use leyline:pytest-config. Consult this skill for Python testing implementation and patterns.

Use a Layered (N-Tier) architecture to separate presentation, domain logic, and data access responsibilities within a system. Triggers: layered architecture, n-tier, separation of concerns, presentation layer, data access layer, service layer, traditional architecture, monolith structure, layer enforcement, dependency direction Use when: building traditional applications with clear boundaries, working with moderate-sized teams, needing familiar and well-understood patterns, compliance requirements demand clear separation DO NOT use when: selecting from multiple paradigms - use architecture-paradigms first. DO NOT use when: high scalability needs independent component scaling. DO NOT use when: teams need independent deployment cycles - use microservices. Consult this skill when implementing layered patterns or enforcing layer boundaries.

Enforces "prove before claim" discipline - validation, testing, and evidence requirements before declaring work complete. Triggers: completion, finished, done, working, should work, configured, ready to use, implemented, fixed Use when: claiming ANY work is complete, recommending solutions, stating something will work, finishing implementations DO NOT use when: explicitly asking questions or requesting clarification DO NOT use when: work is clearly in-progress and not claiming completion CRITICAL: This skill is MANDATORY before any completion claim. Violations result in wasted time and eroded trust.

Guide to effective Claude Code skill authoring using TDD methodology and persuasion principles. Triggers: skill authoring, skill writing, new skill, TDD skills, skill creation, skill best practices, skill validation, skill deployment, skill compliance Use when: creating new skills from scratch, improving existing skills with low compliance rates, learning skill authoring best practices, validating skill quality before deployment, understanding what makes skills effective DO NOT use when: evaluating existing skills - use skills-eval instead. DO NOT use when: analyzing skill architecture - use modular-skills instead. DO NOT use when: writing general documentation for humans. YOU MUST write a failing test before writing any skill. This is the Iron Law.

Record browser sessions using Playwright for web UI tutorials. Captures video of browser interactions that can be converted to GIF. Triggers: browser recording, playwright, web demo, ui recording Use when: creating browser-based tutorials showing web UI interactions

Employ the Hexagonal (Ports & Adapters) pattern to decouple domain logic from infrastructure, maximizing flexibility and testability. Triggers: hexagonal architecture, ports and adapters, infrastructure independence, dependency inversion, clean architecture, domain isolation, adapter pattern, infrastructure abstraction, database independence, framework independence Use when: designing systems with strong business logic separation, anticipating infrastructure changes, needing easy mocking for tests, building portable domain code DO NOT use when: selecting from multiple paradigms - use architecture-paradigms first. DO NOT use when: building simple CRUD apps without complex domain logic. Consult this skill when implementing hexagonal patterns or migrating to port-based design.