AI Coding Assistants 1
▼
Uses Copilot for TypeScript/React. Critically evaluates suggestions for Electron-specific code (IPC, preload).
Effectively uses Copilot for Electron: test generation, IPC handlers, React components. Configures Copilot context. Understands limitations for Electron API.
Integrates AI workflow. Creates custom prompts for Electron patterns. Evaluates security of AI-generated code.
Defines AI-assisted development strategy. Establishes Copilot guidelines. Evaluates productivity impact.
Algorithms & Data Structures 2
▼
Understands O-notation for TypeScript/JavaScript. Chooses Map vs Object, Set vs Array for optimal complexity. Applies Array.sort with understanding of O(n log n) complexity.
Optimizes algorithms for Electron: list virtualization, debounce/throttle, efficient search. Profiles through Chrome DevTools Performance. Implements efficient tree traversal for file browser.
Designs efficient algorithms for desktop: incremental computation, virtual scrolling with binary search, diff algorithms for file comparison. Uses WASM for compute-intensive algorithms.
Conducts algorithmic reviews for Electron projects. Defines performance standards. Mentors on TypeScript optimization.
Uses TypeScript collections: Array, Map, Set, WeakMap. Works with typed arrays for binary data. Understands JSON serialization for IPC data transfer.
Creates custom data structures for Electron: immutable state (Immer), tree structures for file browser, LRU cache. Uses SharedArrayBuffer for cross-thread data. Works with Protocol Buffers.
Designs data layer for Electron: persistent data structures, B-tree for local DB, bloom filters for search. Optimizes memory usage through structural sharing. Implements efficient diff structures.
Defines data structure standards for the Electron team. Coordinates data layer architecture. Mentors on data structure selection.
API Protocols 1
▼
Uses WebSocket for real-time communication. Connects through ws library in main process or WebSocket API in renderer. Handles reconnection.
Implements robust WebSocket client with heartbeat, exponential backoff reconnection. Configures message serialization through protobuf. Manages connection lifecycle through main process. Multiplexes channels.
Designs real-time architecture for Electron: WebSocket + EventEmitter pattern. Implements server-sent events for one-way streaming. Optimizes message throughput. Integrates with offline-first.
Defines real-time strategy for the Electron platform. Coordinates WebSocket infrastructure. Establishes message protocol standards.
Application Security 1
▼
Understands secure coding in TypeScript/Electron. Avoids XSS through sanitization. Uses crypto API for hashing. Knows Content Security Policy.
Applies secure coding: crypto for encryption, path validation for file access, IPC message validation. Configures TypeScript strict for null safety. Uses ESLint security plugins.
Designs secure-by-default APIs. Implements sandboxing for untrusted content. Applies principle of least privilege. Conducts secure code review for Electron.
Defines secure coding standards for the Electron team. Establishes security review process. Coordinates security training.
Build Tools & Bundling 1
▼
Knows Vite for Electron through electron-vite or vite-electron-builder. Configures vite.config.ts for main and renderer. Uses HMR for fast renderer development.
Configures electron-vite with TypeScript, path aliases, environment variables. Configures Vite plugins for Electron specifics. Optimizes build through Rollup options. Configures preview mode.
Designs Vite-based build pipeline for enterprise Electron. Creates custom Vite plugins for Electron. Optimizes cold start and HMR performance. Integrates with electron-builder.
Defines Vite strategy for the Electron team. Coordinates build tooling standardization. Establishes Vite best practices.
Clean Code & Refactoring 1
▼
Follows coding standards for TypeScript/Electron. Uses ESLint with TypeScript rules. Configures Prettier for formatting. Goes through code review.
Configures strict TypeScript (strict: true, noUncheckedIndexedAccess). Uses ESLint plugin for Electron security rules. Introduces Husky pre-commit hooks. Applies conventional commits.
Defines quality gates for Electron. Configures SonarQube/SonarCloud. Creates custom ESLint rules for Electron-specific patterns. Mentors on TypeScript best practices.
Establishes code quality standards for the Electron team. Defines metrics, coordinates tech debt. Introduces quality gates in CI.
Code Review 1
▼
Participates in code review as a reviewee for TypeScript/Electron. Applies feedback. Understands coding standards.
Conducts code review for TypeScript/Electron. Checks security (IPC safety, CSP), performance, TypeScript correctness. Reviews React components and CSS.
Conducts architectural review for Electron. Focuses on IPC design, process model, security. Mentors through code review.
Defines code review process for the team. Establishes review checklist for Electron. Coordinates review workflow.
Concurrency & Parallelism 2
▼
Understands async/await in TypeScript for Electron. Handles async IPC through ipcRenderer.invoke. Uses Promise for async operations. Knows the Node.js event loop.
Applies async patterns: Promise.all for parallel operations, AsyncIterator for streaming, AbortController for cancellation. Implements async queue for rate limiting. Handles unhandled rejections.
Designs async architecture for Electron: backpressure through streams, worker threads for CPU-bound tasks. Implements structured concurrency. Optimizes event loop for responsive UI.
Defines async strategy for the Electron platform. Establishes async coding standards. Coordinates error handling strategy.
Understands Electron process model: main, renderer, utility processes. Uses Web Workers for offloading computation. Knows Node.js worker_threads at a basic level.
Implements worker_threads for CPU-intensive tasks in main process. Uses SharedArrayBuffer for cross-thread data. Applies UtilityProcess for isolated computation. Manages thread pool.
Designs multi-process Electron architecture with UtilityProcess and worker_threads. Optimizes IPC overhead between processes. Implements work stealing for load balancing. Profiles through Node.js inspector.
Defines process model for the Electron platform. Establishes multi-process standards. Coordinates parallel processing strategy.
Desktop Patterns 2
▼
Understands Electron IPC: ipcMain/ipcRenderer through contextBridge. Implements simple invoke/handle patterns. Uses preload scripts for secure IPC. Passes structured data between processes.
Develops typed IPC through TypeScript interfaces. Implements streaming through MessagePort. Uses SharedArrayBuffer for high-performance data sharing. Manages multiple BrowserWindows through IPC.
Designs IPC architecture with RPC-style layer. Implements pub/sub through custom event bus. Optimizes serialization through structured clone. Works with UtilityProcess for compute-intensive tasks.
Defines IPC strategy for the Electron platform. Establishes IPC patterns and security guidelines. Coordinates cross-process architecture.
Understands MVVM/MVC in the context of Electron + React. Separates components into View and ViewModel (hooks/stores). Uses React Context for state management. Implements data binding through props and state.
Applies state management as ViewModel layer. Organizes navigation through React Router. Implements separation of concerns: IPC layer, business logic, UI components. Tests ViewModel separately.
Designs scalable Electron architecture with Clean Architecture layers. Implements IPC abstraction layer. Applies dependency injection through TSyringe/InversifyJS. Uses mediator for inter-module communication.
Defines architectural patterns for the Electron team. Establishes coding guidelines for separation of concerns. Conducts architecture review.
E2E Testing 1
▼
Understands E2E testing for Electron. Uses Playwright/Electron for automation. Records simple scenarios.
Uses Playwright for E2E Electron testing. Implements Page Object. Configures visual regression through screenshot comparison. Automates in CI with headless mode.
Designs E2E framework for Electron. Tests cross-platform. Optimizes stability. Integrates accessibility testing.
Defines E2E strategy for the Electron product. Coordinates E2E infrastructure. Balances coverage and cost.
Electron & Web-based Desktop 2
▼
Knows Electron 28+ basics: main/renderer processes, BrowserWindow, preload scripts. Creates simple windows with contextBridge. Works with electron-forge for scaffolding. Understands Chromium + Node.js architecture.
Independently develops Electron applications with TypeScript. Manages lifecycle (app events, window management). Configures Tray, Menu, dialog API. Works with protocol handlers and deep links.
Designs Electron architecture with process isolation and security hardening. Optimizes Chromium through webPreferences. Creates custom native modules through node-addon-api. Implements shared workers.
Defines technical strategy for Electron development. Establishes security standards (CSP, sandbox). Plans migration between Electron major versions. Coordinates with Chromium/Node.js upgrades.
Understands security: contextIsolation, nodeIntegration: false. Uses contextBridge for safe API exposure. Avoids eval and remote module. Knows CSP for renderer.
Configures sandbox mode for renderer processes. Implements permission handling (media, geolocation). Validates IPC messages. Configures webRequest for blocking dangerous URLs. Audits npm dependencies.
Designs defense-in-depth security for Electron. Implements Fuses for compile-time security. Configures code signing and notarization. Conducts security audit and threat modeling for desktop.
Defines security strategy for the Electron platform. Establishes security checklist and review process. Coordinates penetration testing and CVE response.
Git & Workflows 1
▼
Uses Git for working with Electron projects. Configures .gitignore for node_modules, dist, build artifacts. Works with branches for features.
Applies Git rebase, cherry-pick, bisect. Configures Git hooks through Husky (lint-staged, type-check). Works with Git LFS for native module binaries. Resolves merge conflicts in package-lock.json.
Designs Git workflow for Electron projects. Configures monorepo through turborepo/nx. Optimizes CI through shallow clones. Implements semantic release.
Defines Git strategy for the Electron team. Establishes branching model. Coordinates release process.
Logging 1
▼
Uses electron-log or winston for logging. Configures log levels. Logs from main and renderer processes.
Configures structured logging with JSON output. Implements log rotation. Integrates crash reporting (Sentry/Crashpad). Adds context: app version, OS, process type.
Designs observability for Electron: logging, metrics, crash analytics. Implements remote log collection. Configures user analytics with privacy.
Defines logging strategy for Electron. Establishes GDPR-compliant logging standards. Coordinates observability.
React Ecosystem 1
▼
Knows React for Electron renderer: JSX, components, hooks (useState, useEffect). Creates UI components for desktop. Understands React lifecycle in the context of Electron BrowserWindow.
Develops React UI for Electron with TypeScript strict mode. Uses React.lazy for code splitting. Implements virtualization (react-window) for large lists. Applies React.memo and useMemo for optimization.
Designs React component architecture for Electron. Creates design system with compound components. Optimizes rendering through RSC-like patterns. Implements concurrent features.
Defines React standards for the Electron team. Coordinates component library. Establishes React best practices for desktop context.
State Management 1
▼
Uses React Context and useState for renderer state management. Understands the need for centralized state for multi-window. Works with localStorage/electron-store for persistence.
Applies state management tools. Synchronizes state between main and renderer through IPC. Implements persistence middleware. Works with optimistic updates.
Designs state architecture for multi-window Electron: shared state through main process, window-local state. Implements undo/redo through immer patches. Optimizes state updates for large datasets.
Defines state management strategy for the Electron platform. Establishes state design patterns. Coordinates state architecture across modules.
Unit Testing 1
▼
Writes unit tests through Jest/Vitest for Electron code. Tests renderer components. Tests main process logic separately. Understands IPC mocking.
Structures tests for Electron: main process, renderer, shared. Mocks electron module through jest-electron. Introduces coverage through c8/istanbul. Tests IPC handlers.
Designs test architecture for Electron. Introduces mutation testing through Stryker. Creates test utilities for IPC mocking. Optimizes test performance through parallelism.
Defines testing strategy for the Electron team. Establishes coverage targets. Coordinates test infrastructure.