691 lines
19 KiB
Markdown
691 lines
19 KiB
Markdown
---
|
|
name: automation-quick-fix
|
|
description: Fast automation platform error resolver for Power Automate, n8n, Make, Zapier and other platforms. Handles common patterns like 401/403 auth errors, 429 throttling, and data format issues. Provides immediate fixes without deep research for well-known error patterns. Use when error matches common scenarios (status codes 401, 403, 404, 429, timeout, parse JSON failures). For complex or unknown errors, defer to automation-debugger skill. When the user outputs some code/json snippets and ask for a quick fix, this skill will provide immediate solutions.
|
|
---
|
|
|
|
# Automation Quick Fix
|
|
|
|
Fast-track resolver for common automation workflow error patterns across multiple platforms with immediate, proven solutions.
|
|
|
|
## Supported Platforms
|
|
|
|
- **Power Automate** (Microsoft)
|
|
- **n8n** (Open-source)
|
|
- **Make** (formerly Integromat)
|
|
- **Zapier**
|
|
- **Other JSON-based workflow platforms**
|
|
|
|
## Purpose
|
|
|
|
Provides rapid fixes for frequently encountered automation workflow errors across all platforms:
|
|
- Authentication errors (401/403)
|
|
- Throttling errors (429)
|
|
- Data format issues (JSON parsing, data transformation)
|
|
- Timeout errors
|
|
- Not found errors (404)
|
|
- Basic expression/formula errors
|
|
|
|
**When to use this skill**: Error matches a well-known pattern
|
|
**When to use automation-debugger instead**: Unknown error, complex scenario, or quick fix doesn't resolve
|
|
|
|
## Activation Triggers
|
|
|
|
Activates for messages like:
|
|
- "Quick fix for 429 error in SharePoint/API/webhook"
|
|
- "Fast solution for authentication error in n8n"
|
|
- "I'm getting throttled in Make, need immediate fix"
|
|
- "Parse JSON is failing in Zapier, quick help"
|
|
- "Function expects one parameter but was invoked with 2"
|
|
- "Unable to process template language expressions"
|
|
- "Fix this expression/filter/query/condition"
|
|
- User provides code snippet and asks for "quick fix" or "fix this"
|
|
- Status codes: 401, 403, 404, 429 with platform/connector context
|
|
- Platform-specific: "n8n node error", "Make scenario failing", "Power Automate action issue"
|
|
|
|
## ⚠️ IMPORTANT: Data Structure Check (NEW!)
|
|
|
|
**Before applying any quick fix**, quickly verify data structures in your flow:
|
|
|
|
### Quick Data Type Check
|
|
```javascript
|
|
// In filters/queries, check the where clause:
|
|
|
|
// Array of STRINGS (primitives):
|
|
"where": "@contains(item(), 'text')" // ← item() without property
|
|
|
|
// Array of OBJECTS:
|
|
"where": "@contains(item()?['Name'], 'text')" // ← item()?['Property']
|
|
```
|
|
|
|
**If your flow has data structure mismatches** (filter uses `item()` but loop uses `items('Loop')?['Property']`), this is NOT a quick fix scenario → use **automation-debugger** instead.
|
|
|
|
**Quick Fix applies to**: Authentication, throttling, timeouts, parse JSON, NOT structural bugs.
|
|
|
|
---
|
|
|
|
## Quick Fix Patterns
|
|
|
|
### Data Structure Mismatch (Quick Check - NEW!)
|
|
|
|
**Pattern Recognition**:
|
|
- Error: "Cannot evaluate property on undefined/null"
|
|
- Loop accessing `items('Loop')?['Property']` but source is array of strings
|
|
|
|
**Quick Diagnosis**:
|
|
```javascript
|
|
// Check your filter:
|
|
"where": "@contains(item(), 'value')" // ← This means array of STRINGS!
|
|
|
|
// But loop tries:
|
|
"value": "@items('Loop')?['PropertyName']" // ← ERROR: Can't access property on string!
|
|
```
|
|
|
|
**Quick Decision**:
|
|
- ❌ **NOT a quick fix** → Use **automation-debugger skill**
|
|
- This requires analyzing full data flow and structure
|
|
- Quick fix = known patterns; structural bugs = deep debugging
|
|
|
|
---
|
|
|
|
### Authentication Errors (401/403)
|
|
|
|
**Pattern Recognition**:
|
|
- Status: 401 or 403
|
|
- Keywords: "unauthorized", "forbidden", "access denied"
|
|
|
|
**Immediate Fix**:
|
|
|
|
```json
|
|
{
|
|
"actions": {
|
|
"Scope_With_Auth_Handling": {
|
|
"type": "Scope",
|
|
"actions": {
|
|
"Your_Action": {
|
|
"type": "ApiConnection",
|
|
"inputs": { /* your config */ },
|
|
"authentication": {
|
|
"type": "Raw",
|
|
"value": "@parameters('$connections')['shared_sharepointonline']['connectionId']"
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"Catch_Auth_Error": {
|
|
"type": "Terminate",
|
|
"inputs": {
|
|
"runStatus": "Failed",
|
|
"runError": {
|
|
"code": "AuthenticationFailed",
|
|
"message": "Please re-authenticate the connection in Power Automate"
|
|
}
|
|
},
|
|
"runAfter": {
|
|
"Scope_With_Auth_Handling": ["Failed"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Instructions**:
|
|
1. Copy the Scope structure above
|
|
2. Replace "Your_Action" with your failing action
|
|
3. Update connection name if not SharePoint
|
|
4. Save and re-authenticate connection in Power Automate UI
|
|
|
|
---
|
|
|
|
### Throttling Errors (429)
|
|
|
|
**Pattern Recognition**:
|
|
- Status: 429
|
|
- Keywords: "TooManyRequests", "throttled", "rate limit"
|
|
|
|
**Immediate Fix - SharePoint/OneDrive**:
|
|
|
|
```json
|
|
{
|
|
"actions": {
|
|
"Apply_to_each_FIXED": {
|
|
"type": "Foreach",
|
|
"foreach": "@body('Get_items')?['value']",
|
|
"runtimeConfiguration": {
|
|
"concurrency": {
|
|
"repetitions": 1
|
|
}
|
|
},
|
|
"actions": {
|
|
"Your_API_Action": {
|
|
"type": "ApiConnection",
|
|
"inputs": { /* your config */ },
|
|
"runAfter": {}
|
|
},
|
|
"Delay_1_Second": {
|
|
"type": "Wait",
|
|
"inputs": {
|
|
"interval": {
|
|
"count": 1,
|
|
"unit": "Second"
|
|
}
|
|
},
|
|
"runAfter": {
|
|
"Your_API_Action": ["Succeeded"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Instructions**:
|
|
1. Find your Apply to each loop
|
|
2. Add `runtimeConfiguration.concurrency.repetitions: 1`
|
|
3. Add Delay action after API calls (1 second for SharePoint, 3 seconds for OneDrive)
|
|
4. Save and test
|
|
|
|
**Quick calculation**:
|
|
- SharePoint limit: 600/minute → 1-second delay = 60/minute (safe)
|
|
- OneDrive limit: 100/minute → 3-second delay = 20/minute (safe)
|
|
|
|
---
|
|
|
|
### Parse JSON Failures
|
|
|
|
**Pattern Recognition**:
|
|
- Error: "InvalidTemplate", "cannot be evaluated"
|
|
- Keywords: "Parse JSON", "dynamic content", "schema"
|
|
|
|
**Immediate Fix**:
|
|
|
|
```json
|
|
{
|
|
"actions": {
|
|
"Parse_JSON_FIXED": {
|
|
"type": "ParseJson",
|
|
"inputs": {
|
|
"content": "@body('HTTP')",
|
|
"schema": {
|
|
"type": "object",
|
|
"properties": {
|
|
"id": {"type": "string"},
|
|
"name": {"type": "string"},
|
|
"value": {"type": ["string", "null"]}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
"Safe_Access_Property": {
|
|
"type": "Compose",
|
|
"inputs": "@coalesce(body('Parse_JSON_FIXED')?['value'], 'default')",
|
|
"runAfter": {
|
|
"Parse_JSON_FIXED": ["Succeeded"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Instructions**:
|
|
1. Add Parse JSON action with proper schema
|
|
2. Use `?['property']` for safe navigation (optional chaining)
|
|
3. Use `coalesce()` for default values with null properties
|
|
4. Test with sample payload first
|
|
|
|
**Schema generation tip**:
|
|
- Copy sample JSON response
|
|
- Use "Generate from sample" in Parse JSON action
|
|
- Add `"null"` to type array for optional fields: `{"type": ["string", "null"]}`
|
|
|
|
---
|
|
|
|
### Timeout Errors
|
|
|
|
**Pattern Recognition**:
|
|
- Error: "timeout", "timed out"
|
|
- Context: Large files, long operations, Do until loops
|
|
|
|
**Immediate Fix - Do Until**:
|
|
|
|
```json
|
|
{
|
|
"actions": {
|
|
"Do_until_FIXED": {
|
|
"type": "Until",
|
|
"expression": "@equals(variables('Complete'), true)",
|
|
"limit": {
|
|
"count": 60,
|
|
"timeout": "PT1H"
|
|
},
|
|
"actions": {
|
|
"Your_Action": {
|
|
"type": "Compose",
|
|
"inputs": "@variables('Data')"
|
|
},
|
|
"Check_Complete": {
|
|
"type": "SetVariable",
|
|
"inputs": {
|
|
"name": "Complete",
|
|
"value": "@greater(length(variables('Data')), 0)"
|
|
},
|
|
"runAfter": {
|
|
"Your_Action": ["Succeeded"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Instructions**:
|
|
1. Always set `limit.count` and `limit.timeout` in Do until
|
|
2. Recommended: count=60, timeout="PT1H" (1 hour)
|
|
3. Add exit condition that WILL eventually be true
|
|
4. Test with smaller iterations first
|
|
|
|
**Immediate Fix - Large Files**:
|
|
|
|
```json
|
|
{
|
|
"actions": {
|
|
"Check_File_Size_FIXED": {
|
|
"type": "If",
|
|
"expression": {
|
|
"and": [{
|
|
"lessOrEquals": [
|
|
"@triggerBody()?['Size']",
|
|
50000000
|
|
]
|
|
}]
|
|
},
|
|
"actions": {
|
|
"Process_Normal_File": {
|
|
"type": "ApiConnection",
|
|
"inputs": { /* your file action */ }
|
|
}
|
|
},
|
|
"else": {
|
|
"actions": {
|
|
"Log_Large_File": {
|
|
"type": "Compose",
|
|
"inputs": "File over 50MB - skipping"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Instructions**:
|
|
1. Add file size check before processing
|
|
2. OneDrive: 50MB limit (50000000 bytes)
|
|
3. SharePoint attachments: 90MB limit (94371840 bytes)
|
|
4. Alternative: Use different API for large files
|
|
|
|
---
|
|
|
|
### Not Found Errors (404)
|
|
|
|
**Pattern Recognition**:
|
|
- Status: 404
|
|
- Keywords: "not found", "does not exist"
|
|
|
|
**Immediate Fix**:
|
|
|
|
```json
|
|
{
|
|
"actions": {
|
|
"Try_Get_Item": {
|
|
"type": "Scope",
|
|
"actions": {
|
|
"Get_Item": {
|
|
"type": "ApiConnection",
|
|
"inputs": { /* your get action */ }
|
|
}
|
|
}
|
|
},
|
|
"Handle_Not_Found": {
|
|
"type": "If",
|
|
"expression": {
|
|
"and": [{
|
|
"equals": [
|
|
"@result('Try_Get_Item')[0]['status']",
|
|
"Failed"
|
|
]
|
|
}]
|
|
},
|
|
"runAfter": {
|
|
"Try_Get_Item": ["Failed", "Succeeded"]
|
|
},
|
|
"actions": {
|
|
"Create_If_Missing": {
|
|
"type": "ApiConnection",
|
|
"inputs": { /* your create action */ }
|
|
}
|
|
},
|
|
"else": {
|
|
"actions": {
|
|
"Use_Existing": {
|
|
"type": "Compose",
|
|
"inputs": "@body('Get_Item')"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Instructions**:
|
|
1. Wrap Get action in Scope
|
|
2. Check result status with `result()` function
|
|
3. Create item if not found (or handle alternative)
|
|
4. Use dynamic IDs from previous actions (don't hardcode)
|
|
|
|
---
|
|
|
|
### Expression Errors
|
|
|
|
**Pattern Recognition**:
|
|
- Error: "Unable to process template language expressions"
|
|
- Keywords: "property doesn't exist", "invalid expression"
|
|
|
|
**Common Quick Fixes**:
|
|
|
|
**Missing Property**:
|
|
```javascript
|
|
// BAD
|
|
@body('Get_Item')['MissingProperty']
|
|
|
|
// GOOD
|
|
@body('Get_Item')?['MissingProperty']
|
|
|
|
// BETTER (with default)
|
|
@coalesce(body('Get_Item')?['MissingProperty'], 'default_value')
|
|
```
|
|
|
|
**Type Mismatch**:
|
|
```javascript
|
|
// BAD - concatenating string and number
|
|
@concat('Value: ', variables('NumberVariable'))
|
|
|
|
// GOOD
|
|
@concat('Value: ', string(variables('NumberVariable')))
|
|
```
|
|
|
|
**Array Access**:
|
|
```javascript
|
|
// BAD - array might be empty
|
|
@first(body('Get_Items')?['value'])
|
|
|
|
// GOOD
|
|
@if(greater(length(body('Get_Items')?['value']), 0), first(body('Get_Items')?['value']), null)
|
|
```
|
|
|
|
**Null Checks**:
|
|
```javascript
|
|
// BAD
|
|
@variables('NullableVar')
|
|
|
|
// GOOD
|
|
@if(empty(variables('NullableVar')), 'default', variables('NullableVar'))
|
|
```
|
|
|
|
**Function Parenthesis Placement** (NEW!):
|
|
```javascript
|
|
// BAD - format parameter outside formatDateTime()
|
|
toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
|
|
// ↑
|
|
// This closes formatDateTime BEFORE format string!
|
|
|
|
// ERROR MESSAGE:
|
|
// "The template language function 'toLower' expects one parameter:
|
|
// the string to convert to lower casing. The function was invoked with '2' parameters."
|
|
|
|
// GOOD - format parameter INSIDE formatDateTime()
|
|
toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))
|
|
// ↑
|
|
// Format string is now INSIDE formatDateTime()
|
|
```
|
|
|
|
**Copy-Paste Fix for Filter Query**:
|
|
```javascript
|
|
// Original (broken):
|
|
@and(
|
|
contains(toLower(item()), 'cnesst'),
|
|
contains(
|
|
toLower(item()),
|
|
toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
|
|
)
|
|
|
|
// Fixed expression (ready to copy-paste into Filter Query action):
|
|
@and(
|
|
contains(toLower(item()), 'cnesst'),
|
|
contains(
|
|
toLower(item()),
|
|
toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
|
|
)
|
|
)
|
|
```
|
|
|
|
---
|
|
|
|
## Quick Fix Decision Tree
|
|
|
|
```
|
|
Error Code/Type
|
|
│
|
|
├── Data Structure Mismatch (item() vs item()?['Prop']) → ❌ Use automation-debugger (NOT quick fix)
|
|
│
|
|
├── 401/403 → Re-authenticate connection + Add error handling
|
|
│
|
|
├── 429 → Set concurrency=1 + Add delays
|
|
│
|
|
├── 404 → Add existence check + Handle not found case
|
|
│
|
|
├── Timeout → Add limits to Do until OR check file sizes
|
|
│
|
|
├── Parse JSON → Add schema + Use safe navigation (?[])
|
|
│
|
|
└── Expression Errors
|
|
├── "Function expects N parameters but was invoked with M" → Check parenthesis placement
|
|
├── Missing/null properties → Add ?[] + coalesce()
|
|
├── Type mismatch → Add string(), int() conversions
|
|
└── Array access → Add length checks + first()/last()
|
|
```
|
|
|
|
## When Quick Fix Isn't Enough
|
|
|
|
Escalate to automation-debugger skill if:
|
|
- Quick fix doesn't resolve the error
|
|
- Error doesn't match common patterns
|
|
- Multiple interrelated errors
|
|
- Complex flow logic involved
|
|
- Need deep documentation research
|
|
- Unclear root cause
|
|
|
|
## Output Format
|
|
|
|
Quick fixes provide:
|
|
1. **Pattern identification** (which common error)
|
|
2. **Immediate fix** (JSON snippet for actions/nodes)
|
|
3. **Copy-paste ready expressions** (for Filter Query, Condition, Variable, etc.) - ALWAYS include the complete @{...} expression ready to copy directly into Power Automate
|
|
4. **Instructions** (how to apply)
|
|
5. **Validation** (how to test)
|
|
|
|
**IMPORTANT**: For expression errors (Filter Query, Condition, Variable, Compose, etc.), ALWAYS provide:
|
|
- ❌ **Original (broken)**: The full broken expression
|
|
- ✅ **Fixed expression**: The complete corrected expression ready to copy-paste
|
|
|
|
**Example output format**:
|
|
```
|
|
Quick Fix: Function Parenthesis Placement Error
|
|
|
|
Pattern: formatDateTime() format parameter placed outside function call
|
|
|
|
Original (broken):
|
|
@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date']),'yyyy-MM')))
|
|
|
|
Fixed expression (copy-paste ready):
|
|
@and(contains(toLower(item()), 'text'), contains(toLower(item()), toLower(formatDateTime(outputs('Action')?['body/Date'], 'yyyy-MM'))))
|
|
|
|
What changed: Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses
|
|
```
|
|
|
|
No need for full debug report structure - focus on speed and copy-paste ready fixes.
|
|
|
|
## Best Practices
|
|
|
|
1. **Test first**: Apply quick fix to copy of flow
|
|
2. **Verify limits**: Confirm connector-specific constraints
|
|
3. **Monitor**: Check flow run history after fix
|
|
4. **Escalate if needed**: Use automation-debugger for persistent issues
|
|
|
|
## Common Connector Limits (Quick Reference)
|
|
|
|
| Connector | API Limit | Recommended Delay |
|
|
|-----------|-----------|-------------------|
|
|
| SharePoint | 600/60s | 1 second |
|
|
| OneDrive | 100/60s | 3 seconds |
|
|
| HTTP | 600/60s | 1 second |
|
|
| Apply to each | 50 concurrent | Set to 1 for APIs |
|
|
|
|
## Examples
|
|
|
|
**User**: "I'm getting throttled in SharePoint, need quick fix"
|
|
|
|
**Output**:
|
|
```
|
|
Quick Fix: SharePoint Throttling (429)
|
|
|
|
Reduce concurrency and add delays:
|
|
|
|
[JSON snippet with concurrency + delay]
|
|
|
|
Apply these changes:
|
|
1. Set concurrency to 1
|
|
2. Add 1-second delay
|
|
3. Save and test
|
|
|
|
This limits you to 60 API calls/minute (well under 600/minute limit).
|
|
```
|
|
|
|
**User**: "Parse JSON failing with 'property doesn't exist'"
|
|
|
|
**Output**:
|
|
```
|
|
Quick Fix: Parse JSON Property Access
|
|
|
|
Use safe navigation (?[]) and defaults:
|
|
|
|
[JSON snippet with coalesce()]
|
|
|
|
Changes needed:
|
|
1. Replace ['property'] with ?['property']
|
|
2. Add coalesce() for defaults
|
|
3. Test with sample data
|
|
|
|
This handles null/missing properties gracefully.
|
|
```
|
|
|
|
**User**: "Getting error 'toLower expects one parameter but was invoked with 2 parameters' in my Filter Query"
|
|
|
|
**Output**:
|
|
```
|
|
Quick Fix: Function Parenthesis Placement Error
|
|
|
|
Pattern: formatDateTime() format parameter placed outside function call
|
|
|
|
Original (broken):
|
|
@and(
|
|
contains(toLower(item()), 'cnesst'),
|
|
contains(
|
|
toLower(item()),
|
|
toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST']),'yyyy-MM'))
|
|
)
|
|
|
|
Fixed expression (copy-paste ready):
|
|
@and(
|
|
contains(toLower(item()), 'cnesst'),
|
|
contains(
|
|
toLower(item()),
|
|
toLower(formatDateTime(outputs('Ajouter_une_ligne_à_un_tableau')?['body/Date d''événement CNESST'], 'yyyy-MM'))
|
|
)
|
|
)
|
|
|
|
What changed:
|
|
1. Moved 'yyyy-MM' format string INSIDE formatDateTime() parentheses (before the closing parenthesis)
|
|
2. The format parameter is now the second parameter of formatDateTime(), not a second parameter to toLower()
|
|
|
|
How to apply:
|
|
1. Open your Filter Query action in Power Automate
|
|
2. Delete the current expression
|
|
3. Paste the fixed expression above
|
|
4. Save and test with your data
|
|
```
|
|
|
|
---
|
|
|
|
## Integration with Other Skills
|
|
|
|
- **Quick fix succeeds** → Done!
|
|
- **Quick fix fails** → Automatically suggest automation-debugger
|
|
- **Unknown error** → Immediately defer to automation-debugger
|
|
|
|
This skill optimizes for speed on common patterns while maintaining quality through specialized skill delegation when needed.
|
|
|
|
---
|
|
|
|
**Version**: 1.2
|
|
**Last Updated**: 2025-10-31
|
|
|
|
## Changelog
|
|
|
|
### Version 1.2 (2025-10-31)
|
|
|
|
**Major Enhancements**:
|
|
- ✅ Added **Function Parenthesis Placement Error** pattern to Expression Errors
|
|
- ✅ Enhanced **Output Format** to emphasize copy-paste ready expressions for all expression types
|
|
- ✅ Updated **Activation Triggers** to include expression error patterns
|
|
- ✅ Expanded **Decision Tree** with detailed expression error breakdown
|
|
- ✅ Added **complete example** showing function parenthesis error fix
|
|
|
|
**Key Additions**:
|
|
- Function parameter placement detection (e.g., `toLower(formatDateTime(...), 'format')` → error)
|
|
- Copy-paste ready expression format with ❌ broken / ✅ fixed sections
|
|
- Direct support for Filter Query, Condition, Variable, Compose expression fixes
|
|
- Clear before/after comparison showing exactly what changed
|
|
|
|
**New Triggers**:
|
|
- "Function expects one parameter but was invoked with 2"
|
|
- "Unable to process template language expressions"
|
|
- "Fix this expression/filter/query/condition"
|
|
- User provides code snippet and asks for "quick fix"
|
|
|
|
**Output Philosophy**:
|
|
- Always provide complete, ready-to-paste expressions
|
|
- Show original (broken) and fixed versions side-by-side
|
|
- Explain exactly what changed and why
|
|
- Include step-by-step application instructions
|
|
|
|
### Version 1.1 (2025-10-31)
|
|
|
|
**Minor Improvements**:
|
|
- ✅ Added **Data Structure Check section** - Quick validation before applying fixes
|
|
- ✅ Added **Data Structure Mismatch pattern** - Recognizes when NOT to quick fix
|
|
- ✅ Updated **Decision Tree** - Now includes structural bug detection
|
|
- ✅ Clarified escalation to **automation-debugger** for structural issues
|
|
|
|
**Key Additions**:
|
|
- Quick data type check: `item()` vs `item()?['Property']` indicator
|
|
- Clear guidance on when quick fix is inappropriate
|
|
- Structural bugs (string vs object mismatch) → Use automation-debugger
|
|
|
|
**Philosophy**:
|
|
- Quick fixes are for **known, simple patterns**
|
|
- Data structure bugs require **deep analysis** → Not quick fix territory
|
|
- Fast triage: Recognize when to escalate immediately
|