JavaScript

Use this skill for JavaScript implementation, refactoring, debugging, or review when you need strong Java-style OOP conventions, ES2025+ standard features, t...

Security Scan

This is an instruction-only JavaScript/OOP style and review skill that is internally consistent: it requires no installs, no credentials, and its runtime instructions are limited to coding guidance and included rule files.

Purpose & Capability

The skill's name and description match its contents: a collection of coding rules and runtime instructions for JS OOP style and reviews. It requests no binaries, env vars, or installs, which is proportionate for a stylistic/review skill.

Instruction Scope

SKILL.md confines the agent to code-style, loading the included rule files and following repository conventions/formatters. It does not instruct reading unrelated system files, contacting external endpoints, or accessing secrets. Its reference to repository files and AGENTS.md is appropriate for a code-review skill.

Install Mechanism

There is no install spec and no code executed or downloaded at install time. This is the lowest-risk model (instruction-only).

Credentials

The skill declares no required environment variables, credentials, or config paths, and SKILL.md does not attempt to access any secrets—requirements are proportionate to its stated purpose.

Persistence & Privilege

always is false and the skill does not request elevated or persistent privileges. It can be invoked autonomously (platform default), but there are no additional privilege or cross-skill config changes requested.

Assessment

This skill is a rulebook and checklist for Java-style OOP and modern ES2025+ patterns; it does not request credentials or install software. Before installing, verify the style rules align with your project's conventions (the SKILL.md explicitly says to defer to repository formatters and AGENTS.md). If you want to limit the agent's autonomous actions, control invocation policies on your agent platform, but the skill itself does not introduce obvious security risks.

JavaScript Skill

Scope

Use this skill for JavaScript or Node/browser code changes and reviews.

Precedence

• Follow explicit user instructions first.
• Follow repository conventions, formatter, linter, and AGENTS.md before generic defaults in these rules.
• Use the rule files as focused guidance and review checklists, not as a reason to fight established local patterns.

ES2025+ Baseline

• Assume a modern runtime such as Node 22+ or evergreen engines.
• Prefer standardized Stage 4 ECMAScript features only.
• Prefer newer standard helpers when they reduce boilerplate.
• Treat 2026-finished APIs as conditional on target runtime support.
• Do not default to Stage 3 syntax such as using, await using, or decorators.

Java-Style OOP Baseline

• Treat classes as the default home for stateful business behavior.
• Limit free functions to small pure transforms, validators, calculators, and mappers.
• Treat controllers, services, repositories, policies, use cases, ports, and specifications as first-class architectural concepts.
• Treat stateful browser behavior as interface-layer controller code rather than loose script modules.
• Prefer parameter objects, #private fields, and explicit value objects over ad hoc argument lists and mutable shapes.
• Prefer intent methods, domain errors, and stable event payload DTOs over generic property mutation.
• Keep composition-root wiring explicit and centralized, with dependencies flowing inward.

Operating Model

1. Start with this file.
2. Load the baseline rules for almost every task:
   • References
   • Variables
   • Functions
   • Modules
   • Naming Conventions
   • SOLID and Structure
3. Load only the rule groups that match the task.
4. Use each file's local Example and End Check, then finish with the global checklist at the bottom of this file.

Rule Map

Syntax and formatting

• Strings
• Comments
• Formatting
• Control Flow
• Hoisting

Objects, arrays, and data shape

• Objects
• Destructuring
• Accessors
• Collections

Functions, classes, and modules

• Arrow Functions
• Classes and Constructors
• Events
• Standard Library
• UI Controllers

Equality, conversion, and modern syntax

• Value Semantics

Async and failure handling

• Async
• Error Handling

Task-Based Loading

Load these additional files when the task has these traits:

• Data reshaping or DTO work: objects, destructuring, collections, value-semantics.
• Domain and service design or refactors: classes-and-constructors, functions, accessors, modules, error-handling, naming-conventions, solid-and-structure.
• Browser widgets, DOM bindings, and event-driven UI controllers: ui-controllers, classes-and-constructors, modules, naming-conventions, comments.
• Async flows, I/O, retries, timers, concurrency, or background work: async, error-handling, standard-library.
• Nullability, defaults, parsing, regex, or binary conversion: value-semantics, standard-library.
• Formatting, documentation, or readability cleanup: formatting, strings, comments, control-flow.
• Code review: start from the changed lines, then load only the rules implicated by the diff plus the end-check categories below.

Important Distinctions

• value-semantics.md owns equality, conversions, defaults, truthiness, and optional chaining.
• async.md owns Promise.try(), Array.fromAsync(), and async flow rules.
• collections.md owns iterator helpers, Set algebra, copy depth, and change-by-copy collections inside service and repository workflows.
• classes-and-constructors.md owns encapsulation, constructor discipline, and factory guidance.
• ui-controllers.md owns DOM lifecycle, event binding, teardown, and interface-layer controller guidance.
• functions.md owns parameter-object APIs and the boundary between tiny pure helpers and named service or use-case methods.
• objects.md owns value-object and DTO boundary guidance.
• error-handling.md owns domain-error policy.
• standard-library.md owns concrete ES2025+ helper APIs such as RegExp.escape(), Error.isError(), and binary conversion helpers inside object-oriented designs.
• solid-and-structure.md is the only file that names SRP, OCP, LSP, ISP, DIP, and the composition-root and application layering model.

End Check

• Verify repository conventions override generic defaults when they differ.
• Verify chosen ES2025+ features are standardized and fit target runtime support.
• Verify behavior lives on objects, services, use cases, or controllers rather than scattered utilities.
• Verify naming, encapsulation, module boundaries, value objects, and DTO boundaries stay explicit.
• Verify ports, adapters, and layer placement are clear.
• Verify browser controllers keep lifecycle, DOM boundaries, and cleanup explicit.
• Verify async work, error handling, and collection mutation choices are intentional.
• Verify comments and formatting remain consistent and low-noise.