메뉴
Node.js runtime conventions, APIs, and ecosystem patterns. Invoke whenever task involves any interaction with Node.js runtime — server code, CLI tools, scripts, module system, streams, process lifecycle, or package configuration.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/xobotyi/cc-foundry --skill nodejs명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Design Claude Code output styles: role, voice, and behavioral rules injected into the system prompt. Invoke whenever task involves any interaction with output styles — creating, editing, evaluating, or changing how Claude communicates.
CLAUDE.md instruction quality: writing effective project instructions, diagnosing why Claude ignores rules, routing content to the right layer, progressive disclosure, and systematic improvement. Invoke whenever task involves any interaction with CLAUDE.md files — creating, writing, reviewing, auditing, improving, optimizing, or debugging instruction compliance.
Prompt design techniques for LLMs: structure, examples, reasoning patterns, and optimization. Invoke whenever task involves any interaction with AI instructions — crafting, debugging, improving, or evaluating prompts for skills, agents, output styles, or system configurations.
SKILL.md 표시 중
SOC 직업 분류 기준
| name | nodejs |
| description | Node.js runtime conventions, APIs, and ecosystem patterns. Invoke whenever task involves any interaction with Node.js runtime — server code, CLI tools, scripts, module system, streams, process lifecycle, or package configuration. |
Respect the event loop. Every blocking operation is a scalability bug.
Node.js rewards async-first, stream-oriented code. If your Node.js code fights the event loop, it's wrong.
${CLAUDE_SKILL_DIR}/references/modules.md]: ESM/CJS comparison tables, file extension rules,
conditional exports patterns${CLAUDE_SKILL_DIR}/references/event-loop.md]: Phase order, execution priority, blocking
operations table, worker pool${CLAUDE_SKILL_DIR}/references/streams.md]: Stream types table, pipeline patterns, backpressure
details${CLAUDE_SKILL_DIR}/references/errors.md]: Error categories table, global handlers,
centralized error handling${CLAUDE_SKILL_DIR}/references/security.md]: Supply chain threats table, HTTP security headers,
process hardening"type": "module" in package.json. Use .mjs/.cjs only when mixing module systems within one
package.node: prefix for all built-in imports: import fs from 'node:fs'. Prevents package name collision attacks
and is unambiguous.process explicitly. import process from 'node:process'. Never rely on the global — explicit
imports make dependencies visible.process"exports" in package.json for libraries. Encapsulates internals — only paths listed in "exports" are
importable by consumers.import() for statically-known dependencies.import.meta.dirname/import.meta.filename instead of __dirname/__filename.import.meta.resolve() instead of require.resolve() in ESM."type" explicitly in package.json, even in CJS packages — future-proofs the package and helps
tooling.types > import > require > default. Always
include "default" as fallback."types" first in conditional exports when publishing TypeScript declarations.# imports ("imports" in package.json) for clean internal paths without ../../../. Supports conditional
resolution for platform-specific implementations."main" alongside "exports" only for backward compatibility with old Node.js or bundlers. Never use
"main" alone for new packages.with { type: 'json' } attribute.createRequire() from node:module only when you must require() in ESM (e.g., native addons).require() can load synchronous ESM (no top-level await). For ESM with top-level await, use dynamic
import()."exports" is defined.File extension rules and ESM vs CJS comparison tables: see ${CLAUDE_SKILL_DIR}/references/modules.md.
Node.js uses a single-threaded event loop for JavaScript and a libuv worker pool for expensive I/O and CPU tasks.
readFileSync, execSync, crypto.pbkdf2Sync,
zlib.inflateSync). Sync APIs are acceptable only in CLI scripts, startup code, or build tools.worker_threads or child processes. For main-thread CPU work, partition into chunks
with setImmediate() between iterations.JSON.parse, JSON.stringify, regex, or iteration = DoS vector. A 50MB JSON string
blocks the loop for ~2 seconds.(a+)*, no overlapping alternations (a|a)*, no backreferences
with repetition. Use safe-regex2, RE2, or indexOf.setImmediate() over recursive process.nextTick(). nextTick starves I/O if called recursively. Use
nextTick only when you must run before any I/O in the current tick (e.g., emitting events after construction before
listeners attach).queueMicrotask() over process.nextTick() for new code — it's cross-platform and web-standard.setImmediate always fires before setTimeout(fn, 0). Outside I/O, the order is
non-deterministic — do not depend on it.AbortController for cancellable timers and operations.Phase order, execution priority, blocking operations table, and worker pool details: see
${CLAUDE_SKILL_DIR}/references/event-loop.md.
Streams process data incrementally — use them for large files, HTTP bodies, data transformation pipelines, and proxying. Do not use streams when data is already fully in memory.
pipeline() from node:stream/promises for stream composition. Never manual .pipe() chains — they don't
propagate errors or handle cleanup..write() return value; wait for 'drain' event before continuing. pipeline()
handles this automatically.Readable.from() for converting iterables/async iterables to streams.for await (const chunk of stream)) as the simplest way to consume readable streams.
Backpressure is handled automatically.readline with createInterface for line-by-line file processing.highWaterMark defaults to 16 KiB for byte streams, 16 objects for object mode. It's a hint, not a hard limit.highWaterMark. Enable with { objectMode: true }.stream.destroy(new Error('msg')).Readable.from() over class-based _read() implementation unless
you need fine-grained control._transform(chunk, encoding, callback) and optionally _flush(callback) for
end-of-stream processing._write(chunk, encoding, callback) and optionally _final(callback) for cleanup
before 'finish' event.Stream types table and .pipe() pitfalls: see ${CLAUDE_SKILL_DIR}/references/streams.md.
async/await with try/catch. No callbacks for new code.return await when returning promises from try blocks — preserves full stack traces and ensures catch
fires for rejections.Error. Custom errors must extend Error, set a code property for programmatic matching (not message
strings, which change), and set name.error.cause for chaining: new Error("context", { cause: originalErr }). The full chain is visible via
util.inspect() and structured loggers.error.code or instanceof, never by message string.process.on('unhandledRejection') and process.on('uncaughtException').
Log, clean up, exit. Since Node.js 15+, unhandled rejections crash the process by default.uncaughtException. The process state is unknown — log, cleanup, exit.'error' events on all EventEmitters and streams. An unhandled 'error' event crashes the process.
pipeline() handles stream errors automatically.process.on('warning') for non-fatal process warnings (deprecations, memory leaks, experimental features).catch (e) { log(e); throw e } causes duplicate logging.Error categories table and operational vs programmer error strategies: see ${CLAUDE_SKILL_DIR}/references/errors.md.
SIGTERM/SIGINT: stop accepting connections, wait for in-flight requests (with
timeout), close DB pools, flush logs, then process.exit(0). Force-exit on timeout.NODE_ENV=production in production. It enables framework optimizations and disables debug output.npm ci in CI/production. Never npm install — it ignores lockfile mismatches.Content-Length header before reading the body.stream-json, @streamparser/json) for very large JSON payloads.headersTimeout, requestTimeout, timeout,
keepAliveTimeout, maxRequestsPerSocket.helmet or equivalent): Strict-Transport-Security, X-Content-Type-Options: nosniff,
X-Frame-Options: DENY, Content-Security-Policy..env files — add to .gitignore.crypto.timingSafeEqual() for secret comparison (prevents timing attacks).crypto.scrypt() or crypto.pbkdf2() (async versions) for password hashing.exec() with user-controlled strings. Use execFile() or spawn() with
argument arrays.eval(), new Function(), or dynamic require() with user input.--max-old-space-size to prevent memory exhaustion.Supply chain threats table, dependency auditing, and security checklist: see
${CLAUDE_SKILL_DIR}/references/security.md.
When writing Node.js code:
node:fs/promises over callback-based node:fs.node:stream/promises for pipeline operations.When reviewing Node.js code:
The javascript skill governs language choices; this skill governs Node.js runtime decisions. Activate typescript alongside both when working with TypeScript.
Respect the event loop. When in doubt, make it async.