rahulsub Simplify Code Skill
Trigger
Use after implementing a feature, or when code feels bloated or over-engineered.
Philosophy
LLMs tend to over-engineer. The best code is code that doesn't exist. Every line is a liability. Simpler code is easier to understand, test, debug, and maintain.
Process
Step 1: Question Every Abstraction
- Does this abstraction have more than one user?
- If not, inline it.
- Is this interface used by external code? If not, simplify it.
- Are there generic solutions for specific problems? Make them specific.
Step 2: Count the Lines
Before and after. Set a target. If you have 500 lines, ask: "Can this be 200?"
Step 3: Remove These Patterns
Over-abstracted factories:
// Before: Factory that only creates one thing
class UserServiceFactory {
create(): UserService { return new UserService(); }
}
// After: Just use the class directly
const userService = new UserService();
Unnecessary interfaces:
// Before: Interface with single implementation
interface IUserRepository { ... }
class UserRepository implements IUserRepository { ... }
// After: Just the class (add interface when you need it)
class UserRepository { ... }
Config objects for fixed values:
// Before
const config = { maxRetries: 3, timeout: 5000 };
function fetch(url: string, config: Config) { ... }
// After (if values never change)
function fetch(url: string) {
const maxRetries = 3;
const timeout = 5000;
...
}
Premature error handling:
// Before: Handling impossible errors
try {
const x = 1 + 1;
} catch (e) {
// This can never throw
}
// After: Trust code that can't fail
const x = 1 + 1;
Step 4: Flatten Hierarchies
- Deep nesting is a smell
- Early returns over nested ifs
- Composition over inheritance
- Inline small helper functions called once
Step 5: Remove Dead Code
- Unused imports
- Unused variables
- Commented-out code
- Functions that are never called
- Branches that can never execute
Output
After simplification, report:
- Lines before: X
- Lines after: Y
- Reduction: Z%
- Key simplifications made