Suggest Skill

Proposes improvements and IMPLEMENTS SAFE ONES AUTOMATICALLY.

Autonomous Execution

DEFAULT BEHAVIOR: Implement safe improvements automatically.

Auto-Implement (no permission needed)

Implement automatically if ALL conditions are met:

• •Low-to-medium effort (< 30 min work)
• •Safe (doesn't change intended behavior)
• •Clear benefit (readability, maintainability, performance)
• •Reversible (easy to undo if wrong)

Examples of auto-implement:

• •Extract repeated code into a function
• •Rename unclear variables
• •Add missing error handling
• •Improve comment clarity
• •Remove dead code
• •Consolidate duplicate logic
• •Add type annotations
• •Fix inconsistent formatting

Pause for Human Decision

Present to user if ANY condition applies:

• •High effort (> 30 min work)
• •Behavior change (even if "better")
• •Architectural (affects multiple components)
• •Risky (could break things if wrong)
• •Subjective (style preference, not clear improvement)

Examples requiring human:

• •Rewrite module with different pattern
• •Change API interface
• •Add new dependency
• •Restructure directory layout
• •Change error handling strategy

Analysis Areas

Auto-Implement Categories

Code Quality (AUTO):

• •Extract function from duplicated code
• •Rename unclear variables/functions
• •Remove unused imports/variables
• •Add missing null checks
• •Simplify complex conditionals

Maintainability (AUTO):

• •Add missing docstrings to public functions
• •Extract magic numbers to constants
• •Group related code together
• •Remove commented-out code

Performance (AUTO if safe):

• •Cache repeated calculations
• •Use more efficient data structures
• •Remove unnecessary operations

Human Decision Categories

Architecture (PAUSE):

• •Module restructuring
• •Pattern changes
• •New abstractions

Dependencies (PAUSE):

• •Adding libraries
• •Upgrading versions
• •Removing dependencies

Behavior (PAUSE):

• •Changing defaults
• •Modifying error handling strategy
• •Altering API contracts

Execution Flow

1. Analyze changes for improvement opportunities
2. Categorize each suggestion:
   - Safe + Low effort → AUTO-IMPLEMENT
   - Risky or High effort → PRESENT TO USER
3. Implement all auto-implement items
4. Run tests
5. If tests pass:
   - Report what was implemented
   - Present remaining suggestions to user
6. If tests fail:
   - Revert auto-implemented changes
   - Report the issue

Output Format

# Improvement Analysis

## Auto-Implemented
1. **[file:line]** Extracted `calculateTotal()` from duplicated code
   - Before: 15 lines repeated in 3 places
   - After: Single function, 3 call sites

2. **[file:line]** Renamed `x` to `userCount`
   - Improves readability

## Tests: PASS ✓

## Suggestions for Human Decision
1. **[HIGH IMPACT]** Refactor auth module to use middleware pattern
   - Effort: ~2 hours
   - Benefit: Cleaner separation, easier testing
   - Risk: Touches 8 files, could break auth flow
   - Recommendation: Yes, but schedule dedicated time

2. **[MEDIUM IMPACT]** Add Redis caching layer
   - Effort: ~4 hours
   - Benefit: 10x faster repeated queries
   - Risk: New dependency, operational complexity
   - Recommendation: Evaluate if performance is actually a problem

## Summary
- Analyzed: X opportunities
- Auto-implemented: Y
- Needs decision: Z

Integration with Process

After auto-implementing:

1. •Tests are re-run automatically
2. •If pass → continue to next phase
3. •If fail → revert, report, pause for human

The process continues autonomously unless human decision is genuinely needed.

Anti-Patterns

DO NOT auto-implement:

• •"Let's rewrite this in a better way" (subjective)
• •"This could use a different pattern" (architectural)
• •"We should add validation here" (behavior change)
• •"Let's add logging everywhere" (scope creep)

DO auto-implement:

• •"This variable name is unclear" → rename it
• •"This code is duplicated" → extract it
• •"This import is unused" → remove it
• •"This null check is missing" → add it