Systematic Problem Solving

A disciplined approach to software development that emphasizes complete code solutions, evidence-based planning, and systematic debugging.

What This Skill Does

This skill guides you through a methodical problem-solving process that prioritizes understanding before implementation, ensures complete code without shortcuts, and applies programming best practices consistently.

Instructions

When working on any coding task, follow this systematic approach:

1. Problem Understanding Phase

**Before making any changes:**

Read the request carefully and identify the specific scope

Note what should NOT be changed (unrelated functionality)

Break complex problems into smaller, manageable steps

Think through each step separately before coding

2. Planning Phase

**Create a complete PLAN that includes:**

Clear OBSERVATIONS from examining the codebase

Evidence gathered from code, logs, and documentation

REASONING that connects observations to the solution

Step-by-step approach with justification for each step

**Example format:**

```

OBSERVATIONS:

[List specific facts from code/logs]

REASONING:

[Explain how observations lead to solution]

PLAN:

1. [Step with explanation]

2. [Step with explanation]

...

```

3. Implementation Phase

**Code Quality Standards:**

Write complete code - never use placeholders like `// ... rest of the code ...`

Modify only code directly relevant to the request

Apply programming best practices (DRY, SOLID, appropriate patterns)

Include proper error handling and edge cases

Add meaningful comments for complex logic

**When Debugging:**

Add console logs strategically to gather information

Test assumptions before implementing fixes

Verify changes don't break unrelated functionality

4. Verification Phase

**Before submitting:**

Ensure all code is complete and functional

Verify no placeholders or shortcuts remain

Check that unrelated code remains unchanged

Confirm solution follows best practices

Key Principles

1. **Completeness**: Every code block must be fully implemented

2. **Evidence-Based**: Decisions must be backed by observations

3. **Minimal Scope**: Change only what's necessary

4. **Best Practices**: Always strive for quality, not just working code

5. **Systematic Thinking**: Break down problems, reason through solutions

Usage Examples

**Example 1: Bug Fix Request**

```

User: "Fix the login error on submit"

Assistant approach:

1. OBSERVATIONS: Examine login component, check console logs, review network requests

2. REASONING: Error occurs because validation runs before state updates

3. PLAN: Move validation to useEffect, add loading state, handle edge cases

4. IMPLEMENTATION: Complete code with proper error handling

```

**Example 2: Feature Addition**

```

User: "Add sorting to the user table"

Assistant approach:

1. Break down: Identify table component, data structure, UI requirements

2. OBSERVATIONS: Current implementation uses static rendering, no state for sort

3. REASONING: Need state management + sort function + UI controls

4. PLAN: Add sort state, implement sort logic, create UI controls, preserve other features

5. IMPLEMENTATION: Complete solution without modifying unrelated table features

```

Important Constraints

**Never** use code placeholders or comments like "rest of the code here"

**Never** modify code unrelated to the specific request

**Always** show your reasoning before implementing

**Always** apply best practices, even for quick fixes

**Always** think in steps before coding

Systematic Problem Solving

Systematic Problem Solving

What This Skill Does

Instructions

1. Problem Understanding Phase

2. Planning Phase

3. Implementation Phase

4. Verification Phase

Key Principles

Usage Examples

Important Constraints

Reviews (0)