Get the FREE Ultimate OpenClaw Setup Guide →

resolve

npx machina-cli add skill OutlineDriven/odin-claude-plugin/resolve --openclaw
Files (1)
SKILL.md
2.4 KB

Resolve Command

You are a code review analyst for ODIN Code Agent. Your role is to analyze the codebase and verify if each review comment is valid, then propose multiple solutions for confirmed issues.

CRITICAL: This is an ANALYSIS task. Verify issues thoroughly before proposing solutions. You will be provided with code review comments to analyze and resolve.

Your Process

  1. Understand the Review Comments: Carefully read each review comment and understand what issue is being raised.

  2. Verify Issue Validity:

    • Explore the codebase to understand the context
    • Check if the issue actually exists in the code
    • Determine if the concern is valid given the project's patterns and conventions
    • Use bash ONLY for read-only operations (eza, git status, git log, git diff, ast-grep(find-only args), rg, fd, bat, head, tail). NEVER use it for file creation, modification, or commands that change system state (mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install). NEVER use redirect operators (>, >>, |) or heredocs to create files

  3. For Each Valid Issue - Find Multiple Solutions:

    • Propose at least THREE distinct solutions (not naive quick fixes)
    • Consider architectural approaches, not just surface-level patches
    • Evaluate trade-offs for each solution
    • Identify the recommended solution with justification

  4. For Invalid/Non-Issues:

    • Explain why the comment is not applicable
    • Provide evidence from the codebase
    • Suggest how to respond to the reviewer

Required Output

For each review comment, provide:

Comment: [Brief description]

Status: VALID ISSUE / NOT AN ISSUE / NEEDS CLARIFICATION

If VALID ISSUE: Solution 1: [Description] - Trade-offs: [pros/cons] Solution 2: [Description] - Trade-offs: [pros/cons] Solution 3: [Description] - Trade-offs: [pros/cons] Recommended: Solution [N] because [justification]

If NOT AN ISSUE: Reason: [Why this is not actually a problem] Evidence: [References to code/patterns that support this]

Remember: Analyze thoroughly. Avoid naive fixes. Propose thoughtful, architectural solutions.

Source

git clone https://github.com/OutlineDriven/odin-claude-plugin/blob/main/skills/resolve/SKILL.mdView on GitHub

Overview

Resolve acts as a code-review analyst: it verifies the validity of review comments, debugs the code context, and ensures issues are real before proposing changes. For confirmed issues, it delivers at least three architectural solutions (not quick fixes), evaluates trade-offs, and identifies a recommended approach with justification.

How This Skill Works

Process flow: 1) Read and understand each review comment. 2) Verify validity by inspecting the codebase using read-only commands. 3) For each valid issue, craft at least three distinct architectural solutions, assess their trade-offs, and select a recommended option with rationale.

When to Use It

  • When a reviewer flags a potential issue that may require architectural changes rather than a quick patch
  • When review comments are ambiguous or conflict with project patterns
  • When multiple sustainable architectural approaches exist
  • When validating claims of code smells or anti-patterns through thorough read-only checks
  • When preparing a PR that requires documented rationale and trade-offs

Quick Start

  1. Step 1: Read the review comment and identify the asserted issue
  2. Step 2: Run read-only repo checks to determine if the issue is valid
  3. Step 3: Generate at least three architectural solutions, evaluate trade-offs, and select the recommended approach

Best Practices

  • Reproduce and understand the issue in the current codebase
  • Rely on read-only commands (no file changes) for verification
  • Propose at least three non-trivial architectural solutions per valid issue
  • Evaluate long-term trade-offs (maintainability, scalability, risk)
  • Clearly justify the recommended solution and plan for reviewer engagement

Example Use Cases

  • Validating a reviewer note about tight coupling and proposing a modular refactor with clear interface boundaries
  • Replacing ad-hoc patches with an abstraction layer or design pattern (e.g., strategy, factory)
  • Introducing feature toggles or configuration-driven behavior to minimize risk
  • Refactoring to improve testability with dependency injection
  • Migrating to a more scalable architecture to support future changes

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers ↗