A base class can change save() to persist() and leave a subclass with a save() method that no longer overrides anything. TypeScript can still compile that code because the subclass has simply gained its own method with a name that the base-class contract no longer calls.
noImplicitOverride closes that gap. When a subclass really replaces an inherited member, it must write override. If the base-class method is renamed, the compiler points out the mismatch instead of letting a silent override drift through review.
This article explains the mechanism, shows the difference between override and a local method, and proposes a short migration with tsc --noEmit. I compiled the fixture locally with TypeScript 5.9.3 on November 16, 2026. It proves the compiler diagnostic in a minimal example, not the result of a production migration.
Short answer
- Enable
noImplicitOverridewhen the intent to replace methods should appear in the code.- Use
overrideon every member that really replaces a base-class member.- If a method stops overriding after a rename, fix the contract or rename the helper. Do not use
as anyto hide the diagnostic.- The option checks the relationship between classes. It does not prove that the hierarchy is the right design for the domain.
What does noImplicitOverride check?
TypeScript checks that a member marked with override exists in the base class and that the declaration can replace it. With noImplicitOverride: true, it also requires the keyword when a subclass is already overriding an inherited member.
The official noImplicitOverride reference uses an Album class and shows the error when a subclass redefines a method without the modifier. The TypeScript 4.3 release notes explain the related problem: after a method is renamed in the base class, a subclass can keep the old name without the compiler knowing that it was meant to be an override.
The important part is intent. The compiler is not saying that every class should use inheritance. It is asking you to declare a replacement as a replacement.
Why can a rename pass without the option?
Consider this hierarchy:
class Repository {
save(value: string): string {
return value;
}
}
class AuditedRepository extends Repository {
save(value: string): string {
return `audit:${super.save(value)}`;
}
}
The second save overrides the first. Now the base class changes because of a naming decision:
class Repository {
persist(value: string): string {
return value;
}
}
class AuditedRepository extends Repository {
save(value: string): string {
return `audit:${value}`;
}
}
The subclass method is still valid TypeScript. The semantic problem is that calls made through a Repository reference now use persist, while the audit logic sits in a method that the base contract does not know about. The old name no longer preserves the relationship that existed before.
With override, the intent is tied to the contract:
class AuditedRepository extends Repository {
override save(value: string): string {
return `audit:${super.save(value)}`;
}
}
After Repository.save becomes Repository.persist, the compiler reports that the member does not exist in the base class. That error forces a choice between override persist, a newly named local method, or a broader interface change.
How do you enable the check in tsconfig.json?
Add the option to the configuration that compiles the hierarchy:
{
"compilerOptions": {
"strict": true,
"noImplicitOverride": true,
"noEmit": true
}
}
The option is not part of the settings enabled by strict. A project can therefore use strict: true and still accept an override without the override modifier. The TSConfig reference is the source for the option's behavior, while your project command determines which configuration CI actually uses.
If the repository has several packages, keep this decision separate from build order. TypeScript Project References in a monorepo organize the project graph; noImplicitOverride checks intent inside each class. They are related build concerns, but they are not the same contract.
When should you use override or rename the method?
Use override when the member has the same role as the inherited contract. The method can call super, change the implementation, or add a policy, but the relationship to the base class must be real.
class JsonRepository extends Repository {
override save(value: string): string {
return JSON.stringify({ value: super.save(value) });
}
}
Do not use override on a helper that only happens to have a similar name. If the base class has save() and the subclass needs saveForAuditLog(), different names communicate the boundary better. If both methods have the same name, the option may reveal an inheritance relationship that was already hard to understand.
This limit matters: the modifier proves a nominal relationship to the base class, not the quality of the design. A class can still override a method with incompatible effects, call super in a dangerous order, or depend on an undocumented precondition. Those problems need tests and contract review.
How do you migrate a hierarchy without removing the signal?
Treat activation as a small compiler-contract change:
- Run the typecheck command CI uses today and record the effective configuration.
- Enable
noImplicitOverridein one package or project with a clear boundary. - For each diagnostic, confirm whether the member should replace a base-class member.
- Add
overridewhen the relationship is intentional. - Rename the method or change the contract when the relationship no longer exists.
- Run tests that exercise calls through the base class, not only calls through the concrete subclass.
- Keep the option in CI so a future rename produces an error in the same change set.
A minimal fixture for checking the local behavior is:
class Repository {
save(value: string): string {
return value;
}
}
class AuditedRepository extends Repository {
override save(value: string): string {
return `audit:${super.save(value)}`;
}
formatLabel(value: string): string {
return value.trim();
}
}
const repository = new AuditedRepository();
console.log(repository.save("ready"));
console.log(repository.formatLabel(" label "));
Save the snippet in an isolated project, use strict, noImplicitOverride, noEmit, and types: [], then run npx -p typescript@5.9.3 tsc -p tsconfig.json --pretty false. The fixture passes. If you rename save in the base class without updating the subclass, the override modifier produces TS4113. That checks the configuration boundary, but it does not replace the real package's tests. When the change also alters a service's error path, Result or Exceptions in a TypeScript Service covers that separate decision.
What does not fix the problem?
Some shortcuts make the build green without preserving intent:
- remove
overridefrom every method, deleting the relationship the option documents; - use
as any,as unknown as, or another assertion to make a member appear compatible; - disable
noImplicitOverridefor the whole package because a diagnostic requires a decision; - add
overridewithout checking that the base class still provides the behavior the subclass needs.
An assertion can have a place at a boundary the compiler cannot prove, but it is not an answer to a rename that the source code can correct. TypeScript satisfies for configuration covers a related decision for values written in code: checking a contract is not the same as asking the compiler to trust blindly.
If a coding agent changes a base class and its subclasses in the same task, include the question “did the contract change, or only the implementation?” in review. RemoteCode is the author's tool for this kind of workflow, but compilation and tests remain the repository's proof.
Frequently asked questions
Does noImplicitOverride require override in every child class?
No. It requires the modifier on members that actually override inherited members. A new method whose name does not exist in the base class does not need override.
Does override apply when implementing an interface?
The modifier describes a replacement in a base class. Implementing an interface is a different type relationship and should not be treated as overriding an implementation. If the class also extends a base class, analyze the two relationships separately.
Does adding override change the JavaScript that runs?
Not by itself. The modifier participates in TypeScript checking and is not a runtime policy. Behavior still depends on the prototype chain, the method being called, and the tests that cover the call.
Sources and limits
- TypeScript, “TSConfig Option: noImplicitOverride”, retrieved November 16, 2026.
- TypeScript, “TypeScript 4.3 release notes”, retrieved November 16, 2026.
- TypeScript Playground, “No Implicit Class Overrides”, retrieved November 16, 2026.
Samuel Fajreldines is responsible for this article. The research compared official TypeScript references with a public configuration from an active project. The local fixture passed with TypeScript 5.9.3 and failed with TS4113 after a deliberate base-class rename. That demonstrates the mechanism in a minimal case, not the safety of a production hierarchy. AI assistance helped with research, drafting, localization, and review; it did not run the fixture or replace the sources and the author's editorial responsibility.