Documentation

Write consistent, maintainable CSS following the project's methodology (Tailwind, BEM, utility classes, CSS modules) with design system adherence and performance optimization. Use this skill when writing or modifying styles, CSS files, utility classes, CSS-in-JS, styled components, or any styling code. Apply when working with .css, .scss, .module.css files, Tailwind utility classes, styled-components, CSS modules, design tokens (colors, spacing, typography), framework-specific styling approaches, optimizing CSS for production, implementing CSS purging or tree-shaking, or avoiding style overrides. Use for any task involving visual styling, layout styling, design system implementation, or CSS organization.

Prevent common testing anti-patterns that undermine test effectiveness and code quality by ensuring tests verify real behavior rather than mock behavior, keeping production code free from test-only pollution, and enforcing thoughtful mocking strategies. Use this skill when writing or modifying any test files (.test.ts, .test.js, .spec.ts, _test.py, test_*.py, *_test.go, *_spec.rb), when adding mock objects, stubs, spies, or test doubles to test suites, when considering adding methods or properties to production classes that are only called from test code, when setting up complex test fixtures or test data, when tests are failing and you're tempted to adjust mocks to make them pass, when deciding how to isolate code under test from external dependencies, when implementing dependency injection or test seams, during code reviews when reviewing test implementation and mocking strategies, when refactoring tests that have become brittle or hard to maintain, when test setup code is becoming longer than the actual te

Use when creating agents.md files - provides plain markdown format with NO frontmatter, free-form structure, and project context guidelines for AI coding assistants

Write clean, consistent code following naming conventions, automated formatting, DRY principles, small focused functions, and meaningful variable names across all languages and files. Use this skill when writing or modifying any code file in any language or framework. Apply when naming variables, functions, classes, or files, when refactoring code to remove duplication, when breaking down large functions into smaller focused ones, when cleaning up dead code or unused imports, when ensuring consistent indentation and formatting, when choosing descriptive names over abbreviations, or when following the project's linting and formatting rules (ESLint, Prettier, RuboCop, Black, etc.). Use for any task involving code organization, readability, maintainability, or style consistency across the codebase.

Systematically review completed code implementations against original plans, requirements, and coding standards to ensure quality, plan alignment, and best practices adherence. Use this skill after completing any significant implementation work including features, refactorings, bug fixes, or architectural changes, when a numbered step or phase from a planning document has been finished, after implementing multiple related functions or components that form a logical unit, when finishing work that was specified in a technical specification or design document, after making substantial changes to existing code or architecture, before creating pull requests to validate implementation quality, when completing API endpoints, service layers, or data access implementations, after implementing test suites for new functionality, when refactoring code to ensure no behavior was inadvertently changed, after integrating with external systems or third-party services, when finishing user-facing features to verify requirements

Use when creating Continue rules - provides required name field, alwaysApply semantics, glob/regex patterns, and markdown format with optional frontmatter

Apply rigorous test-driven development methodology following the Red-Green-Refactor cycle (write failing test, implement minimal code to pass, refactor while staying green) that ensures tests genuinely verify behavior by requiring observed failure before implementation, preventing untested code and false-positive tests. Use this skill when implementing any new feature or functionality in any programming language, when fixing bugs or resolving defects in existing code, when refactoring code to improve design while preserving behavior, when adding new methods, functions, classes, or modules to a codebase, when modifying existing behavior or business logic, when writing code in any file that will be executed in production environments, when creating API endpoints, service methods, or controller actions, when implementing data validation, transformation, or processing logic, when building user interface components with testable behavior, when writing algorithms, calculations, or business rules, when integrating w

Follow consistent project structure, clear documentation, version control best practices, environment configuration, dependency management, code review processes, and feature flag usage for maintainable team development. Use this skill when organizing project files and directories, writing or updating documentation (README files, architecture docs, contribution guidelines), managing dependencies (package.json, requirements.txt, Gemfile), configuring environment variables, implementing feature flags, writing commit messages, creating pull/merge requests, or establishing team development workflows. Apply when setting up project structure, documenting setup instructions, managing configuration files, maintaining changelogs, or implementing development conventions. Use for any task involving project organization, team collaboration standards, or development workflow best practices.

Implement robust error handling with user-friendly messages, specific exception types, fail-fast validation, centralized error handling, graceful degradation, retry strategies, and proper resource cleanup. Use this skill when implementing error handling logic, try-catch blocks, exception handling, error boundaries, validation checks, API error responses, or resource cleanup. Apply when writing error handling in API controllers, service layers, frontend error boundaries, input validation, external service calls with retry logic, error logging, user-facing error messages, finally blocks for resource cleanup, or when establishing centralized error handling patterns at application boundaries. Use for any task involving exception handling, error recovery, graceful failure, or user error communication.

Use when creating GitHub Copilot instructions - provides repository-wide and path-specific formats, applyTo patterns, excludeAgent options, and natural language markdown style

Use when creating Windsurf rules - provides plain markdown format with NO frontmatter, 12,000 character limit, and single-file structure requirements

Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first

IMMEDIATELY USE THIS SKILL when creating or develop anything and before writing code or implementation plans - refines rough ideas into fully-formed designs through structured Socratic questioning, alternative exploration, and incremental validation

Search the Nori knowledge base for relevant context, solutions, and documentation.

List all server-side noridocs, optionally filtered by repository and/or path prefix.

Use when design is complete and you need detailed implementation tasks for engineers with zero codebase context - creates comprehensive implementation plans with exact file paths, complete code examples, and verification steps assuming engineer has minimal domain knowledge

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Use when writing or changing tests, adding mocks, or tempted to add test-only methods to production code - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies

Write or update documentation in the server-side noridocs system.

Use when you need to create a new custom skill for a profile - guides through gathering requirements, creating directory structure, writing SKILL.md, and optionally adding bundled scripts