name: code-review description: Performs a structured engineering code review focusing on design quality, coupling, performance (especially mobile), and maintainability. Use when the user asks to review code, 检查代码, 审阅代码, 代码评估, or analyze code design/quality.

Code Review

When to Use

Use this skill when the user asks to:

• review code
• 检查代码
• 审阅代码
• 代码评估 / code review
• 分析代码设计或质量

The user may provide:

• a code snippet
• a full file
• a git diff
• a description of the code structure

If no code is provided, ask the user to provide the code or file path before proceeding.

Review Goals

The goal is not just correctness, but overall engineering quality.

Focus on:

• design rationality
• coupling clarity
• mobile‑friendly performance
• maintainability and extensibility
• readability

Provide actionable suggestions, not vague comments.

Review Dimensions

1. Design Rationality

Check whether the architecture and responsibilities are reasonable.

Questions:

• Does each module/class have a single responsibility?
• Is the abstraction level appropriate?
• Is there unnecessary complexity or over‑engineering?
• Are responsibilities clearly separated?

Problems to flag:

• God classes
• functions doing too many things
• unclear module boundaries

2. Coupling and Dependency Clarity

Check whether dependencies are explicit and controllable.

Look for:

• hidden global state
• implicit dependencies
• circular dependencies
• tight coupling between modules

Prefer:

• dependency injection
• clear interfaces
• modular boundaries

Example problem: global state modifying behavior across modules without explicit dependency.

3. Performance Awareness (Especially Mobile)

Check for common performance risks.

CPU: heavy computation on main thread, unnecessary loops, repeated calculations.

Memory: large object allocations in loops, unnecessary copies, memory leaks.

IO / Resources: large resources loaded at once, blocking network or disk operations.

For UI or game: check update loops, avoid per-frame allocations and expensive operations in hot paths.

4. Maintainability

Evaluate whether future engineers can easily modify the code.

Check: naming clarity, file/module structure, readability, duplication of logic.

Prefer: clear names, modular code, reusable components.

Flag: magic numbers, unclear naming, duplicated code blocks.

5. Extensibility

Check whether the code can evolve without major rewrites.

Look for: rigid design, tightly coupled logic, missing extension points.

Prefer: configuration over hardcoding, modular design, open‑closed principle.

Output Format

Overall Assessment

Short summary: overall design (Good / Acceptable / Needs Improvement), main risks (performance, coupling, maintainability).

Key Issues

List the most important problems first. For each:

• Problem
• Why it matters
• Suggested improvement

Example:

• Problem: Function mixes networking and data parsing.
• Why it matters: Violates single responsibility and complicates testing.
• Suggestion: Split networking logic and parsing into separate modules.

Improvement Suggestions

Concrete improvements: refactoring, architectural adjustments, performance optimizations. Include small code examples if helpful.

Positive Aspects

Highlight what the code does well: good modular design, efficient logic, good naming.

Review Quality Checklist

Before finishing, ensure:

• The review covers design, coupling, performance, and maintainability.
• Each problem includes a suggested improvement.
• The review prioritizes the most important issues first.
• Feedback is clear and actionable.