Documentation

Write self-documenting code with clear structure and naming, adding minimal, helpful, evergreen comments only for large sections of complex logic, avoiding comments about recent changes or temporary fixes. Use this skill when writing or reviewing code in any file where comments or code documentation are involved. Apply when deciding whether to add comments, when refactoring code to be more self-explanatory through better naming and structure, when reviewing existing comments for relevance and evergreen quality, when removing outdated or change-related comments, or when adding concise explanatory comments for complex logic sections. Use for any task involving code documentation strategy, comment quality assessment, or improving code readability through structure rather than comments.

Expert guidance for writing secure, reliable, and performant Claude Code hooks - validates design decisions, enforces best practices, and prevents common pitfalls

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

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.

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.

Web search and content extraction via Brave Search API. Use for searching documentation, facts, or any web content. Lightweight, no browser required.

Write focused tests for core user flows and critical paths with clear test names, behavior-focused assertions, mocked external dependencies, and fast execution, deferring edge case testing until explicitly required. Use this skill when creating or modifying test files, writing unit tests, integration tests, or test cases for any feature. Apply when writing test files (test/, __tests__/, spec/, .test.js, .spec.ts, test_*.py), implementing tests for core user workflows, testing critical business logic, mocking external dependencies (databases, APIs, file systems), writing descriptive test names, creating fast-running unit tests, or adding tests at logical completion points of feature development. Use for any task involving test creation, test coverage, test strategy, or test-driven development.

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.

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

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

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

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 this when you have finished making code changes and you are ready to update the documentation based on those changes.

Sync all local docs.md files to server-side noridocs system.

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