wrong
npx machina-cli add skill umputun/cc-thingz/wrong --openclawWrong — Reset and Re-evaluate
The current approach isn't working as expected. Step back and re-examine the problem from the beginning.
Workflow
Step 1: Re-analyze the Core Problem
State the problem in clear, simple terms. What exactly are we trying to solve?
Step 2: Identify Missing Context
Determine what additional information is needed about:
- The existing codebase and its patterns
- Performance requirements or constraints
- Integration points with other systems
- Expected usage patterns or scale
- Any domain-specific requirements not yet mentioned
Step 3: Propose Fresh Approaches
Suggest 2-3 alternative solutions that:
- Follow project best practices and idioms
- Match the existing code's style and architecture patterns
- Are maintainable and testable
- Solve the exact problem without over-engineering
- Don't use shortcuts or hacks
Step 4: Explain Trade-offs
For each proposed approach, briefly explain:
- Why this approach fits the problem
- What the main benefits and drawbacks are
- How it integrates with the existing codebase
Step 5: Recommend the Best Path Forward
Which approach is most appropriate and why?
Requirements
- Solution must be production-ready, not a proof of concept
- Code should be idiomatic and follow established patterns
- Include comprehensive tests with edge cases
- Provide complete, runnable code with no placeholders
- Ensure the solution is maintainable
Ask clarifying questions before proceeding.
Source
git clone https://github.com/umputun/cc-thingz/blob/master/plugins/workflow/skills/wrong/SKILL.mdView on GitHub Overview
Wrong is a reset-first skill that helps you pause, re-state the problem, and gather missing context when the current path isn’t delivering. It guides you through new approaches, trade-offs, and a recommended path forward to regain footing.
How This Skill Works
Conceptually, you execute five steps: 1) re-analyze the core problem; 2) identify missing context about the codebase, performance constraints, and integrations; 3) propose 2-3 fresh approaches that fit the project’s style; 4) explain trade-offs for each approach; 5) recommend the best path forward. The process may prompt clarifying questions before proceeding to ensure alignment with requirements.
When to Use It
- Current solution path isn’t delivering the expected results or constraints.
- User signals the need to start over, try again, or indicates a wrong approach.
- Missing critical context about the codebase, performance, integration points, or scale is suspected.
- Two to three fresh approaches are needed to compare options and avoid hacks.
- You require a concrete, production-ready plan with tests and runnable code.
Quick Start
- Step 1: Acknowledge the wrong signal and pause the current path.
- Step 2: Re-state the problem and list missing context (codebase, performance, integrations).
- Step 3: Propose 2-3 fresh approaches, compare trade-offs, and select the best path to implement with tests.
Best Practices
- Pause and explicitly state the failure signal before changing direction.
- Gather missing context (codebase patterns, performance limits, integrations) before proposing solutions.
- Brainstorm 2-3 viable approaches that fit existing patterns and are maintainable.
- Explain trade-offs for each approach and justify the recommended path.
- Deliver a complete plan with tests, runnable code, and no placeholders.
Example Use Cases
- User reports incorrect results; trigger Step 1 to re-analyze the problem.
- Current path hits a dead end; propose alternative implementations that align with architecture.
- Performance constraints prompt rethinking the chosen direction.
- New domain or feature requirements render the current approach unsuitable.
- External service changes force a reset and re-plan with fresh approaches.
