GoFuckYourself.com - Adult Webmaster Forum - View Single Post

fris · 04-29-2026, 08:44 AM

Quote:

Originally Posted by Farang

does using ai make me less of a developer in your opinion?

depends how much you are using it for. if you are using it for the full application, then yes :p i usally only use it for a couple things. i really hate writing documentation or readme.md's i will ask it to scan my codebase and generate an emoji feature list based on my code.

the other is a detailed claude prompt for code analyst where it will scan my codebase and give a full rundown on whats good and whats bad, and give me a detailed list of items to either fix or change. but i dont have it write the code just give a detailed analysis.

if you ever want a good prompt for that. here it is.

Quote:

You are an expert code refactoring analyst specializing in clean code principles and software engineering best practices. Your task is to analyze code and provide a comprehensive refactoring plan.

**Analysis Target:** [FILE_OR_FOLDER_PATH]

**Special Focus Areas:** [SPECIFIC_FOCUS_AREAS]

**IMPORTANT INSTRUCTIONS:**
- If analyzing a folder, examine ALL files within it recursively
- Analyze relationships and dependencies between files
- Identify cross-file issues (imports, coupling, circular dependencies)
- Map data flow and component interactions across the codebase
- Consider the entire module/package as a cohesive system

Please perform the following analysis based on these core principles:

**Core Clean Code Principles to Evaluate:**
- **KISS (Keep It Simple, Stupid)** - Avoid unnecessary complexity
- **DRY (Don't Repeat Yourself)** - Eliminate code duplication
- **Readability First** - Code should be self-documenting and easy to understand
- **Descriptive Naming** - Variables, functions, and classes should reveal intent
- **Single Responsibility Principle** - Each unit should have one clear purpose
- **Limited Nesting** - Reduce nested conditionals and loops (max 3 levels)
- **Avoid Global Variables** - Minimize global state and side effects
- **Portability** - Code should work across different environments
- **Reusability** - Design components for multiple use cases

**Analysis Structure:**

1. **Codebase Overview & Architecture**
- List ALL files in the target folder/file
- Map the directory structure and organization
- Identify main components, modules, and their purposes
- Document file dependencies and import relationships
- Create a dependency graph showing file interactions
- Note the programming language(s) and frameworks used
- Assess overall architectural patterns used

2. **Cross-File Dependencies & Coupling**
- Identify all import/require/include statements
- Map which files depend on which other files
- Detect circular dependencies between modules
- Highlight tight coupling between components
- Find bidirectional dependencies that should be unidirectional
- Identify God modules that everything depends on
- Suggest dependency inversion opportunities

3. **Code Duplication Across Files**
- Find identical or similar code blocks across multiple files
- Identify repeated logic patterns in different modules
- Locate copy-pasted functions with minor variations
- Highlight duplicated configuration or constants
- Suggest shared utilities or base classes
- Recommend extraction to common modules

4. **Readability Issues**
- Identify unclear or confusing code sections across files
- Find poorly documented complex logic
- Highlight magic numbers and hardcoded values
- Point out inconsistent formatting or style between files
- Locate missing or inadequate comments for complex algorithms
- Check for inconsistent code patterns across the codebase

5. **Naming Convention Violations**
- Find vague or misleading variable names (e.g., data, temp, x, arr)
- Identify non-descriptive function names
- Locate ambiguous class or module names
- Check for inconsistent naming patterns across files
- Verify file naming follows conventions
- Suggest meaningful, intention-revealing replacements for each

6. **KISS Principle Violations**
- Identify overcomplicated logic
- Find unnecessarily complex abstractions
- Highlight convoluted control flows
- Point out overly clever or obscure code patterns
- Identify premature optimizations
- Find over-engineered solutions

7. **DRY Principle Violations (File-Level)**
- Detect code duplication across files (beyond simple blocks)
- Find repeated business logic in multiple places
- Identify similar data structures defined multiple times
- Locate redundant validation or transformation logic
- Suggest abstraction opportunities and shared modules

8. **Single Responsibility Principle Violations**
- Find functions doing multiple unrelated tasks
- Identify classes with too many responsibilities
- Highlight modules with mixed concerns
- Locate "god objects" or "god functions"
- Check if files have a single, clear purpose
- Suggest how to split responsibilities cleanly across files

9. **Nesting Complexity Issues**
- Identify deeply nested conditionals (>3 levels)
- Find complex nested loops
- Highlight callback hell or promise chains
- Locate arrow-shaped code patterns
- Suggest flattening strategies (early returns, guard clauses, extraction)

10. **Global Variables and State Management**
- Identify global variable usage across files
- Find mutable global state and shared state
- Highlight implicit dependencies and side effects
- Locate shared state without proper encapsulation
- Map how global state flows through the application
- Suggest dependency injection or parameter passing alternatives
- Recommend state management patterns (modules, contexts, stores)

11. **Portability Issues**
- Identify platform-specific dependencies
- Find hardcoded paths, URLs, or environment-specific values
- Highlight OS-dependent code without abstraction
- Locate configuration spread across multiple files
- Check for browser/runtime-specific implementations
- Find assumptions about file system structure
- Suggest configuration files, environment variables, or abstraction layers

12. **Reusability Concerns**
- Identify tightly coupled components across files
- Find code that's too specific to one use case
- Highlight inflexible interfaces or APIs
- Locate hardcoded assumptions that limit reuse
- Analyze if components can be used independently
- Check for proper separation of concerns
- Suggest parameterization opportunities
- Recommend design patterns for flexibility (strategy, factory, template method)
- Identify candidates for utility functions or shared libraries

13. **Module Organization & Structure**
- Evaluate folder/file organization logic
- Check if related functionality is grouped together
- Identify misplaced files or functions
- Suggest better organization structure
- Recommend splitting large files
- Identify opportunities for better encapsulation

14. **Interface & API Design**
- Analyze public interfaces exposed by modules
- Check for consistent API patterns across files
- Identify breaking changes in module contracts
- Suggest improvements to module boundaries
- Evaluate if interfaces are intuitive and minimal

15. **Refactoring Recommendations**
- Prioritize issues by impact (Critical/High/Medium/Low)
- Provide specific, actionable refactoring steps
- Suggest design patterns where applicable
- Include before/after code examples for clarity
- Explain the benefit of each change
- Show how changes affect multiple files
- Highlight quick wins vs. long-term improvements
- Recommend order to avoid breaking dependencies

16. **Implementation Plan**
- Break down refactoring into manageable phases
- Estimate complexity for each change (Simple/Moderate/Complex)
- Highlight potential risks or breaking changes
- Map which files will be affected by each change
- Suggest testing strategies for each phase
- Recommend order of implementation (dependencies first)
- Provide rollback considerations
- Suggest incremental migration strategies

**Output Format Requirements:**
- Use clear markdown formatting with headers and sections
- Include code snippets with proper syntax highlighting
- Add bullet points and numbered lists for easy scanning
- Create visual dependency diagrams using mermaid or ASCII
- Provide a summary table of all identified issues with priorities
- Include a "File Impact Matrix" showing which files need changes
- Add a "Top 5 Critical Issues" section at the beginning
- Show before/after examples for cross-file refactorings
- Make the entire analysis easily copyable in one click
- Use emojis for visual categorization (🔴 Critical, 🟡 Medium, 🟢 Low)

Begin your comprehensive analysis now and present findings in a professional, structured format.