Zero Warnings Enforcer

Enforce zero ESLint warnings and TypeScript errors via root-cause fixes.

Updated Oct 31, 2025
One-click install
npx skills add https://github.com/RomualdP/hoki --skill zero-warnings-enforcer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Zero Warnings Enforcer
Source: https://github.com/RomualdP/hoki/tree/main/.claude/skills/zero-warnings
Command: npx skills add https://github.com/RomualdP/hoki --skill zero-warnings-enforcer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires eslint, typescript, husky, lint-staged.

What problem does it solve?

This Skill enforces a "Zero Warnings" policy, eliminating technical debt and improving code quality by strictly prohibiting ignored ESLint warnings, TypeScript errors, and weak types, leading to more reliable and maintainable software.

Core Features & Use Cases

  • Broken Window Theory: Applies the principle that even small ignored issues lead to rapid code degradation, promoting immediate correction of all warnings and errors.
  • Strict ESLint & TypeScript Rules: Provides guidance on configuring and adhering to strict linting and typing rules, including how to fix common issues like unused variables, any types, and unhandled promises.
  • Quality Gates: Integrates pre-commit hooks (Husky, lint-staged) and CI/CD pipelines to enforce zero warnings/errors before code is merged or deployed.
  • Use Case: During a code review, if a developer introduces a new ESLint warning or TypeScript error, this Skill guides them to identify the root cause and fix it properly, rather than suppressing the warning.

Quick Start

To ensure zero warnings, run yarn lint --max-warnings 0 and yarn tsc --noEmit before every commit. If a warning or error appears, identify its root cause and fix it, never disable the rule.

Frequently Asked Questions about Zero Warnings Enforcer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce zero ESLint warnings and TypeScript errors in my project?

Enforce zero warnings by running `yarn lint --max-warnings 0` and `yarn tsc --noEmit` before commits. When warnings or errors appear, identify and fix the root cause rather than disabling rules. Integrate these checks into pre-commit hooks using Husky and lint-staged to prevent violations from merging.

What's the best way to prevent ignored ESLint rules and @ts-ignore comments in code reviews?

A zero warnings policy prevents rule suppression by requiring root-cause fixes instead. Configure ESLint and TypeScript with strict rules, then use pre-commit hooks and CI/CD quality gates to block any code containing eslint-disable comments or @ts-ignore directives, enforcing immediate resolution.

How do I set up Husky and lint-staged to catch linting issues before commit?

Install Husky and lint-staged, then configure pre-commit hooks to run `eslint` and `tsc --noEmit` on staged files. This creates a quality gate that prevents commits with warnings or errors, integrating zero warnings enforcement directly into your development workflow.

Can I use ESLint and TypeScript strict mode together to eliminate technical debt?

Yes. Configure ESLint with strict rules and TypeScript with `strict: true` to catch unused variables, weak types, and unhandled promises. Apply the broken window theory by fixing every warning immediately rather than accumulating ignored issues, preventing rapid code degradation.

Why should I avoid disabling ESLint rules instead of fixing warnings?

Disabling rules creates technical debt that accelerates code degradation, following the broken window theory. Root-cause fixes preserve static typing, maintain code quality, and prevent warning accumulation. Strict enforcement ensures reliable, maintainable software and catches issues during development rather than production.

Does a zero warnings policy work with existing TypeScript projects?

Yes. Gradually migrate existing projects by enabling strict ESLint and TypeScript rules, then systematically fixing warnings and errors rather than suppressing them. Integrate Husky and lint-staged quality gates to prevent new violations, building toward a fully zero warnings state.