Mastering Code Review: Boost Code Quality and Team Efficiency

Glossary

CR: Code Review CL: changelist – a self‑contained change submitted for review. LGTM: "Looks Good to Me" – approval phrase.

Why Code Review Matters

Root Question

Why are the codebases we inherit so hard to maintain?

Key reason: incomplete code review, often excused by "too busy".

Short‑term focus

Invisible problems

Non‑functional development

No immediate ROI

Underestimated impact (non‑linear)

Significance

Modern code review, based on best practices, reduces risk, improves maintainability, and increases development efficiency while raising individual and team technical skills – a true expression of the "craftsman spirit".

Code Review Principles

Approve any changelist that improves overall code health, even if imperfect.

Communicate based on technical facts and data.

Resolve conflicts without getting stuck.

Leverage tools (lint, company standards, AI assistants).

Initiating a Code Review

Preparation

Create a personal checklist.

Review your own code as if you were the reviewer.

Anticipate problematic areas.

Perform thorough self‑testing.

Don’t rely on others to find issues.

Reference: Code Review quick‑reference handbook.

Automated Pre‑checks

Unit test coverage

New unit tests

Method length limits

Cyclomatic complexity limits

Code style linting

Size monitoring

Suggested average review time should not exceed 10 minutes; e2e and performance checks should not block MR creation.

Reasonable Scope

200 LOC per review is ideal, max 400 LOC.

Keep review speed below 500 LOC/hour.

Do not exceed 60 minutes per review.

Adopt lightweight review style.

All team members should participate.

Spend 0.5–1 day per week on code review.

Ensure thoroughness.

How to Split a CL

Reference: Google Small CL Guidelines

Commit Description

Bad Cases

"Fix bug" is insufficient – specify which bug and what was done.

Logical fix

Add patch

Add rule X

Delete logic X

Good Cases

Summary: [module] add new feature Background: new requirement, see ticket Details: because of X, added processing module…

Example: Remove size limit of RPC server message free list.

Explain why and how.

Use tools like cz for conventional commits when needed.

Mindset

Treat each review as a conversation.

Expect feedback and respond promptly.

Be prepared for defects.

Review aims to discover problems, not to resist.

What Should Be Reviewed

Code is written for people, not machines – Structure and Interpretation of Computer Programs

Review Content Priorities (Top‑Down)

Review Process Flow

Real‑World Code Review Example (JD)

Design

Good Case

componentDidMount() {
  this.fetchUserInfo();
  this.fetchCommonInfo();
  this.fetchBankDesc();
}

Bad Case

componentDidMount() {
  const { location, dispatch, accountInfoList } = this.props;
  const { token, af } = getLocationParams(location) || {};
  dispatch({
    type: 'zpmUserCenter/fetchUserInfo',
    payload: { token },
  }).catch(e => {
    const zpmOpenAuthUrlLogin = decodeURIComponent(getCookie('zpmOpenAuthUrlLogin'));
    if ([TOKEN_EXPIRED_CODE, '300000'].includes(e.errorCode) && (isSaveUrl(af) || isSaveUrl(zpmOpenAuthUrlLogin))) {
      setTimeout(() => {
        window.location.href = isSaveUrl(af) ? af : zpmOpenAuthUrlLogin;
      }, 2000);
    }
  });
  if (!this.showWhichHeader() && !this.showGatewayHeader()) {
    dispatch({ type: 'zpmUserCenter/fetchAccountInfo', payload: { token } });
  }
  this.getBlackList();
}

Problems: unencapsulated fetchUserInfo, vague variable names, magic strings, repeated URL checks.

Clean Code Traits (CLEAN)

Cohesive – easier to understand.

Loosely Coupled – fewer side effects.

Encapsulated – manages complexity.

Assertive – behavior and data together.

Non‑redundant – single source of truth.

Avoid Over‑Design

Code should be readable and its pattern recognizable to others.

Complexity & Maintainability

Prefer standard library features.

Encapsulate details.

Simpler code means fewer bugs.

Follow Single Responsibility Principle.

Apply DRY.

Example of Unnecessary Complexity

function getWords(number) {
  switch (number) {
    case 1: return "one";
    case 2: return "a couple";
    case 3: return "a few";
    default: return "lots";
  }
} // Cyclomatic complexity: 4

Code Style Issues

Inconsistent import ordering, naming, and magic numbers should be fixed using tools like eslint-plugin-simple-import-sort or eslint-plugin-import.

import { ref } from 'vue';
import Taro from '@tarojs/taro';
import gwApi from '@/api/index-gateway-js';
import api from '@/api/index-js';
import { onMounted, reactive, watch } from 'vue';
import InputRight from '../components/InputRight.vue';
import { isweapp, getParams } from '@/utils';
import { FACTORY_ADDRESS_ORIGIN } from '@/utils/const.js';
import { sgmReportCustom } from '@/utils/log';
import { genAddressStr } from '@/utils/address';

Security

Avoid hard‑coding sensitive credentials.

// Bad example
const WX_APP_ID = 'xxxxxxxxxx';
const WX_APP_SECRET = 'xxxxxxxxxxxxxxxxxxxxx';

Consistency

Function names match implementations.

Comments reflect code.

Naming conventions are uniform (kebab‑case files, PascalCase classes, camelCase variables).

Avoid mixing import and require.

Common Challenges

Cannot Spot Issues

Organize collective review sessions to raise overall review skill.

Fear of Conflict

Leaders mediate and arbitrate.

Use collaborative language (“Would it be better if…?”).

Provide constructive suggestions rather than criticism.

Lack of Time

Allocate ~20% of development time for reviews; keep reviews under 60 minutes and limit CL size to 200‑400 LOC.

Improving Team Engineering Culture

Master 24 design patterns.

Apply SOLID principles.

Adopt DevOps, XP, Scrum, Kanban, Waterfall, structured analysis/design.

Practice TDD, OOP, functional programming, CI, pair programming.

Recommended Reading

"Programming Principles", "Refactoring", "Clean Code", "Code Complete", "Agile Software Development", "Clean Architecture", "The Clean Coder".

TL;DR

Code Review quick‑reference handbook.

References

https://composity.com/post/too-busy-to-improve

https://commadot.com/wtf-per-minute/

https://dl.acm.org/doi/10.1145/3585004#d1e372

https://google.github.io/eng-practices/review/reviewer/standard.html

https://book.douban.com/subject/35513153/

https://zhuanlan.zhihu.com/p/549019453