We make services people love by the power of Gen AI.
Facebook-f Twitter Youtube Linkedin-in
Contact

Code-Simplifier Plugin – Công cụ làm sạch code từ Anthropic

CLAUDE CODE PLUGIN

Code-Simplifier

Công cụ refactor và làm sạch code chính thức được phát triển bởi team Claude Code tại Anthropic


Plugin này là gì?

Code-Simplifier là một plugin chính thức được phát triển và sử dụng nội bộ bởi team Claude Code tại Anthropic. Đây không phải là một công cụ từ bên thứ ba, mà là công cụ mà chính những người tạo ra Claude Code dùng hàng ngày để giữ cho codebase của họ luôn sạch sẽ và dễ bảo trì.

Mục đích chính của plugin là cải thiện chất lượng code mà không thay đổi chức năng. Điều này có nghĩa là sau khi plugin refactor code của bạn, mọi input vẫn cho ra cùng output, mọi API vẫn hoạt động như cũ, nhưng code sẽ ngắn gọn hơn, dễ đọc hơn, và dễ maintain hơn.

Plugin này đặc biệt hữu ích khi làm việc với code do AI generate. Khi sử dụng AI để viết code, đôi khi AI tạo ra những pattern phức tạp không cần thiết, những đoạn code dư thừa, hoặc những cấu trúc lồng nhau quá sâu. Code-Simplifier sẽ tự động phát hiện và sửa những vấn đề này.

Các tính năng chính

Bảo toàn chức năng tuyệt đối

Đây là nguyên tắc số một của plugin. Code-Simplifier cam kết không bao giờ thay đổi behavior của code. Điều này có nghĩa là: tất cả các giá trị trả về (return values) giữ nguyên, tất cả các side effects giữ nguyên, tất cả các public API và method signatures giữ nguyên. Plugin chỉ thay đổi cách code được viết, không phải những gì code làm. Bạn có thể yên tâm chạy plugin mà không lo code bị break.

Giảm độ phức tạp của logic

Plugin sẽ tự động phát hiện và sửa các pattern phức tạp không cần thiết. Ví dụ phổ biến nhất là “Pyramid of Doom” – khi có quá nhiều câu lệnh if lồng nhau tạo thành hình kim tự tháp. Plugin sẽ chuyển đổi thành pattern “Early Return” – kiểm tra điều kiện lỗi và return sớm, giúp code phẳng hơn và dễ đọc hơn. Ngoài ra, plugin cũng loại bỏ các nested ternary operators, simplify các điều kiện boolean phức tạp, và gộp các điều kiện có thể gộp được.

Xóa dead code và biến không sử dụng

Trong quá trình phát triển, đặc biệt khi refactor hoặc sửa bug, developers thường để lại những đoạn code không còn được sử dụng. Plugin sẽ tự động phát hiện: các biến được khai báo nhưng không dùng đến, các hàm không được gọi từ đâu, các block code không thể reach được (ví dụ code sau lệnh return, hoặc trong điều kiện if(false)), và các import/require không sử dụng. Việc loại bỏ dead code giúp giảm kích thước file, giảm confusion khi đọc code, và cải thiện performance trong một số trường hợp.

Cải thiện cách đặt tên

Tên biến và tên hàm tốt là yếu tố quan trọng nhất để code dễ đọc. Plugin sẽ đề xuất thay đổi những tên biến mơ hồ như “temp”, “data”, “x”, “result” thành những tên có ý nghĩa hơn dựa trên context sử dụng. Ví dụ: “temp1” có thể thành “userAge”, “data” thành “responsePayload”, “x” thành “itemCount”. Tuy nhiên, plugin sẽ không tự động đổi tên mà không hỏi, vì việc đổi tên có thể ảnh hưởng đến các file khác reference đến biến/hàm đó.

Tách hàm lớn thành các hàm nhỏ (Extract Method)

Một hàm quá dài (thường trên 30-50 dòng) là dấu hiệu của code smell. Plugin sẽ tự động nhận diện các đoạn code có thể tách ra thành hàm riêng. Lợi ích của việc này bao gồm: mỗi hàm nhỏ chỉ làm một việc nên dễ hiểu và dễ test; có thể tái sử dụng các hàm nhỏ ở nơi khác; khi có bug, dễ xác định bug nằm ở hàm nào; và code trở nên self-documenting vì tên hàm mô tả chức năng của đoạn code đó.

Tuân thủ chuẩn và convention của dự án

Mỗi dự án có những convention và coding style riêng. Plugin sẽ đọc file CLAUDE.md (nếu có) trong project để hiểu các quy tắc của dự án, sau đó áp dụng những quy tắc này khi refactor. Ví dụ: nếu project quy định dùng ES modules thay vì CommonJS, plugin sẽ tuân theo; nếu project yêu cầu explicit type annotations, plugin sẽ thêm vào; nếu project có naming convention riêng (camelCase, snake_case, etc.), plugin sẽ follow. Điều này đảm bảo code sau khi refactor vẫn consistent với phần còn lại của codebase.

Hướng dẫn cài đặt chi tiết

Có hai cách để cài đặt plugin Code-Simplifier. Cả hai cách đều đơn giản và chỉ mất vài giây. Sau khi cài đặt, bạn cần restart session Claude Code để plugin được kích hoạt.

Cách 1: Cài đặt trực tiếp từ command line

Đây là cách nhanh nhất. Mở terminal và chạy lệnh sau:

claude plugin install code-simplifier

Lệnh này sẽ tự động download và cài đặt plugin từ marketplace chính thức của Claude.

Cách 2: Cài đặt từ bên trong session Claude Code

Nếu bạn đang trong một session Claude Code, có thể cài đặt trực tiếp bằng các slash commands:

/plugin marketplace update claude-plugins-official
/plugin install code-simplifier

Lệnh đầu tiên cập nhật danh sách plugins từ marketplace. Lệnh thứ hai cài đặt plugin.

Kết quả sau khi cài đặt thành công:

Successfully installed plugin: code-simplifier@claude-plugins-official (scope: user)

Sau khi thấy thông báo này, hãy restart session Claude Code. Plugin sẽ tự động được load và sẵn sàng sử dụng.

Hướng dẫn Demo Nhanh (5 phút)

Làm theo các bước dưới đây để trải nghiệm code-simplifier ngay lập tức. Bạn sẽ thấy được sức mạnh của plugin trong việc làm sạch code chỉ trong vài phút.

Bước 1

Mở thư mục demo trong terminal

cd C:\Users\Dk Cuong\Desktop\code-simplifier

Điều hướng đến thư mục chứa các file demo.

Bước 2

Xem code “messy” trước khi refactor

Mở file trong thư mục demo/ để xem các vấn đề code:

demo/example_javascript.js # 106 dòng - Callback hell, null checks
demo/example_python.py # 12+ levels nested if
demo/example_react.jsx # Prop drilling, anti-patterns

Bước 3

Khởi động Claude Code và chạy simplifier

# Khởi động Claude Code
claude
# Trong session Claude Code, gõ:
Use code-simplifier to refactor demo/example_javascript.js

Plugin sẽ phân tích và refactor file, cho bạn thấy trước/sau.

Bước 4

Demo với các file khác (tùy chọn)

# Refactor TypeScript
Use code-simplifier to refactor demo/example_typescript.ts
# Refactor Python
Use code-simplifier to refactor demo/example_python.py
# Hoặc refactor tất cả
Use code-simplifier to refactor all files in demo folder

Bước 5

Rollback để demo lại (Reset về code messy)

Sau khi demo xong, bạn có thể khôi phục lại code messy ban đầu để demo lại cho người khác:

Cách 1: Chạy batch file

rollback.bat

Double-click hoặc chạy trong terminal

Cách 2: Lệnh trong Claude Code

/demo-rollback

Gõ trực tiếp trong session

Tips Demo hiệu quả

  • Mở file side-by-side trước và sau để so sánh trực quan
  • Bắt đầu với example_javascript.js vì có nhiều vấn đề dễ thấy nhất
  • Dùng /demo-rollback để reset nhanh giữa các lần demo
  • Chạy git diff sau khi refactor để thấy tất cả thay đổi

Demo thực tế: So sánh code trước và sau khi refactor

Để minh họa cách plugin hoạt động, tôi đã tạo một file JavaScript với nhiều vấn đề code phổ biến, sau đó chạy Code-Simplifier để refactor. Dưới đây là kết quả chi tiết.

106
dòng code ban đầu

75
dòng sau refactor

-29%
giảm số dòng

Ví dụ 1: Xử lý “Pyramid of Doom” (If lồng nhau quá sâu)

Đây là vấn đề rất phổ biến khi developers viết code validation hoặc xử lý data. Mỗi lần check một điều kiện, họ lồng thêm một level if, tạo thành hình kim tự tháp. Code này rất khó đọc, khó maintain, và dễ bị bug khi cần thêm điều kiện mới.

TRƯỚC
18 levels nested 
function processUserData(data) {
  let result = null;
  if (data !== null) {
    if (data !== undefined) {
      if (typeof data === 'object') {
        if (data.users !== null) {
          if (data.users !== undefined) {
            if (Array.isArray(data.users)) {
              if (data.users.length > 0) {
                result = [];
                for (let i = 0; i < data.users.length; i++) {
                  const user = data.users[i];
                  if (user !== null && user !== undefined) {
                    if (user.name !== null && user.name !== undefined && user.name !== '') {
                      if (user.age !== null && user.age !== undefined) {
                        if (typeof user.age === 'number') {
                          if (user.age >= 18) {
                            const processedUser = {
                              fullName: user.name,
                              userAge: user.age,
                              isAdult: true,
                              status: user.status !== null && user.status !== undefined ? user.status : 'unknown'
                            };
                            result.push(processedUser);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  return result;
}


SAU
Flat, dễ đọc 
function processUserData(data) {
  // Guard clauses - kiểm tra và exit sớm
  if (!data || typeof data !== 'object') {
    return null;
  }

  if (!Array.isArray(data.users) || data.users.length === 0) {
    return null;
  }

  // Logic chính - rõ ràng và dễ hiểu
  return data.users
    .filter(isValidAdultUser)
    .map(createProcessedUser);
}

// Hàm helper - có thể reuse
function isValidAdultUser(user) {
  if (!user || !user.name) {
    return false;
  }
  if (typeof user.age !== 'number') {
    return false;
  }
  return user.age >= 18;
}

function createProcessedUser(user) {
  return {
    fullName: user.name,
    userAge: user.age,
    isAdult: true,
    status: user.status ?? 'unknown'
  };
}

Phân tích những gì đã thay đổi:

  • Early Return Pattern: Thay vì lồng if, kiểm tra điều kiện lỗi và return ngay. Code còn lại chỉ xử lý happy path.
  • Extract Method: Logic validation và transformation được tách thành hàm riêng (isValidAdultUser, createProcessedUser).
  • Functional Style: Dùng filter() và map() thay vì for loop với push(), code declarative hơn.
  • Nullish Coalescing: Dùng ?? thay vì check null/undefined dài dòng.
  • Kết quả: Từ 40 dòng xuống 25 dòng, từ 18 levels nesting xuống 2 levels.

Ví dụ 2: Loại bỏ biến thừa và code rườm rà

Đây là pattern thường gặp khi code được viết vội hoặc được refactor nhiều lần mà không cleanup. Các biến được gán qua lại không có mục đích, làm code khó theo dõi và tốn memory không cần thiết.

TRƯỚC
8 biến thừa 
function doStuff(x, y, z) {
  let temp1 = x + y;
  let temp2 = temp1;      // không cần thiết
  let temp3 = temp2 + z;
  let a = temp3;          // không cần thiết
  let b = a * 2;
  let c = b;              // không cần thiết
  let d = c - 10;
  let final = d;          // không cần thiết
  return final;
}

SAU
Trực tiếp, rõ ràng 
function doStuff(x, y, z) {
  const sum = x + y + z;
  return (sum * 2) - 10;
}

// Plugin đã phân tích logic:
// temp1 = x + y
// temp3 = temp1 + z = x + y + z
// b = temp3 * 2 = (x+y+z) * 2
// d = b - 10 = (x+y+z)*2 - 10

Ví dụ 3: Xóa dead code và unreachable code

Dead code là những đoạn code không bao giờ được thực thi. Chúng có thể là code cũ được comment out, biến được khai báo nhưng không dùng, hoặc code trong điều kiện không bao giờ true. Dead code làm tăng kích thước file, gây confusion, và có thể chứa security vulnerabilities.

TRƯỚC
Nhiều dead code 
function fetchData(url) {
  // Biến khai báo nhưng không dùng
  const unusedVar1 = "this is never used";
  const unusedVar2 = 42;
  let result;

  // Block không bao giờ chạy
  if (false) {
    console.log("This will never run");
    result = "impossible";
  }

  result = fetch(url);

  // Gán nhưng không dùng sau đó
  const unusedVar3 = result;

  return result;
}

SAU
Chỉ giữ code cần thiết 
function fetchData(url) {
  return fetch(url);
}






// Từ 16 dòng xuống 3 dòng
// Chức năng hoàn toàn giống nhau

Ví dụ 4: Đơn giản hóa logic điều kiện phức tạp

Khi có nhiều điều kiện if-else với logic tương tự, thường có thể tìm ra pattern chung và abstract thành code đơn giản hơn. Trong ví dụ này, discount cho premium và non-premium customers follow cùng một pattern, chỉ khác base rate.

TRƯỚC
Logic duplicate 
function calculateDiscount(price, customer) {
  let discount = 0;
  if (customer.isPremium === true) {
    if (customer.yearsActive > 5) {
      discount = 0.25;
    } else if (customer.yearsActive > 3) {
      discount = 0.20;
    } else if (customer.yearsActive > 1) {
      discount = 0.15;
    } else {
      discount = 0.10;
    }
  } else {
    if (customer.yearsActive > 5) {
      discount = 0.15;
    } else if (customer.yearsActive > 3) {
      discount = 0.10;
    } else if (customer.yearsActive > 1) {
      discount = 0.05;
    } else {
      discount = 0;
    }
  }
  const finalPrice = price - (price * discount);
  return finalPrice;
}

SAU
DRY – Don’t Repeat Yourself 
function calculateDiscount(price, customer) {
  const discount = getDiscountRate(
    customer.isPremium,
    customer.yearsActive
  );
  return price - (price * discount);
}

function getDiscountRate(isPremium, yearsActive) {
  // Premium có base 10%, non-premium base 0%
  const baseRate = isPremium ? 0.10 : 0;

  // Years bonus giống nhau cho cả hai
  if (yearsActive > 5) return baseRate + 0.15;
  if (yearsActive > 3) return baseRate + 0.10;
  if (yearsActive > 1) return baseRate + 0.05;

  return baseRate;
}

Pattern được phát hiện:

Plugin nhận ra rằng premium customers luôn có discount cao hơn non-premium đúng 10% ở mỗi tier. Thay vì duplicate logic, plugin extract thành hàm getDiscountRate với baseRate = isPremium ? 0.10 : 0, sau đó cộng thêm years bonus giống nhau cho cả hai loại customer.

Khuyến nghị sử dụng trong dự án thực tế

Dựa trên kinh nghiệm sử dụng và feedback từ cộng đồng developer, dưới đây là những tình huống nên và không nên sử dụng Code-Simplifier, cùng với các lợi ích cụ thể mà plugin mang lại.

Nên sử dụng khi:

Sau session code dài

Khi bạn đã code liên tục nhiều giờ, implement nhiều features, code có thể trở nên lộn xộn. Chạy plugin trước khi commit để dọn dẹp.

Trước khi tạo Pull Request

Code sạch sẽ giúp reviewer dễ đọc và review nhanh hơn. Ít comments về code style = merge PR nhanh hơn.

Sau khi refactor lớn

Refactoring thường để lại dead code, unused imports, và inconsistencies. Plugin giúp cleanup những remnants này.

Audit code do AI generate

AI models (kể cả Claude) đôi khi tạo ra code verbose hoặc over-engineered. Plugin giúp simplify những patterns này.

Onboarding team member mới

Codebase đơn giản và consistent giúp người mới hiểu code nhanh hơn và productive sớm hơn.

Lợi ích đo lường được:

Tiết kiệm 20-30% token usage

Code ngắn hơn = ít token hơn khi Claude đọc codebase = chi phí API thấp hơn. Một developer Nhật Bản báo cáo tiết kiệm đáng kể sau khi dùng plugin regularly.

Giảm bug rate

Code đơn giản có ít chỗ để bug ẩn náu. Nested conditionals và complex logic là nơi bug hay xuất hiện nhất.

CI/CD pipeline nhanh hơn

Ít code hơn = parse nhanh hơn, lint nhanh hơn, test coverage analysis nhanh hơn. Đặc biệt đáng kể với large monorepos.

Dễ maintain long-term

Code dễ đọc = dễ debug = dễ thêm feature mới. Technical debt được kiểm soát tốt hơn.

Phát hiện over-engineering sớm

Plugin giúp nhận ra khi code đang được làm phức tạp hơn mức cần thiết, trước khi nó trở thành pattern trong toàn bộ codebase.

Lưu ý quan trọng khi sử dụng

Plugin chạy trên model Opus

Đây là model mạnh nhất của Claude, đảm bảo chất lượng refactoring cao. Tuy nhiên, điều này cũng có nghĩa là mỗi lần chạy sẽ tốn nhiều tokens hơn so với models nhỏ hơn.

Mặc định chỉ focus code mới sửa

Plugin không tự động refactor toàn bộ codebase. Nó chỉ xử lý những file bạn vừa modify trong session hiện tại, tránh những thay đổi unexpected.

Luôn giữ nguyên public API

Plugin cam kết không thay đổi function signatures, method names, hoặc exported interfaces trừ khi bạn explicitly cho phép. Điều này đảm bảo code khác depend vào code của bạn không bị break.

Có phiên bản cho frameworks khác

Nếu bạn dùng Laravel/PHP, có laravel-simplifier từ Taylor Otwell. Nếu dùng Rust, có rust-simplifier từ MCP marketplace. Các phiên bản này hiểu conventions của framework tương ứng.

Bộ file demo đi kèm

Để tiện cho việc thực hành và trình diễn, bài viết này đi kèm với một bộ file demo hoàn chỉnh bao gồm 5 ngôn ngữ/framework phổ biến. Mỗi file chứa nhiều vấn đề code thực tế mà developers thường gặp trong công việc hàng ngày.

Cấu trúc thư mục

code-simplifier/
|-- demo/                      # Folder chứa các file code để demo
|   |-- example_javascript.js  # JavaScript: Callback hell, null checks
|   |-- example_typescript.ts  # TypeScript: Complex types, verbose code
|   |-- example_python.py      # Python: Nested conditions, anti-patterns
|   |-- example_php.php        # PHP: Legacy patterns, validation
|   |-- example_react.jsx      # React: Component anti-patterns
|
|-- backup/                    # Folder chứa bản gốc (messy code)
|   |-- (same files)           # Dùng để rollback khi cần demo lại
|
|-- article.html               # Bài viết này
|-- rollback.bat               # Script khôi phục code về trạng thái ban đầu
|-- simplify-all.bat           # Hướng dẫn chạy simplifier
|-- README.txt                 # Hướng dẫn sử dụng

Chi tiết các file demo

example_javascript.js

JavaScript

File này minh họa các vấn đề phổ biến trong JavaScript thuần, đặc biệt là khi làm việc với asynchronous code và data validation.

Các vấn đề được demo:

  • Callback Hell: Nested promises với .then() chồng chéo 4-5 levels, khiến code khó đọc và khó debug
  • Repetitive Null Checks: Kiểm tra null/undefined lặp đi lặp lại trên mỗi property của object
  • Duplicate Validation: Ba hàm validate (email, phone, username) có cấu trúc gần như giống hệt nhau
  • Magic Numbers: Hàm tính shipping cost chứa nhiều con số không có ý nghĩa rõ ràng (5.99, 9.99, 1.5, etc.)

example_typescript.ts

TypeScript

File này tập trung vào các anti-patterns thường gặp khi sử dụng TypeScript, đặc biệt là việc không tận dụng được sức mạnh của type system.

Các vấn đề được demo:

  • Redundant Type Checking: Kiểm tra null/undefined thủ công mặc dù TypeScript đã có strict null checks
  • Verbose Object Creation: Tạo object response bằng cách gán từng property một thay vì spread operator
  • Switch Statement Smell: Switch case dài với pattern lặp lại, có thể thay bằng lookup table/map
  • Unnecessary Temp Variables: Tạo biến tạm không cần thiết trong các phép tính đơn giản

example_python.py

Python

File này demo các vấn đề trong Python, bao gồm việc không tận dụng các tính năng Pythonic như list comprehension, f-strings, và dictionary operations.

Các vấn đề được demo:

  • Deep Nesting (12+ levels): Hàm process_payment với 12 tầng if lồng nhau để validate payment data
  • Repeated Code Blocks: Hàm calculate_bonus lặp lại cùng một pattern cho 4 departments khác nhau
  • Non-Pythonic Loops: Sử dụng range(len()) thay vì iterate trực tiếp, không dùng list comprehension
  • String Concatenation: Nối string bằng + thay vì f-strings, khiến code khó đọc và chậm hơn

example_php.php

PHP

File này tập trung vào các legacy patterns trong PHP mà nhiều codebase cũ vẫn còn sử dụng, cùng với các vấn đề về validation và data formatting.

Các vấn đề được demo:

  • Excessive Null Checking: Kiểm tra !== null, !== false, isset() lồng nhau nhiều tầng
  • Duplicate Validation: Validation cho name, price, quantity có cấu trúc giống nhau nhưng viết lại 3 lần
  • Verbose Array Building: Xây dựng array bằng cách gán từng key một thay vì compact syntax
  • God Method: Hàm processCheckout làm quá nhiều việc: validate, calculate, apply discount, shipping, tax

example_react.jsx

React

File này demo các anti-patterns phổ biến trong React components, đặc biệt là các vấn đề về state management và component design.

Các vấn đề được demo:

  • Prop Drilling: Pass props qua nhiều levels (UserDashboard -> PostList -> PostCard) thay vì dùng Context
  • Verbose Event Handlers: Mỗi event handler là một function riêng chỉ để gọi setState
  • Non-Arrow Functions: Sử dụng function() {} thay vì arrow functions trong callbacks
  • Too Many Props: Component PostCard nhận quá nhiều props riêng lẻ thay vì nhận object post
  • Complex Conditional Rendering: Multiple if statements trong render thay vì early return hoặc component composition

Hướng dẫn sử dụng Rollback

Sau khi chạy code-simplifier để refactor các file demo, bạn có thể muốn khôi phục lại trạng thái ban đầu (messy code) để demo lại hoặc so sánh. Đây là lý do tại sao chúng tôi cung cấp script rollback.

Cách 1: Chạy file rollback.bat

Double-click vào file rollback.bat trong thư mục gốc. Script sẽ tự động copy các file từ folder backup về folder demo.


C:\code-simplifier> rollback.bat

Cách 2: Chạy lệnh thủ công

Nếu bạn muốn rollback một file cụ thể, có thể dùng lệnh copy:

# Rollback file JavaScript
copy backup\example_javascript.js demo\example_javascript.js
# Rollback tất cả files
copy backup\* demo\

Output khi rollback thành công:

========================================
   CODE-SIMPLIFIER DEMO - ROLLBACK
========================================

Rolling back all demo files to original messy state...

[OK] example_javascript.js - Restored
[OK] example_typescript.ts - Restored
[OK] example_python.py - Restored
[OK] example_php.php - Restored
[OK] example_react.jsx - Restored

========================================
   ROLLBACK COMPLETE!
========================================

Workflow demo đề xuất

1

Mở file messy

Xem code trong folder demo/ để thấy các vấn đề

2

Chạy Simplifier

Yêu cầu Claude Code refactor file đó

3

So sánh kết quả

Xem code đã được cải thiện như thế nào

4

Rollback

Chạy rollback.bat để demo lại

Kết luận

Code-Simplifier là một công cụ thiết yếu cho bất kỳ developer nào làm việc với Claude Code. Nó không chỉ giúp code sạch hơn mà còn tiết kiệm chi phí API, giảm bug, và cải thiện tốc độ development. Đặc biệt quan trọng khi làm việc với AI-generated code, nơi mà sự phức tạp không cần thiết thường xuất hiện.

Plugin được phát triển và sử dụng nội bộ bởi chính team tạo ra Claude Code, đảm bảo chất lượng và độ tin cậy cao.

Cài đặt ngay với một lệnh đơn giản:

claude plugin install code-simplifier

Source code tham khảo: https://github.com/cuongdvscuti/code-simplifier

Video demo
Tags: