What's the difference between ESLint and Prettier?

ESLint focuses on code quality and catching potential bugs, while [Prettier](https://prettier.io/) is a code formatter that handles code style. ESLint can catch issues like unused variables, missing return statements, and potential security vulnerabilities. Prettier handles formatting like line length, quotes, and indentation. Many teams use both together, with ESLint for linting and Prettier for formatting, though there can be configuration conflicts that require [eslint-config-prettier](https://www.npmjs.com/package/eslint-config-prettier) to resolve. The [official Prettier integration guide](https://prettier.io/docs/en/integrating-with-linters.html) and [eslint-plugin-prettier](https://www.npmjs.com/package/eslint-plugin-prettier) can help with setup, though the Prettier team now [recommends running them separately](https://prettier.io/docs/en/integrating-with-linters.html#notes) for better performance.

Should I use ESLint with TypeScript?

![TypeScript-ESLint Logo](https://typescript-eslint.io/img/logo.svg) Yes, ESLint works excellently with TypeScript through [@typescript-eslint](https://typescript-eslint.io/). This provides TypeScript-aware linting rules that understand type information, offering more sophisticated analysis than basic ESLint rules. The [typescript-eslint monorepo](https://github.com/typescript-eslint/typescript-eslint) includes [@typescript-eslint/parser](https://www.npmjs.com/package/@typescript-eslint/parser) and [@typescript-eslint/eslint-plugin](https://www.npmjs.com/package/@typescript-eslint/eslint-plugin), with [comprehensive documentation](https://typescript-eslint.io/getting-started/) and [migration guides](https://typescript-eslint.io/linting/troubleshooting/tslint/). TSLint (the original TypeScript linter) was deprecated in 2019 in favor of the ESLint + typescript-eslint approach, making ESLint the recommended choice for TypeScript projects. The [TypeScript team officially endorses](https://github.com/Microsoft/TypeScript/issues/29288) this approach.

How do I fix "ESLint is unable to determine what parser to use" errors?

This fucking error shows up at the worst times, usually right before a deployment. Here's what actually works: **Most common cause**: You have a `.vue` file or `.ts` file but didn't install the right parser. Copy-paste this and adjust as needed: ```bash npm install --save-dev @typescript-eslint/parser @typescript-eslint/eslint-plugin ``` **Second most common**: Your `.eslintrc.js` is missing the `parser` field entirely. Add this: ```js module.exports = { parser: '@typescript-eslint/parser', // ... rest of your config } ``` **The nuclear option**: Add this to `.eslintignore` if you're debugging and just need the damn thing to work: ``` **/*.vue **/*.ts dist/ build/ ``` **Pro tip**: Use `npx eslint --debug file.js` to see exactly what's happening. Usually reveals some dumb configuration issue you missed.

Can ESLint slow down my development workflow?

Hell yes it can. Our CI went from 3 minutes to 12 minutes after someone enabled `eslint-plugin-import` with all the import/order rules. Took me two weeks to figure out that one rule was scanning the entire node_modules directory for every import statement. **Quick fixes that actually work:** - Use `--cache` - cuts repeat runs from 45 seconds to 8 seconds on our monorepo - Use `TIMING=1 npx eslint .` to find the rules eating your CPU - Disable `import/no-cycle` in development if you have a large codebase - it's slow as shit - Set up different configs for dev vs CI. Dev can skip expensive rules that catch edge cases **The nuclear option**: If ESLint is taking more than 30 seconds on your project, something's wrong. Either you have a misconfigured plugin or your rules are doing too much work. I've seen `no-restricted-syntax` take 2+ minutes when someone wrote a regex that backtracked to hell. V9.34.0's multithread linting helps a ton, but it won't fix badly written rules. It just makes them fail faster across more cores.

What's the difference between ESLint rules and plugins?

ESLint rules are individual checks (like `no-unused-vars` or `prefer-const`) that examine specific patterns in your code. Plugins are collections of rules, often focused on specific frameworks or use cases. For example, `eslint-plugin-react` contains dozens of React-specific rules. Plugins can also provide custom parsers, processors, and environments beyond just rules.

How do I handle ESLint conflicts in team settings?

Team ESLint conflicts usually arise from different developers having different configurations or preferences. Solutions include: - Using shared configurations (like Airbnb or Standard) that everyone agrees on - Committing your `.eslintrc.js` and `.eslintignore` files to version control - Setting up ESLint in CI/CD to enforce consistent standards - Using `--fix` to automatically resolve formatting-related conflicts - Having team discussions about controversial rules rather than constantly changing configuration

Is it safe to use ESLint's auto-fix feature?

ESLint's auto-fix is generally safe for formatting and simple corrections, but should be used carefully with complex rules. The `--fix` flag only applies fixes that ESLint considers safe and semantically neutral. However, it's good practice to review auto-fixed changes, especially when first setting up ESLint on an existing codebase. Some fixes might change code behavior in subtle ways.

How do I create custom ESLint rules?

Custom ESLint rules are JavaScript modules that export a rule definition. You can create them as part of a plugin or as standalone rules. The ESLint documentation provides a [comprehensive guide](https://eslint.org/docs/latest/extend/custom-rules) for writing custom rules. Most custom rules involve traversing the AST (Abstract Syntax Tree) and reporting issues when specific patterns are found. Tools like [AST Explorer](https://astexplorer.net/) help understand the AST structure.

Should I migrate from TSLint to ESLint?

Yes, you should migrate from TSLint to ESLint if you haven't already. TSLint was officially deprecated in 2019, and the TypeScript team now recommends using ESLint with [@typescript-eslint](https://typescript-eslint.io/). The migration provides better performance, more rules, active development, and better ecosystem support. Migration tools are available to help convert TSLint configurations to ESLint.

How does ESLint compare to newer tools like Biome and Oxlint?

![JavaScript OS Award 2024 - Biome as Productivity Booster](https://biomejs.dev/_astro/JS_OSAward_2024_5_1.DAezUIm4_k2bVY.webp) Newer tools like [Biome](https://biomejs.dev/) and [Oxlint](https://oxc-project.github.io/) offer significantly better performance (10-100x faster) but with trade-offs. ESLint has the largest ecosystem (4,000+ plugins), most mature tooling, and widest IDE support. Newer tools are better for performance-critical scenarios or new projects where you can adopt their conventions. ESLint remains the safer choice for most existing projects due to its stability and ecosystem.

What's ESLint's future with AI-powered code analysis?

ESLint isn't sitting still while AI tools like [GitHub Copilot](https://github.com/features/copilot), [Cursor](https://cursor.sh/), and [Codeium](https://codeium.com/) change how developers write code. The [ESLint team is exploring](https://eslint.org/blog/2025/01/eslint-2024-year-review/) AI-assisted rule suggestions and semantic analysis that goes beyond syntax patterns. Expect integration with AI code generation tools to catch issues that static analysis alone might miss, while maintaining ESLint's core philosophy of configurable, transparent rules.

Currently viewing the AI version

Switch to human version

ESLint: JavaScript Linting Utility - AI-Optimized Technical Reference

Configuration and Setup

Installation Requirements

Installation: npm install --save-dev eslint + npx eslint --init
Node.js Compatibility: Some plugins break on specific Node versions (e.g., @typescript-eslint issues on Node 16.14.2, requires 16.15.0+)
Common Failure: "Failed to load parser" error despite installation - requires deleting node_modules and reinstalling

Configuration Approaches

Method	Use Case	Complexity	Performance Impact
Flat Config (eslint.config.js)	ESLint v9+ projects	Low	Fastest
Legacy Config (.eslintrc.js)	Backward compatibility	Medium	Slower
Shared Configs	Team standardization	Low	Variable

Critical Warning: Running npx eslint --init in wrong directory creates config in wrong location, causing 20+ minute debugging sessions.

Performance Optimization

ESLint v9.34.0 Multithread Linting

Performance Gain: 1.3x to 3x faster depending on hardware
Real-world Impact: 2.3M line monorepo: 2min 30sec → 52sec
Usage: npx eslint --concurrency=auto
Warning: Manual concurrency settings can overwhelm hardware (--concurrency=8 on 4-core = system overload)

Performance Killers

eslint-plugin-import: Can add 800ms per file if misconfigured
import/no-cycle rule: Extremely slow on large codebases
no-restricted-syntax: Can take 2+ minutes with complex regex patterns
Solution: Use TIMING=1 npx eslint . to identify slow rules

Essential Performance Features

Caching: --cache flag - reduces 45sec to 8sec on repeat runs
File Filtering: .eslintignore prevents scanning dependencies
Rule-specific Timing: Identifies performance bottlenecks

Language and Framework Support

TypeScript Integration

Required Packages: @typescript-eslint/parser + @typescript-eslint/eslint-plugin
Migration Status: TSLint deprecated 2019, ESLint+typescript-eslint is official recommendation
Weekly Downloads: 50M+ (indicates stability)

Framework Support

Framework	Plugin	Weekly Downloads	Maturity
React	eslint-plugin-react	25M+	Mature
Vue.js	vue-eslint-parser	Active	Mature
Angular	@angular-eslint	Active	Mature
Node.js	eslint-plugin-node	Active	Mature

Performance Comparison with Alternatives

Tool	Performance	Ecosystem	Risk Level
ESLint	Fast (with v9.34.0)	4,000+ plugins	Low
Biome	35x faster formatting	Growing	Medium
Oxlint	50-100x faster	ESLint compatible	High (development stage)

Decision Criteria:

Choose ESLint: Existing projects, need plugin ecosystem, enterprise requirements
Choose Biome/Oxlint: New projects, performance critical, can accept limited ecosystem

Critical Failure Scenarios

Common Gotchas and Solutions

Parser Errors

Error: "ESLint is unable to determine what parser to use"
Root Causes:

Missing parser for file type (.vue, .ts files without proper parser)
Missing parser field in config
Monorepo with configs in wrong locations

Nuclear Option: Add problematic file types to .eslintignore during debugging

CI/CD Performance Issues

Symptom: CI time increased from 3 minutes to 12 minutes
Root Cause: eslint-plugin-import scanning entire node_modules for every import
Solutions:

Different configs for dev vs CI
Disable expensive rules in development
Use multithread linting in CI

Memory Issues

Symptom: Out-of-memory errors in large codebases
Solution: v9.34.0 worker-thread architecture isolates memory per thread
Workaround: Process files in smaller batches

Production-Ready Configuration

Security and Quality Rules

eslint-plugin-security: Detects XSS, SQL injection risks
eslint-plugin-jsx-a11y: Accessibility compliance (React)
eslint-plugin-no-secrets: Prevents hardcoded secrets

Enterprise Integration

CI/CD Support: GitHub Actions, GitLab CI, Jenkins, CircleCI
Reporting: JSON, JUnit, HTML formatters for dashboards
Monorepo Tools: Nx, Rush, Turborepo for caching strategies

Gradual Adoption Strategy

Week 1: Error-level rules only (no-undef, no-unreachable)
Week 3: Style rules as warnings
Week 6: Warnings to errors for new files only
Month 3: Apply to existing code during refactoring

Critical Mistake: Enabling strict rules (e.g., @typescript-eslint/no-explicit-any) across entire codebase breaks hundreds of files instantly.

Resource Requirements

Time Investment

Initial Setup: 30 minutes (assuming no gotchas)
Team Alignment: 2-4 weeks for rule agreement
Legacy Migration: 1-3 months depending on codebase size

Expertise Requirements

Basic Setup: Junior developer can handle
Custom Rules: Senior developer with AST knowledge
Enterprise Configuration: DevOps + Senior Developer

Breaking Points

File Count: UI becomes unusable at 1000+ spans in error output
Rule Complexity: Complex regex rules can cause exponential slowdown
Monorepo Scale: Without proper caching, scales poorly beyond 100k lines

Migration and Legacy Support

ESLint Version Migration

v8 to v9: Flat config system requires configuration rewrite
Legacy Support: .eslintrc files still supported but not recommended
Breaking Changes: Some plugins require updates for v9 compatibility

Integration with Modern Tools

AI Code Generation: Works with GitHub Copilot, Cursor, Codeium
Future Direction: AI-assisted rule suggestions in development

Operational Intelligence

What Official Documentation Doesn't Tell You

Default settings often fail in production environments
Plugin quality varies dramatically - some are abandoned or poorly maintained
Community wisdom often contradicts official recommendations
Migration between major versions has hidden breaking changes

Support Quality Indicators

ESLint Core: Excellent support, active development
Popular Plugins: Generally good support
Niche Plugins: Support quality unpredictable

Real-world Constraints

Teams often disable rules due to refactoring costs rather than technical merit
Performance considerations trump code quality in CI environments
Plugin maintenance becomes technical debt when maintainers abandon projects

Decision Framework

Use ESLint When:

Working with existing JavaScript/TypeScript codebase
Need extensive plugin ecosystem
Require enterprise-grade stability
Team has mixed skill levels

Consider Alternatives When:

Starting greenfield project
Performance is critical constraint
Can accept limited plugin ecosystem
Team comfortable with newer tooling

Success Metrics

Linting time under 30 seconds for typical development workflow
Less than 5% of developer time spent on linting configuration
Zero production bugs related to code quality issues ESLint should catch

Useful Links for Further Investigation

Essential ESLint Resources and Documentation

Link	Description
ESLint Official Website	The primary source for ESLint documentation, including getting started guides, rule reference, and configuration options. Features an interactive playground for testing rules and configurations.
ESLint GitHub Repository	The main ESLint repository containing source code, issue tracking, and contribution guidelines. Essential for staying current with development and reporting bugs.
ESLint Rules Reference	Comprehensive documentation of all built-in ESLint rules, with examples and configuration options for each rule.
ESLint Configuration Guide	Detailed guide to configuring ESLint, covering flat config, legacy config, and advanced configuration patterns.
ESLint Playground	Interactive online tool for testing ESLint rules and configurations without local setup. Excellent for experimenting with different rule combinations.
TypeScript ESLint	The official TypeScript integration for ESLint, providing TypeScript-aware linting rules and parser. Essential for any TypeScript project using ESLint.
TypeScript ESLint Rules	Complete documentation of TypeScript-specific ESLint rules, including type-aware rules that leverage TypeScript's type checker.
Migration Guide from TSLint	Step-by-step guide for migrating from the deprecated TSLint to ESLint with TypeScript support.
Airbnb ESLint Config	One of the most popular shared ESLint configurations, providing comprehensive rules for JavaScript and React development.
Standard JS	Zero-configuration JavaScript standard style guide with built-in linter and automatic code fixer.
Google ESLint Config	Google's ESLint configuration following their JavaScript style guide.
ESLint Plugin React	React-specific ESLint rules for detecting common issues and enforcing best practices in React applications.
ESLint Plugin Security	Security-focused ESLint rules for identifying potential vulnerabilities in JavaScript code.
VS Code ESLint Extension	Official ESLint extension for Visual Studio Code, providing real-time linting feedback and auto-fixing capabilities. Install via Extensions view with ID: dbaeumer.vscode-eslint
WebStorm ESLint Integration	Built-in ESLint support in WebStorm IDE with configuration and auto-fixing features.
Vim ESLint Integration	ALE (Asynchronous Lint Engine) provides ESLint integration for Vim and Neovim with real-time error highlighting.
Emacs ESLint Support	Flycheck extension for Emacs with comprehensive ESLint integration and syntax checking.
Prettier ESLint Integration	Guide for integrating Prettier code formatter with ESLint to avoid conflicts and ensure consistent code style.
Husky Git Hooks	Tool for setting up Git hooks that can run ESLint before commits, ensuring code quality in version control.
lint-staged	Run ESLint only on staged files in pre-commit hooks, significantly improving performance in large repositories.
ESLint Webpack Plugin	Official webpack plugin for running ESLint during builds with hot reloading support.
ESLint Vite Plugin	Vite plugin for integrating ESLint with hot module replacement and build-time checking.
ESLint Blog	Official ESLint blog featuring release announcements, feature deep-dives, and community updates.
Awesome ESLint	Curated list of ESLint resources, including plugins, configurations, and tools.
ESLint Discussion Forum	Community chat and discussion platform for ESLint users and contributors.
ESLint on Stack Overflow	Large collection of ESLint-related questions and answers from the developer community.
ESLint Release Notes	Archive of all ESLint release announcements with detailed change logs and migration information.
ESLint Contributors Guide	Comprehensive guide for contributing to ESLint development, including code, documentation, and community contributions.
ESLint RFC Process	Repository tracking ESLint's Request for Comments process for major changes and new features.
ESLint GitHub Discussions	Official discussion forum for ESLint users to ask questions and share knowledge.
AST Explorer	Interactive tool for exploring Abstract Syntax Trees, essential for understanding how ESLint analyzes code and for writing custom rules.
ESLint Performance Timing	Documentation on using ESLint's built-in performance timing to identify slow rules and optimize configuration.
ESLint Caching Guide	Information on using ESLint's caching features to improve performance in large projects.
eslint-remote-tester	Tool for testing ESLint rules and configurations against multiple real-world repositories to catch performance regressions.
ESLint Rule Testing Utilities	Official utilities for testing custom ESLint rules with comprehensive test cases and validation.
Action ESLint	Popular GitHub Action for running ESLint in CI/CD pipelines with annotations and caching support.
ESLint Config Inspector	Visual tool for inspecting and debugging ESLint configurations, especially useful for flat config migrations.
Biome	Fast alternative to ESLint and Prettier written in Rust, offering significant performance improvements for certain use cases.
Oxlint	High-performance linter written in Rust that aims for ESLint compatibility with dramatically better performance.
Rome Tools	Unified toolchain for JavaScript (now archived, succeeded by Biome) that attempted to replace multiple tools including ESLint.

ESLint: JavaScript Linting Utility - AI-Optimized Technical Reference

Configuration and Setup

Installation Requirements

Configuration Approaches

Performance Optimization

ESLint v9.34.0 Multithread Linting

Performance Killers

Essential Performance Features

Language and Framework Support

TypeScript Integration

Framework Support

Performance Comparison with Alternatives

Critical Failure Scenarios

Common Gotchas and Solutions

Parser Errors

CI/CD Performance Issues

Memory Issues

Production-Ready Configuration

Security and Quality Rules

Enterprise Integration

Gradual Adoption Strategy

Resource Requirements

Time Investment

Expertise Requirements

Breaking Points

Migration and Legacy Support

ESLint Version Migration

Integration with Modern Tools

Operational Intelligence

What Official Documentation Doesn't Tell You

Support Quality Indicators

Real-world Constraints

Decision Framework

Use ESLint When:

Consider Alternatives When:

Success Metrics

Useful Links for Further Investigation

Essential ESLint Resources and Documentation

Related Tools & Recommendations

Fix Kubernetes ImagePullBackOff Error - The Complete Battle-Tested Guide

Fix Git Checkout Branch Switching Failures - Local Changes Overwritten

YNAB API - Grab Your Budget Data Programmatically

NVIDIA Earnings Become Crucial Test for AI Market Amid Tech Sector Decline - August 23, 2025

Longhorn - Distributed Storage for Kubernetes That Doesn't Suck

How to Set Up SSH Keys for GitHub Without Losing Your Mind

Braintree - PayPal's Payment Processing That Doesn't Suck

Trump Threatens 100% Chip Tariff (With a Giant Fucking Loophole)

Tech News Roundup: August 23, 2025 - The Day Reality Hit

Someone Convinced Millions of Kids Roblox Was Shutting Down September 1st - August 25, 2025

Microsoft's August Update Breaks NDI Streaming Worldwide

Docker Desktop Hit by Critical Container Escape Vulnerability

Roblox Stock Jumps 5% as Wall Street Finally Gets the Kids' Game Thing - August 25, 2025

Meta Slashes Android Build Times by 3x With Kotlin Buck2 Breakthrough

Apple's ImageIO Framework is Fucked Again: CVE-2025-43300

Figma Gets Lukewarm Wall Street Reception Despite AI Potential - August 25, 2025

Anchor Framework Performance Optimization - The Shit They Don't Teach You

GPT-5 Is So Bad That Users Are Begging for the Old Version Back

Git RCE Vulnerability Is Being Exploited in the Wild Right Now

Microsoft's Latest Windows Patch Breaks Streaming for Content Creators