Code Smell Analyzer
Analyzes code files for potential improvements including code smells, design patterns, and best practices. Provides suggestions for enhancing readability, maintainability, and performance while preserving functionality.
When to Use
Invoke this skill when:
- User asks for code analysis or code review
- User wants suggestions to improve code quality
- User mentions "code smells", "refactoring", or "best practices"
- User wants to optimize code structure without changing functionality
Analysis Framework
1. Code Smells
Identify any code smells such as:
- Long Methods: Methods exceeding 20-30 lines should be broken down
- Large Classes: Classes with too many responsibilities
- Duplicate Code: Repeated code blocks that should be extracted
- Complex Conditionals: Deeply nested if/else statements
- Magic Numbers: Hard-coded values without explanation
- Dead Code: Unused variables, methods, or imports
- Long Parameter Lists: Methods with more than 3-4 parameters
- Feature Envy: Methods that use another class more than their own
2. Design Patterns
Suggest appropriate design patterns that could improve the code structure:
- Creational: Factory, Builder, Singleton, Prototype
- Structural: Adapter, Decorator, Facade, Composite
- Behavioral: Strategy, Observer, Command, State, Template Method
3. Best Practices
Check adherence to language-specific best practices:
- Naming Conventions: Clear, descriptive names for variables, functions, classes
- DRY Principle: Don't Repeat Yourself
- SOLID Principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
- Error Handling: Proper exception handling and error messages
- Documentation: Adequate comments and documentation
- Testing: Testability of the code
4. Readability
Evaluate code clarity:
- Naming: Are names self-documenting?
- Structure: Is the code well-organized?
- Comments: Are complex sections explained?
- Formatting: Is indentation and spacing consistent?
- Abstraction Level: Is the code at the right level of abstraction?
5. Maintainability
Assess how easy the code would be to modify and extend:
- Coupling: Are components loosely coupled?
- Cohesion: Are related functionalities grouped together?
- Modularity: Can parts be changed independently?
- Configuration: Are hard-coded values externalized?
- Logging: Is there adequate logging for debugging?
6. Performance
Identify potential performance optimizations:
- Algorithm Complexity: O(n) vs O(n^2) considerations
- Memory Usage: Unnecessary object creation, memory leaks
- I/O Operations: Database queries, file operations, network calls
- Caching: Opportunities for caching repeated computations
- Lazy Loading: Defer expensive operations until needed
Output Format
For each suggestion, provide:
Issue Description
Clear explanation of the issue or improvement opportunity.
Current Code
// Show the problematic code
Suggested Improvement
// Show the improved code
Rationale
Explain why the change would be beneficial.
Priority
- High: Critical issues affecting functionality, security, or major performance
- Medium: Important improvements for maintainability and readability
- Low: Minor enhancements or nice-to-have improvements
Example Analysis
Issue: Long Method with Multiple Responsibilities
Priority: High
Current Code:
function processOrder(order) {
// Validate order
if (!order.items || order.items.length === 0) {
throw new Error('Order has no items');
}
if (!order.customer) {
throw new Error('Customer is required');
}
// Calculate totals
let subtotal = 0;
for (const item of order.items) {
subtotal += item.price * item.quantity;
}
const tax = subtotal * 0.1;
const total = subtotal + tax;
// Apply discount
if (order.discountCode) {
total = total * 0.9;
}
// Save to database
db.orders.insert({
...order,
subtotal,
tax,
total,
createdAt: new Date(),
});
// Send confirmation email
emailService.send(order.customer.email, 'Order Confirmed', total);
return {orderId: order.id, total};
}
Suggested Improvement:
function processOrder(order) {
validateOrder(order);
const pricing = calculatePricing(order);
saveOrder(order, pricing);
sendConfirmation(order, pricing.total);
return {orderId: order.id, total: pricing.total};
}
function validateOrder(order) {
if (!order.items?.length) throw new Error('Order has no items');
if (!order.customer) throw new Error('Customer is required');
}
function calculatePricing(order) {
const subtotal = order.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
const tax = subtotal * 0.1;
let total = subtotal + tax;
if (order.discountCode) {
total *= 0.9;
}
return {subtotal, tax, total};
}
function saveOrder(order, pricing) {
db.orders.insert({
...order,
...pricing,
createdAt: new Date(),
});
}
function sendConfirmation(order, total) {
emailService.send(order.customer.email, 'Order Confirmed', total);
}
Rationale:
- Single Responsibility: Each function has one clear purpose
- Testability: Each function can be tested independently
- Readability: Main function reads like a high-level overview
- Maintainability: Changes to pricing logic don't affect validation
Language-Specific Considerations
JavaScript/TypeScript
- Use
const/let instead of var
- Prefer arrow functions for callbacks
- Use optional chaining (
?.) and nullish coalescing (??)
- Avoid
any type in TypeScript
Python
- Follow PEP 8 style guide
- Use list comprehensions appropriately
- Leverage context managers (
with statements)
- Type hints for better documentation
Java
- Use streams for collection operations
- Prefer composition over inheritance
- Use Optional instead of null
- Follow Java naming conventions
WeChat Mini Program
- Use Service layer for all HTTP requests
- Avoid storing redundant data in Page data
- Use
wx:key for list rendering
- Follow the project's AGENTS.md guidelines
Notes
- Always preserve existing functionality
- Consider the project's existing conventions
- Prioritize changes by impact and effort
- Provide actionable, specific suggestions
- Consider backward compatibility
