Design note: errors, not warnings
This note goes with Compile-Time Code Quality Enforcement, in particular Why Compile-Time Enforcement? and Impact on AI-Assisted Development. EK9 checks code quality in the compiler and reports every failure as an error. There are no quality warnings.
The problem with optional tools
Most languages rely on a fragmented set of optional, external tools:
- Checkstyle/StyleCop for style checking (optional, configurable, ignorable)
- SonarQube/NDepend for complexity and quality (requires setup, often ignored)
- Snyk/Fortify for security scanning (external, expensive)
- Code review for design quality (subjective, slow, inconsistent)
- CI/CD gates for enforcement (can be bypassed, creates friction)
The result is quality enforcement that is fragmented, optional and bypassable. Warnings accumulate, tools are misconfigured, and technical debt compounds over time.
One tool: the compiler
EK9 replaces that set of tools with the compiler. The thresholds are part of the language, so there is nothing to configure; the checks run during compilation, so there is nothing to install; and every failure is an error, so there is nothing to bypass.
The important step is removing the warning. A warning is a statement that something "will be fixed later". Under deadline pressure, later does not come, and the warnings become the technical debt. With no warnings, there is nothing to put off: the code meets the standard or it does not compile.
AI coding assistants
AI coding assistants (GitHub Copilot, Claude and others) generate code quickly, and often with quality problems:
- Excessive complexity: long functions with many conditions
- High coupling: dependencies added to solve the problem in front of it quickly
- Duplication: code that should have been refactored into a shared function (the compiler does not detect duplication yet, so this one is still the reviewer's)
- Deep hierarchies: inheritance patterns followed from training data
Generating code faster does not make it better, and an assistant that is not stopped produces debt at the speed it produces code. The compiler stops it the same way it stops a person:
- Feedback in the loop: the assistant reads the error and corrects the code; the
-E3flag gives a detailed explanation of each error to work from - One standard: AI-generated code that compiles has passed the same checks as any other code
- Objective standards: no debate about quality; the compiler is the arbiter
For a team adopting AI assistants, that means:
- Zero configuration: no external quality tools to set up and maintain
- Consistent standards: the same bar across every project and team
- Faster onboarding: new developers, and AI, learn good design from the compiler's feedback
- No quality debt from AI-generated code in what the compiler checks: that kind of debt cannot accumulate, because code that fails a check does not compile
The For AI Assistants page documents the machine-readable side of this.