javascript-modern
/javascript-modern
Use when writing or reviewing modern JavaScript for browser or PHP-backed SaaS applications, including modules, asynchronous flows, error handling, language features, and performance.
- Author
- peterbamuhigire ↗
- Repository
- chwezi-dev-engine ↗
- Licence
- MIT
- Last repository change
- 24.10.2026
Assessment and security
- Files in this package
- 7
- Scripts
- 0
- HTML comments
- 3
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- SKILL.md zawiera komentarze HTML (3). Nie widać ich w podglądzie Markdown, a model je czyta.
What it does and when to use it
Use when writing or reviewing modern JavaScript for browser or PHP-backed SaaS applications, including modules, asynchronous flows, error handling, language features, and performance.
Original author description
Use when writing or reviewing modern JavaScript for browser or PHP-backed SaaS applications, including modules, asynchronous flows, error handling, language features, and performance.
How it works
- Use When
- Workflow
- Evidence Produced
- References
- Architecture Rule (Non-Negotiable)
- 1. Module Pattern (IIFE + ES Modules)
- Additional Guidance
- Decision Rules
- Capability Contract
- Degraded Mode
SKILL.md preview
---
name: javascript-modern
description: Use when writing or reviewing modern JavaScript for browser or PHP-backed SaaS applications, including modules, asynchronous flows, error handling, language features, and performance.
metadata:
portable: true
compatible_with:
- claude-code
- codex
---
# javascript-modern
Acknowledgement: Shared by Peter Bamuhigire, techguypeter.com, +256 784 464178.
<!-- dual-compat-start -->
## Use When
- Modern JavaScript (ES6+) patterns for PHP+JavaScript SaaS apps: modules, async/await, destructuring, Proxy/Reflect, generators, WeakMap/WeakSet, optional chaining, error handling, and performance patterns. Use when writing JavaScript for web...
## Workflow
- For OOP-heavy browser modules, reusable UI widgets, or complex stateful workflows, pair with `references/javascript-patterns.md` and load `references/javascript-patterns.md`.
- For Node/runtime container work, pair with `docker-development`.
## Evidence Produced
| Category | Artifact | Format | Example |
|----------|----------|--------|---------|
| Correctness | JavaScript module test plan | Markdown doc covering async, generators, Proxy, and module boundary tests | `docs/web/js-module-tests.md` |
## References
- Use the `references/` directory for deep detail after reading the core workflow below.
- Use `references/javascript-advanced.md` when the task needs deeper ES language mechanics, async patterns, metaprogramming, or performance.
- Use `references/javascript-patterns.md` when the task involves OOP, prototypes, design patterns, event modules, or maintainable browser architecture.
<!-- dual-compat-end -->
Expert-level ES6+ patterns for PHP+JavaScript SaaS developers. Assumes fluency with variables, loops, and functions.
## Architecture Rule (Non-Negotiable)
JavaScript belongs in its own `.js` files. PHP only emits a `<script src="...">` tag or passes config via a single JSON data attribute. No `<?php echo $var ?>` scattered through JS files.
```php
<!-- PHP emits one data attribute — no inline JS -->
<div id="app-config"
data-config='<?= json_encode($config, JSON_HEX_APOS) ?>'
data-user='<?= json_encode(['id' => $user->id, 'role' => $user->role]) ?>'>
</div>
```
```javascript
// assets/js/app.js — reads config cleanly from its own file
const config = JSON.parse(document.getElementById('app-config').dataset.config);
const user = JSON.parse(document.getElementById('app-config').dataset.user);
```
---
## 1. Module Pattern (IIFE + ES Modules)
```javascript
// assets/js/modules/user-table.js
const UserTable = (() => {
let tableInstance = null; // private — unreachable from outside
function init(config) { tableInstance = new DataTable('#users-table', config); }
function refresh() { tableInstance?.ajax.reload(); }
return { init, refresh }; // public API only
})();
export default UserTable;
// Named exports for shared utilities: assets/js/core/utils.js
export function debounce(fn, delay) { /* ... */ }
export function throttle(fn, limit) { /* ... */ }
```
---
## Additional Guidance
Extended guidance for `javascript-modern` was moved to [references/skill-deep-dive.md](references/skill-deep-dive.md) to keep this entrypoint compact and fast to load.
Use that deep dive for:
- `2. Async/Await — The Right Patterns`
- `3. Production-Grade Fetch Wrapper`
- `4. Destructuring — Beyond the Basics`
- `5. Optional Chaining and Nullish Coalescing`
- `6. Generators for Pagination / Lazy Data`
- `7. WeakMap for Private Data and DOM Metadata`
- `8. Proxy for Validation and Reactivity`
- `9. Error Handling Strategy`
- `10. Event Delegation (Performance Pattern)`
- `11. Debounce and Throttle`
- `12. LocalStorage with Expiry`
- `13. `const` / `let` and Arrow Function `this``
- Additional deep-dive sections continue in the reference file.
## Decision Rules
| Condition | Action |
|---|---|
| Code is shared across features | Use explicit ES modules with narrow exports |
| Work is CPU-bound | Move it off the main thread or backend |
| Legacy IIFE is stable and isolated | Preserve it unless tested conversion adds value |
## Capability Contract
Read and search are required. Editing and browser or test execution require authorisation; network access is optional.
## Degraded Mode
Fallback: without execution, provide a patch plus exact lint, unit, and browser checks still required.
## Domain Anti-Patterns
- Starting asynchronous work without handling rejection.
- Using global mutable state instead of module scope.
- Adding a dependency for a native language operation.
- Blocking the main thread with large synchronous transforms.
- Changing module format without checking runtime compatibility.
## Inputs
| Artefact | Required? | Purpose |
|---|---|---|
| JavaScript target, runtime, code, and project conventions | yes | Select compatible language and module patterns |
## Outputs
- Produce reviewed JavaScript, findings, tests, and compatibility notes.
Files in this package (7)
- SKILL.md 5 KB
- references/javascript-advanced.md 18 KB
- references/javascript-patterns.md 6 KB
- references/skill-deep-dive.md 14 KB
- references/javascript-patterns/references/scalable-js-oop-patterns.md 3 KB
- references/javascript-patterns/references/skill-deep-dive.md 15 KB
- references/javascript-patterns/references/source-register-dev-engine.md 1 KB
Versions
The database has no other skills named javascript-modern.
Database snapshot: 13.11.2026 · package version 8ee6ee7fbf57 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100javascript-pro
Use this agent when you need to build, optimize, or refactor modern JavaScript code for browser, Node.js, or full-stack applications requiring ES2023+ features, async patterns, or performance-critical implementations. - 90javascript-expert
Use when building JavaScript applications with modern ES2023+ features, async patterns, or Node.js development. Invoke for vanilla JavaScript, browser APIs, performance optimization, module systems. - 100js-modern
Write modern JavaScript and TypeScript — ES6+ features, async/await, modules, destructuring, optional chaining, TypeScript types, and modern tooling. Use when writing JavaScript/TypeScript for BigCommerce themes, apps, or headless storefronts. - 100js-modern
Write modern JavaScript and TypeScript — ES6+ features, async/await, modules, destructuring, optional chaining, TypeScript types, and modern tooling. Use when writing JavaScript/TypeScript for Shopify themes, apps, Functions, or Hydrogen storefronts. - 100php-language-modern
Use when writing modern non-framework PHP 8.1-8.5 — property hooks, asymmetric visibility, pipe operator, attributes, enums, readonly. Do NOT use for style (php-standards) or Laravel. - 100javascript
Expert modern JavaScript (ES2024+) assistance covering closures, async/await, promises, modules, event loop concurrency, and DOM manipulation. Use when writing frontend or Node.js code, designing clean asynchronous flows, or modernizing legacy JavaScript.