Linting
Linting is the automated static analysis of source code or configuration against rules to detect potential errors, suspicious patterns, and style or consistency violations.
"Looks Good to Me"
A software tool that analyzes source code to detect stylistic, structural, or potential quality problems without executing the program.
- How it is used
- Automates low-stakes code checks during development and before code review.
- How deep it goes
- Defines rule-based fault detection, severity choices, and tool boundaries, while leaving rule policy to each team.
- Examples
- Uses ESLint checks for console calls, variables, imports, equality, alerts, loops, and unnecessary ternaries.
- What you can do after
- Apply linting via ESLint to detect and fix recurring code problems before review.
Vibe Engineering
A local linter is a tool run in a developer's environment that statically analyzes source code for style issues, likely errors, and convention violations.
- How it is used
- Catches known code patterns early in a layered verification loop for AI-generated changes.
- How deep it goes
- Explains pattern-based detection and false positives, then places linting in local and CI validation without detailing linter internals.
- Examples
- Uses a markup parser's nested-quantifier regex and unclosed inputs to illustrate a security warning and rapidly growing execution time.
- What you can do after
- Apply linting via ESLint and an enabled security plugin, and investigate warnings alongside other verification checks.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
Linting is the automated analysis of code or configuration to detect nonstandard style, invalid constructs, and incorrect configuration.
- How it is used
- Catches invalid infrastructure fields, syntax, style, and security violations before code is committed or executed.
- How deep it goes
- Defines automated style and configuration checks, then connects them to hooks, extensions, CI, and shared repository standards.
- Examples
- Uses an ip versus ip_address field error, YAML spacing checks, pre-commit hooks, and shared prototype-module tests.
- What you can do after
- Diagnose configuration mistakes early and enforce shared style, naming, security, and conformance rules automatically.
The Design of Web APIs, Second Edition
A linter is a static-analysis tool that examines source or specification documents for errors, inconsistencies, and possible improvements.
- How it is used
- Checks API definitions against design guidelines so designers can focus on consumer needs rather than repeatable details.
- How deep it goes
- Defines API linting, walks through representative diagnostics and tool-selection criteria, but does not show rule syntax in the supplied evidence.
- Examples
- Uses inconsistent property casing, missing search pagination, undefined security scopes, duplicated path parameters, and inline request-body schemas.
- What you can do after
- Apply it via an API linter to identify design and OpenAPI authoring problems early, then assess findings against consumer needs.
Read how The Design of Web APIs, Second Edition explains linting →
Essential TypeScript 5, Third Edition
A linter is a software tool that analyzes source code against configurable rules to identify problems or undesirable patterns.
- How it is used
- Finds confusing patterns and common coding errors that TypeScript’s compiler does not detect.
- How deep it goes
- Walks through package installation, configuration, diagnostics, and rule exceptions rather than linter internals.
- Examples
- Uses `prefer-const` and `no-debugger` diagnostics, a `.eslintrc` rule override, and an inline `eslint-disable-line` comment.
- What you can do after
- Apply it via ESLint and typescript-eslint to check TypeScript files and tailor rules to a project.
Read how Essential TypeScript 5, Third Edition explains linting →
Shipping Go: Develop, deliver, discuss, design, and go again
A linter is a software tool that analyzes source code for programming errors, suspicious constructs, and style violations.
- How it is used
- Enforces code-quality and style rules as part of preparing changes for repository workflows.
- How deep it goes
- Defines linters’ role and links them to idiomatic Go, but does not detail specific linter rules or configuration.
- Examples
- Uses Go formatting and pipeline checks to illustrate automated enforcement alongside linting.
- What you can do after
- Evaluate how automated checks can enforce code-quality and style rules before repository changes proceed.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains linting →
React in Depth
Linting is the automated analysis of source code to identify coding errors, undesirable practices, and stylistic violations.
- How it is used
- Uses automated checks to reduce coding errors and enforce consistent style in growing or collaborative projects.
- How deep it goes
- Defines linting and illustrates rule categories, but does not detail ESLint configuration or custom rule implementation.
- Examples
- Uses duplicate object keys, inconsistent return types, and missing final newlines as representative linting targets.
- What you can do after
- Apply ESLint-style checks to enforce conventions and reduce minor errors in source code.
Pro Angular 16
A linter is a static-analysis tool that examines source code for programming errors, style violations, and other rule-defined issues.
- How it is used
- Uses static analysis to catch code problems before version-control commits or other development processes.
- How deep it goes
- Explains installation, execution, diagnostics, suppressions, and rule configuration without detailing linter internals.
- Examples
- Demonstrates `debugger`, Angular selector casing, `ng lint` output, suppression comments, and `.eslintrc.json` rules.
- What you can do after
- Diagnose with `ng lint`, interpret rule violations, and configure or narrowly suppress unavoidable findings.
Build Financial Software with Generative AI (From Scratch)
A linter is a static-analysis tool that detects style violations, common programming mistakes, and other suspicious patterns in source code.
- How it is used
- Reduce cognitive load by promoting consistent code and checking it against company policies and standards.
- How deep it goes
- Connects linting to consistency and early checks for generated code, without detailing rule configuration or a linting workflow.
- Examples
- Names SonarLint as a linter and IDE syntax highlighting as another way to spot problems.
- What you can do after
- Apply linting to promote consistent code and identify potential problems, including in generated code.
Read how Build Financial Software with Generative AI (From Scratch) explains linting →
Also covered in
- PostgreSQL Mistakes and How to Avoid Them
- Web Component Development with Modern Libraries and ToolingIn early access (MEAP)
- 100 Go Mistakes and How to Avoid Them
- Rust Web Development
- Django in Action
- Software Engineering for Data ScientistsIn early access (MEAP)
- Secrets of the JavaScript Ninja, Third EditionIn early access (MEAP)
- GitHub Actions in Action: Continuous integration and delivery for DevOps
- Go in Practice, Second Edition
- Code Like a Pro in Rust
- Tiny Python Projects: Learn coding and testing with puzzles and games
- Acing the Frontend InterviewIn early access (MEAP)
What to know first
- JavaScriptJavaScript is a high-level, dynamically typed programming language standardized as ECMAScript and used for web and general-purpose programming.
- GoGo is a statically typed, compiled, general-purpose programming language with garbage collection and built-in support for concurrency.
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
Related concepts
- ESLintincludes · ESLint is an open-source, configurable static-analysis tool that identifies and optionally fixes coding problems in JavaScript, TypeScript, and related source code.
- Spectralincludes · Spectral is an open-source linter that applies configurable rules to JSON, YAML, and structured API description documents.
- Pylintincludes · Pylint is a Python static-analysis tool that detects programming errors, style violations, and other code-quality issues.
- static analysiskind of · Static analysis is the examination of source code or other software artifacts without executing the program to infer properties or identify potential issues.
Questions about linting
What is linting?
Linting is the automated static analysis of source code or configuration against rules to detect potential errors, suspicious patterns, and style or consistency violations.
Which Manning books explain linting?
"Looks Good to Me", Vibe Engineering, Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform, The Design of Web APIs, Second Edition, Essential TypeScript 5, Third Edition, Shipping Go: Develop, deliver, discuss, design, and go again, React in Depth, Pro Angular 16 and 1 more.
What should I know before learning linting?
Manning books that teach linting usually introduce JavaScript, Go, software testing and deployment pipeline first.
What kinds of linting are there?
Kinds of linting include ESLint, plpgsql_check, Spectral, SQLFluff and Pylint.
What is linting a kind of?
Linting is a kind of static analysis. Static analysis is the examination of source code or other software artifacts without executing the program to infer properties or identify potential issues.
What is linting also called?
Linting is also called lint.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.








