home / skills / duc01226 / easyplatform / fix-hard

fix-hard skill

/.claude/skills/fix-hard

This skill helps diagnose and fix hard issues in C# projects by coordinating subagents and evidence-based debugging.

npx playbooks add skill duc01226/easyplatform --skill fix-hard

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.2 KB
---
name: fix-hard
description: "[Fix & Debug] ⚡⚡⚡ Use subagents to plan and fix hard issues"
argument-hint: [issues]
infer: true
---

**Ultrathink** to plan & start fixing these issues follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules:
<issues>$ARGUMENTS</issues>

## ⚠️ MUST READ Before Starting

**IMPORTANT: You MUST read these shared protocols before any code changes. Do NOT skip.**

- **⚠️ MUST READ** `.claude/skills/shared/anti-hallucination-protocol.md` — Assumption validation, evidence chains, context anchoring
- **⚠️ MUST READ** `.claude/skills/shared/knowledge-graph-template.md` — Per-file analysis structure (for investigation phases)

**Core Rule:** Verify every assumption with actual code evidence before making changes. Search for all usages, read implementations, trace dependencies. If confidence < 90%, investigate further or ask user.

## Workflow:

If the user provides a screenshots or videos, use `ai-multimodal` skill to describe as detailed as possible the issue, make sure developers can predict the root causes easily based on the description.

### Fulfill the request
**Question Everything**: Use `AskUserQuestion` tool to ask probing questions to fully understand the user's request, constraints, and true objectives. Don't assume - clarify until you're 100% certain.

* If you have any questions, use `AskUserQuestion` tool to ask the user to clarify them.
* Ask 1 question at a time, wait for the user to answer before moving to the next question.
* If you don't have any questions, start the next step.

### Fix the issue

Use `sequential-thinking` skill to break complex problems into sequential thought steps.
Use `problem-solving` skills to tackle the issues.
Analyze the skills catalog and activate other skills that are needed for the task during the process.

1. Use `debugger` subagent to find the root cause of the issues and report back to main agent.
2. Use `researcher` subagent to research quickly about the root causes on the internet (if needed) and report back to main agent.
3. Use `planner` subagent to create an implementation plan based on the reports, then report back to main agent.
4. Then use `/code` SlashCommand to implement the plan step by step.
5. Final Report:
  * Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
  * Ask the user if they want to commit and push to git repository, if yes, use `git-manager` subagent to commit and push to git repository.
  - **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
  - **IMPORTANT:** In reports, list any unresolved questions at the end, if any.

**REMEMBER**:
- You can always generate images with `ai-multimodal` skills on the fly for visual assets.
- You always read and analyze the generated assets with `ai-multimodal` skills to verify they meet requirements.
- For image editing (removing background, adjusting, cropping), use `ImageMagick` skill or similar tools as needed.

## IMPORTANT Task Planning Notes

- Always plan and break many small todo tasks
- Always add a final review todo task to review the works done at the end to find any fix or enhancement needed

Overview

This skill orchestrates subagents to plan, diagnose, and fix hard software issues with a structured, evidence-first approach. It emphasizes verification of assumptions, incremental implementation, and a clear final report so developers can understand what changed and why. The flow supports multimodal inputs (screenshots/video) and can commit changes when approved.

How this skill works

The skill inspects provided issue details and any attached screenshots or videos, then runs a staged investigation using dedicated subagents: a debugger to locate root causes, a researcher to collect external context if needed, and a planner to craft a step-by-step implementation plan. Implementation is done via iterative code changes using the /code command and reviewed with a final report. It validates every assumption against actual code evidence and logs unresolved questions at the end.

When to use it

  • When an issue is complex, unclear, or spans multiple components and needs coordinated investigation.
  • When you have screenshots, videos, or logs and want a systematic diagnosis plus a reproducible fix plan.
  • When fixes require research, multi-step implementation, and an explicit verification plan.
  • When you need granular task breakdowns and a final concise report to hand off to engineers.

Best practices

  • Start by feeding complete context: reproduction steps, logs, and any media; the more detail, the faster root-cause discovery.
  • Answer the agent's clarifying questions one at a time; the workflow relies on sequential Q&A for accuracy.
  • Require evidence for every assumption—search usages, read implementations, and trace dependencies before edits.
  • Break implementation into small commits and include a final review task to catch regressions.
  • Approve commits before pushing; the skill will ask before using git-manager to commit and push.

Example use cases

  • A multi-module C# bug that only reproduces under certain inputs and needs stepwise debugging and fixes.
  • A UI rendering issue shown in screenshots where root cause may be styling, layout, or data binding.
  • Performance regression that requires profiler evidence, targeted code changes, and verification.
  • A security or concurrency bug that needs careful hypothesis validation and staged remediation.

FAQ

Can the skill change code automatically?

Yes—after planning, it can implement changes stepwise via /code, but it will ask for approval before committing or pushing.

What if the agent's confidence is low?

It will pause investigation, ask clarifying questions, or add deeper analysis tasks until confidence is ≥90% before making changes.