JavaScript Pro
When to Use This Skill
- Building vanilla JavaScript applications
- Implementing async/await patterns and Promise handling
- Working with modern module systems (ESM/CJS)
- Optimizing browser performance and memory usage
- Developing Node.js backend services
- Implementing Web Workers, Service Workers, or browser APIs
Core Workflow
- Analyze requirements — Review
package.json, module system, Node version, browser targets; confirm .js/.mjs/.cjs conventions
- Design architecture — Plan modules, async flows, and error handling strategies
- Implement — Write ES2023+ code with proper patterns and optimisations
- Validate — Run linter (
eslint --fix); if linter fails, fix all reported issues and re-run before proceeding. Check for memory leaks with DevTools or --inspect, verify bundle size; if leaks are found, resolve them before continuing
- Test — Write comprehensive tests with Jest achieving 85%+ coverage; if coverage falls short, add missing cases and re-run. Confirm no unhandled Promise rejections
Reference Guide
Load detailed guidance based on context:
| Topic |
Reference |
Load When |
| Modern Syntax |
references/modern-syntax.md |
ES2023+ features, optional chaining, private fields |
| Async Patterns |
references/async-patterns.md |
Promises, async/await, error handling, event loop |
| Modules |
references/modules.md |
ESM vs CJS, dynamic imports, package.json exports |
| Browser APIs |
references/browser-apis.md |
Fetch, Web Workers, Storage, IntersectionObserver |
| Node Essentials |
references/node-essentials.md |
fs/promises, streams, EventEmitter, worker threads |
Constraints
MUST DO
- Use ES2023+ features exclusively
- Use
X | null or X | undefined patterns
- Use optional chaining (
?.) and nullish coalescing (??)
- Use async/await for all asynchronous operations
- Use ESM (
import/export) for new projects
- Implement proper error handling with try/catch
- Add JSDoc comments for complex functions
- Follow functional programming principles
MUST NOT DO
- Use
var (always use const or let)
- Use callback-based patterns (prefer Promises)
- Mix CommonJS and ESM in the same module
- Ignore memory leaks or performance issues
- Skip error handling in async functions
- Use synchronous I/O in Node.js
- Mutate function parameters
- Create blocking operations in the browser
Key Patterns with Examples
Async/Await Error Handling
// ✅ Correct — always handle async errors explicitly
async function fetchUser(id) {
try {
const response = await fetch(`/api/users/${id}`);
if (!response.ok) throw new Error(`HTTP ${response.status}`);
return await response.json();
} catch (err) {
console.error("fetchUser failed:", err);
return null;
}
}
// ❌ Incorrect — unhandled rejection, no null guard
async function fetchUser(id) {
const response = await fetch(`/api/users/${id}`);
return response.json();
}
Optional Chaining & Nullish Coalescing
// ✅ Correct
const city = user?.address?.city ?? "Unknown";
// ❌ Incorrect — throws if address is undefined
const city = user.address.city || "Unknown";
ESM Module Structure
// ✅ Correct — named exports, no default-only exports for libraries
// utils/math.mjs
export const add = (a, b) => a + b;
export const multiply = (a, b) => a * b;
// consumer.mjs
import { add } from "./utils/math.mjs";
// ❌ Incorrect — mixing require() with ESM
const { add } = require("./utils/math.mjs");
Avoid var / Prefer const
// ✅ Correct
const MAX_RETRIES = 3;
let attempts = 0;
// ❌ Incorrect
var MAX_RETRIES = 3;
var attempts = 0;
Output Templates
When implementing JavaScript features, provide:
- Module file with clean exports
- Test file with comprehensive coverage
- JSDoc documentation for public APIs
- Brief explanation of patterns used
Documentation
1---2name: javascript-pro3description: Writes, debugs, and refactors JavaScript code using modern ES2023+ features, async/await patterns, ESM module systems, and Node.js APIs. Use when building vanilla JavaScript applications, implementing Promise-based async flows, optimising browser or Node.js performance, working with Web Workers or Fetch API, or reviewing .js/.mjs/.cjs files for correctness and best practices.4license: MIT5metadata:6 source: https://skillmd.com/skills/jeffallan/javascript-pro7 author: https://github.com/Jeffallan8 version: "1.1.0"9 domain: language10 triggers: JavaScript, ES2023, async await, Node.js, vanilla JavaScript, Web Workers, Fetch API, browser API, module system11 role: specialist12 scope: implementation13 output-format: code14 related-skills: fullstack-guardian15---1617# JavaScript Pro1819## When to Use This Skill2021- Building vanilla JavaScript applications22- Implementing async/await patterns and Promise handling23- Working with modern module systems (ESM/CJS)24- Optimizing browser performance and memory usage25- Developing Node.js backend services26- Implementing Web Workers, Service Workers, or browser APIs2728## Core Workflow29301. **Analyze requirements** — Review `package.json`, module system, Node version, browser targets; confirm `.js`/`.mjs`/`.cjs` conventions312. **Design architecture** — Plan modules, async flows, and error handling strategies323. **Implement** — Write ES2023+ code with proper patterns and optimisations334. **Validate** — Run linter (`eslint --fix`); if linter fails, fix all reported issues and re-run before proceeding. Check for memory leaks with DevTools or `--inspect`, verify bundle size; if leaks are found, resolve them before continuing345. **Test** — Write comprehensive tests with Jest achieving 85%+ coverage; if coverage falls short, add missing cases and re-run. Confirm no unhandled Promise rejections3536## Reference Guide3738Load detailed guidance based on context:3940| Topic | Reference | Load When |41|-------|-----------|-----------|42| Modern Syntax | `references/modern-syntax.md` | ES2023+ features, optional chaining, private fields |43| Async Patterns | `references/async-patterns.md` | Promises, async/await, error handling, event loop |44| Modules | `references/modules.md` | ESM vs CJS, dynamic imports, package.json exports |45| Browser APIs | `references/browser-apis.md` | Fetch, Web Workers, Storage, IntersectionObserver |46| Node Essentials | `references/node-essentials.md` | fs/promises, streams, EventEmitter, worker threads |4748## Constraints4950### MUST DO51- Use ES2023+ features exclusively52- Use `X | null` or `X | undefined` patterns53- Use optional chaining (`?.`) and nullish coalescing (`??`)54- Use async/await for all asynchronous operations55- Use ESM (`import`/`export`) for new projects56- Implement proper error handling with try/catch57- Add JSDoc comments for complex functions58- Follow functional programming principles5960### MUST NOT DO61- Use `var` (always use `const` or `let`)62- Use callback-based patterns (prefer Promises)63- Mix CommonJS and ESM in the same module64- Ignore memory leaks or performance issues65- Skip error handling in async functions66- Use synchronous I/O in Node.js67- Mutate function parameters68- Create blocking operations in the browser6970## Key Patterns with Examples7172### Async/Await Error Handling73```js74// ✅ Correct — always handle async errors explicitly75async function fetchUser(id) {76 try {77 const response = await fetch(`/api/users/${id}`);78 if (!response.ok) throw new Error(`HTTP ${response.status}`);79 return await response.json();80 } catch (err) {81 console.error("fetchUser failed:", err);82 return null;83 }84}8586// ❌ Incorrect — unhandled rejection, no null guard87async function fetchUser(id) {88 const response = await fetch(`/api/users/${id}`);89 return response.json();90}91```9293### Optional Chaining & Nullish Coalescing94```js95// ✅ Correct96const city = user?.address?.city ?? "Unknown";9798// ❌ Incorrect — throws if address is undefined99const city = user.address.city || "Unknown";100```101102### ESM Module Structure103```js104// ✅ Correct — named exports, no default-only exports for libraries105// utils/math.mjs106export const add = (a, b) => a + b;107export const multiply = (a, b) => a * b;108109// consumer.mjs110import { add } from "./utils/math.mjs";111112// ❌ Incorrect — mixing require() with ESM113const { add } = require("./utils/math.mjs");114```115116### Avoid var / Prefer const117```js118// ✅ Correct119const MAX_RETRIES = 3;120let attempts = 0;121122// ❌ Incorrect123var MAX_RETRIES = 3;124var attempts = 0;125```126127## Output Templates128129When implementing JavaScript features, provide:1301. Module file with clean exports1312. Test file with comprehensive coverage1323. JSDoc documentation for public APIs1334. Brief explanation of patterns used134135[Documentation](https://jeffallan.github.io/claude-skills/skills/language/javascript-pro/)