- name
SKILL.md
Tệp skill vẫn nằm trong kho mã của nhà phát hành.
Dán lệnh đã sao chép vào terminal. Lệnh sẽ cài đặt tệp SKILL.md này vào agent đó.
npx skills add vibeeval/vibecosystem --skill ai-slop-cleaner -a cursor -yDán lệnh đã sao chép vào terminal. Lệnh sẽ cài đặt tệp SKILL.md này vào agent đó.
npx skills add vibeeval/vibecosystem --skill ai-slop-cleaner -a claude-code -yDán lệnh đã sao chép vào terminal. Lệnh sẽ cài đặt tệp SKILL.md này vào agent đó.
npx skills add vibeeval/vibecosystem --skill ai-slop-cleaner -a codex -yDán lệnh đã sao chép vào terminal. Lệnh sẽ cài đặt tệp SKILL.md này vào agent đó.
npx skills add vibeeval/vibecosystem --skill ai-slop-cleaner -a grok -yGửi tin nhắn đã sao chép trong cuộc trò chuyện Grok Bot. Bot sẽ lấy tệp SKILL.md này từ GitHub và thêm vào bộ skill mà mọi Bot của bạn dùng chung.
Install this skill: https://github.com/vibeeval/vibecosystem/tree/HEAD/skills/ai-slop-cleanerTừ nhà phát hành
AI code generation produces working code. It also produces unnecessary code alongside it. This skill removes the unnecessary parts while keeping everything that matters.
AI slop is code that:
Common slop categories and their signals:
Tests are sacred. Never clean test files.
Tests exist to protect behavior. Any cleanup that breaks a test reveals that the "slop" was actually load-bearing. That is good information. The test wins.
BEFORE ANYTHING: Run full test suite → all tests must pass (baseline)
FOR EACH PASS:
1. Identify targets for this pass category
2. Apply cleanup
3. Run tests
4. If tests pass: keep cleanup, continue
5. If tests fail: git checkout -- . (revert), skip this pass category
6. Log what was reverted and why
AFTER ALL PASSES: Run full test suite → confirm all tests still pass
Report: lines removed, files touched, passes skipped, reason for each skip
Never batch multiple pass categories together. If combined changes break a test, you cannot know which change caused it.
Risk: Very Low
What to remove:
let/const/var that are never read after assignment_)Before:
import { useState, useEffect, useCallback, useMemo } from 'react'
import { formatDate } from '@/lib/utils'
import { ApiClient } from '@/lib/api'
export function UserCard({ user }) {
const [count, setCount] = useState(0)
const formatted = formatDate(user.createdAt)
return <div>{user.name}</div>
}
After:
import { useState } from 'react'
import { formatDate } from '@/lib/utils'
export function UserCard({ user }) {
const [count, setCount] = useState(0)
const formatted = formatDate(user.createdAt)
return <div>{user.name}</div>
}
Note: count, setCount, and formatted are still present because they may be used elsewhere in a larger component. Pass 1 only removes imports.
Risk: Very Low
What to remove:
console.log, console.debug, console.warn (unless it is a legitimate error logger)debugger statementsprint() in Python when not serving as actual program outputfmt.Println in Go debug instrumentationBefore:
async function processOrder(orderId: string) {
console.log('processing order', orderId)
const order = await db.orders.findById(orderId)
// const cached = await cache.get(orderId)
// if (cached) return cached
console.log('order fetched:', order)
const result = await payments.charge(order)
// TODO: add retry logic here
// console.log('charge result', result)
return result
}
After:
async function processOrder(orderId: string) {
const order = await db.orders.findById(orderId)
const result = await payments.charge(order)
// TODO: add retry logic here
return result
}
Rule: // TODO: comments are preserved. They are documentation of known gaps, not slop.
Risk: Low
What to remove:
@param blocks that just repeat the parameter name and type (TypeScript already says this)// ===== COMPONENT =====)} // end if, } // end for)Before:
/**
* Gets a user by ID.
* @param id - the user ID
* @param db - the database instance
* @returns the user object
*/
async function getUserById(id: string, db: Database): Promise<User> {
// Query the database for the user
const user = await db.users.findById(id)
// Return the user
return user
} // end getUserById
After:
async function getUserById(id: string, db: Database): Promise<User> {
return db.users.findById(id)
}
Keep comments that explain WHY (business rules, performance choices, known gotchas). Remove comments that explain WHAT (the code already says what).
Risk: Medium — Run tests immediately after
What to remove:
return, throw, or breakBefore:
function getStatus(user: User): string {
if (user.role === 'admin' || user.role === 'admin') {
return 'ADMIN'
}
if (user.isActive) {
return 'ACTIVE'
} else {
return 'INACTIVE'
}
// This never runs
return 'UNKNOWN'
}
After:
function getStatus(user: User): string {
if (user.role === 'admin') {
return 'ADMIN'
}
return user.isActive ? 'ACTIVE' : 'INACTIVE'
}
Do not remove branches that look unreachable but depend on runtime data you cannot verify statically. When uncertain, leave it.
Risk: Medium — Run tests immediately after
What to inline:
Before:
function formatUserDisplayName(user: User): string {
return `${user.firstName} ${user.lastName}`.trim()
}
function renderUserCard(user: User) {
const displayName = formatUserDisplayName(user)
return `<div class="card">${displayName}</div>`
}
After (if formatUserDisplayName is only called from renderUserCard):
function renderUserCard(user: User) {
const displayName = `${user.firstName} ${user.lastName}`.trim()
return `<div class="card">${displayName}</div>`
}
Do NOT inline if:
Risk: Medium-High — Run tests immediately after each consolidation
What to consolidate:
Before:
// In UserService
async function getActiveUsers() {
const users = await db.query(
'SELECT * FROM users WHERE status = $1 AND deleted_at IS NULL',
['active']
)
return users.rows
}
// In AdminService (same file or different file)
async function getActiveAdmins() {
const admins = await db.query(
'SELECT * FROM users WHERE status = $1 AND deleted_at IS NULL AND role = $2',
['active', 'admin']
)
return admins.rows
}
After:
async function getActiveUsers(role?: string) {
const params: unknown[] = ['active']
let sql = 'SELECT * FROM users WHERE status = $1 AND deleted_at IS NULL'
if (role) {
sql += ' AND role = $2'
params.push(role)
}
const result = await db.query(sql, params)
return result.rows
}
Be careful: consolidation that requires complex parameterization may make code harder to understand. If the consolidated version is more complex than the two originals, leave them separate.
Risk: High — High scrutiny, run tests after every individual change
What to simplify:
Before:
interface DataProcessor<T extends BaseData> {
process(data: T): ProcessedData<T>
validate(data: T): ValidationResult
}
class UserDataProcessorFactory {
create(): DataProcessor<UserData> {
return new UserDataProcessor()
}
}
class UserDataProcessor implements DataProcessor<UserData> {
process(data: UserData): ProcessedData<UserData> {
return { ...data, processed: true }
}
validate(data: UserData): ValidationResult {
return { valid: !!data.id }
}
}
After (if only UserData ever flows through this):
function processUserData(data: UserData) {
if (!data.id) throw new Error('Invalid user data: missing id')
return { ...data, processed: true }
}
Rule for Pass 7: If you need more than 2 minutes to understand why an abstraction exists, and there is only one concrete case, remove the abstraction. If you find yourself unsure whether it is load-bearing, leave it. Pass 7 is optional.
Place at project root to exclude paths:
# .slopignore
src/legacy/ # Old code being migrated, don't touch
src/generated/ # Auto-generated, cleaned by generator
vendor/ # Third-party code
After all passes complete, output:
AI Slop Cleaner Report
======================
Files touched: 12
Lines removed: 147
Lines remaining: 1,843
Reduction: 7.4%
Pass results:
Pass 1 (Dead imports): DONE — 23 lines removed
Pass 2 (Debug code): DONE — 18 lines removed
Pass 3 (Obvious comments): DONE — 41 lines removed
Pass 4 (Dead code): DONE — 12 lines removed
Pass 5 (One-use helpers): DONE — 31 lines removed
Pass 6 (Duplication): SKIPPED — test failed after consolidation (UserService)
Pass 7 (Over-engineering): DONE — 22 lines removed
Skipped details:
Pass 6 reverted: UserService query consolidation broke getUsersByStatus test.
Root cause: test was asserting on the exact SQL string. Left original.
Test status: ALL PASSING (127/127)
AI slop cleaner runs at the code level (syntactic cleanup). The refactor-cleaner agent runs at the architecture level (structural refactoring). Run this skill first, then refactor-cleaner if structural improvement is needed.
Order:
1. ai-slop-cleaner (remove the noise)
2. code-reviewer (verify quality after cleanup)
3. refactor-cleaner (structural improvements if needed)
4. verifier (final gate)
This skill is automatically triggered after:
The trigger runs Pass 1 and Pass 2 only by default (very low risk). Passes 3-7 require explicit activation or a /clean command.
Remember: The goal is not minimum lines of code. The goal is maximum clarity per line. If removing something makes the code harder to understand, put it back.
Post-implementation cleanup that removes AI-generated bloat while preserving functionality. Runs pass-by-pass with test verification after each pass. Activate after kraken/spark complete a feature, or
---name: ai-slop-cleanerdescription: Post-implementation cleanup that removes AI-generated bloat while preserving functionality. Runs pass-by-pass…---# skills/ai-slop-cleaner/SKILL.mdTổng quan
Post-implementation cleanup that removes AI-generated bloat while preserving functionality. Runs pass-by-pass with test verification after each pass. Activate after kraken/spark complete a feature, or when a codebase needs hygiene work.
Câu hỏi thường gặp
Tải skills/ai-slop-cleaner/SKILL.md từ nhà phát hành, hoặc sao chép đường dẫn và mở kho mã. PlugMCP chỉ liệt kê skill và không lưu trữ tệp này.
Nhà phát hành duy trì nó tại https://github.com/vibeeval/vibecosystem.
Claude, Cursor, Codex và Grok Build có thể đọc tệp SKILL.md mà bạn thêm từ kho mã của nhà phát hành. Grok Bot cài đặt skill khi bạn gửi liên kết thư mục GitHub của skill trong cuộc trò chuyện.