reviews
npx machina-cli add skill OutlineDriven/odin-claude-plugin/review --openclawCode Review
You are an expert code reviewer. Review the current state of the codebase on the active branch, focusing on recent changes and overall quality.
Follow these steps:
- Use appropriate tools to inspect the current branch status and recent commits (e.g., git log --oneline -10, git diff origin/main).
- Examine key files and directories for modifications, paying attention to source code, tests, and configuration files.
- Analyze the codebase structure, implementation details, and adherence to best practices.
Provide a thorough code review that includes:
- Overview of recent changes and their purpose
- Analysis of code quality, style, and maintainability
- Specific suggestions for improvements in structure, logic, and implementation
- Identification of potential issues, bugs, or risks
- Assessment of test coverage and validation strategies
- Performance considerations and optimization opportunities
- Security review and vulnerability assessment
Focus on:
- Code correctness and logical soundness
- Adherence to project conventions, coding standards, and architecture patterns
- Performance implications and efficiency
- Comprehensive test coverage and edge case handling
- Security best practices and potential vulnerabilities
- Documentation quality and developer experience
- Scalability and maintainability concerns
Format your review with clear sections:
Overview
- Summary of recent changes and their intended impact
Code Quality Analysis
- Strengths in implementation approach
- Areas needing improvement
- Style and consistency observations
Specific Recommendations
- [Concrete suggestion 1 with file/line references]
- [Concrete suggestion 2 with rationale]
- [Priority-ranked improvement opportunities]
Potential Issues and Risks
- Critical bugs or logical errors
- Performance bottlenecks
- Security concerns
- Maintainability challenges
Testing and Validation
- Current test coverage assessment
- Missing test scenarios
- Integration and end-to-end testing recommendations
Security Review
- Authentication/authorization gaps
- Input validation and sanitization
- Data exposure risks
- Dependency vulnerabilities
Performance Considerations
- Algorithmic complexity analysis
- Resource utilization patterns
- Scalability limitations
Conclusion and Next Steps
- Overall assessment
- Priority action items
- Estimated effort for improvements
Be specific about file locations, line numbers, and provide concrete examples. Reference actual code patterns and suggest precise improvements. Maintain professional tone while being direct about issues found.
Source
git clone https://github.com/OutlineDriven/odin-claude-plugin/blob/main/skills/review/SKILL.mdView on GitHub Overview
Reviews the active branch to surface recent changes, assess code quality, and compare against the main branch. It emphasizes correctness, style, tests, security, and maintainability to improve overall code health.
How This Skill Works
It uses Git-based inspections (e.g., git log --oneline -10 and git diff origin/main) to surface recent commits and changes. It then scans key directories like src/, tests/, and config/ to evaluate structure, adherence to standards, and implementation quality, producing a structured review with actionable feedback.
When to Use It
- Before merging a feature branch, to assess changes against main
- When you want a quick, data-backed quality assessment of recent commits
- During a refactor to catch regressions and architectural drift
- When validating test coverage and validation strategies
- For security- or config-related changes that could introduce vulnerabilities
Quick Start
- Step 1: Run git log --oneline -10 and git diff origin/main to gather recent changes
- Step 2: Inspect key directories (src/, tests/, config/) for modifications and test coverage gaps
- Step 3: Generate a structured review with sections: Overview, Code Quality Analysis, Recommendations, and Next Steps
Best Practices
- Anchor feedback with concrete file/line references (e.g., src/lib/api.ts:210).
- Check the most critical files first (src/, tests/, config/) for changes and risks.
- Review in the context of main to spot regressions and compatibility issues.
- Prioritize issues by severity and impact on correctness, security, and performance.
- Document recommended fixes and rationale to ease triage and handoff.
Example Use Cases
- Feature branch review before opening a PR against main
- Refactor audit to ensure modules still comply with API contracts
- Hotfix assessment comparing the branch to main to confirm minimal surface area
- Security-sensitive config changes reviewed for exposure or weak defaults
- Post-commit evaluation to verify tests pass and edge cases are covered
