Skill

Pass

Audit score 90

m15-anti-pattern

zhanghandong/rust-skills

Identify and refactor Rust code anti-patterns during review.

What is m15-anti-pattern?

This skill helps you spot common Rust anti-patterns like excessive cloning, unwrap in production, and fighting the borrow checker. Use it when reviewing code to diagnose whether a pattern is solving a symptom or the underlying design problem, and to suggest more idiomatic alternatives.

Identify anti-patterns like clone-everywhere, unwrap-in-production, and unnecessary Rc usage
Trace anti-patterns to root causes in ownership, error handling, or data structure design
Suggest idiomatic Rust alternatives (references, ?, iterators, pattern matching)
Detect code smells indicating design issues (deep nesting, long functions, unclear ownership)
Provide refactoring guidance from anti-pattern to better pattern

How to install m15-anti-pattern

npx skills add https://github.com/zhanghandong/rust-skills --skill m15-anti-pattern

Claude Code

Cursor

Windsurf

Cline

How to use m15-anti-pattern

1.When reviewing code, ask: Is this solving a symptom or the root cause?
2.Check the anti-pattern table to identify the issue and its underlying problem
3.Trace up to related skills (m01-ownership, m06-error-handling, m09-domain) for design context
4.Use the refactoring guidance to suggest idiomatic alternatives
5.Apply the quick review checklist to catch common mistakes

Use cases

Good for

Review code with many .clone() calls to diagnose ownership design issues
Check production code for unwrap() calls and suggest proper error handling
Identify when String is overused instead of &str or Cow<str>
Spot index-based loops that should be iterators
Evaluate if Rc/Arc usage indicates unclear ownership structure

Who it's for

Code reviewers checking for design problems
Rust developers learning idiomatic patterns
Teams establishing code quality standards
Developers fighting the borrow checker or lifetime issues

m15-anti-pattern FAQ

What's the difference between an anti-pattern and just bad code?

An anti-pattern is a recurring solution that looks reasonable but creates problems. It often masks a design issue—like cloning to avoid borrow checker errors instead of fixing the ownership model.

Should I always avoid .clone()?

No, .clone() is sometimes correct. The anti-pattern is using it to escape borrow checker errors without fixing the underlying ownership design. Justify each clone.

When is .unwrap() acceptable?

In tests, examples, and situations where failure is truly impossible. In production library code, use ?, expect with a message, or proper error handling.

How do I know if my code structure is wrong?

If you're fighting lifetimes, have many clones, or need excessive unsafe code, the data structure or ownership model likely needs redesign. Trace to m01-ownership or m09-domain.

What should I use instead of index-based loops?

Use iterators: .iter(), .enumerate(), .map(), .filter(). They're more idiomatic, safer, and often more efficient.

Full instructions (SKILL.md)

Source of truth, from zhanghandong/rust-skills.

name: m15-anti-pattern description: "Use when reviewing code for anti-patterns. Keywords: anti-pattern, common mistake, pitfall, code smell, bad practice, code review, is this an anti-pattern, better way to do this, common mistake to avoid, why is this bad, idiomatic way, beginner mistake, fighting borrow checker, clone everywhere, unwrap in production, should I refactor, 反模式, 常见错误, 代码异味, 最佳实践, 地道写法" user-invocable: false

Anti-Patterns

Layer 2: Design Choices

Core Question

Is this pattern hiding a design problem?

When reviewing code:

Is this solving the symptom or the cause?
Is there a more idiomatic approach?
Does this fight or flow with Rust?

Anti-Pattern → Better Pattern

Anti-Pattern	Why Bad	Better
`.clone()` everywhere	Hides ownership issues	Proper references or ownership
`.unwrap()` in production	Runtime panics	`?`, `expect`, or handling
`Rc` when single owner	Unnecessary overhead	Simple ownership
`unsafe` for convenience	UB risk	Find safe pattern
OOP via `Deref`	Misleading API	Composition, traits
Giant match arms	Unmaintainable	Extract to methods
`String` everywhere	Allocation waste	`&str`, `Cow<str>`
Ignoring `#[must_use]`	Lost errors	Handle or `let _ =`

Thinking Prompt

When seeing suspicious code:

Is this symptom or cause?
- Clone to avoid borrow? → Ownership design issue
- Unwrap "because it won't fail"? → Unhandled case
What would idiomatic code look like?
- References instead of clones
- Iterators instead of index loops
- Pattern matching instead of flags
Does this fight Rust?
- Fighting borrow checker → restructure
- Excessive unsafe → find safe pattern

Trace Up ↑

To design understanding:

"Why does my code have so many clones?"
    ↑ Ask: Is the ownership model correct?
    ↑ Check: m09-domain (data flow design)
    ↑ Check: m01-ownership (reference patterns)

Anti-Pattern	Trace To	Question
Clone everywhere	m01-ownership	Who should own this data?
Unwrap everywhere	m06-error-handling	What's the error strategy?
Rc everywhere	m09-domain	Is ownership clear?
Fighting lifetimes	m09-domain	Should data structure change?

Trace Down ↓

To implementation (Layer 1):

"Replace clone with proper ownership"
    ↓ m01-ownership: Reference patterns
    ↓ m02-resource: Smart pointer if needed

"Replace unwrap with proper handling"
    ↓ m06-error-handling: ? operator
    ↓ m06-error-handling: expect with message

Top 5 Beginner Mistakes

Rank	Mistake	Fix
1	Clone to escape borrow checker	Use references
2	Unwrap in production	Propagate with `?`
3	String for everything	Use `&str`
4	Index loops	Use iterators
5	Fighting lifetimes	Restructure to own data

Code Smell → Refactoring

Smell	Indicates	Refactoring
Many `.clone()`	Ownership unclear	Clarify data flow
Many `.unwrap()`	Error handling missing	Add proper handling
Many `pub` fields	Encapsulation broken	Private + accessors
Deep nesting	Complex logic	Extract methods
Long functions	Multiple responsibilities	Split
Giant enums	Missing abstraction	Trait + types

Common Error Patterns

Error	Anti-Pattern Cause	Fix
E0382 use after move	Cloning vs ownership	Proper references
Panic in production	Unwrap everywhere	?, matching
Slow performance	String for all text	&str, Cow
Borrow checker fights	Wrong structure	Restructure
Memory bloat	Rc/Arc everywhere	Simple ownership

Deprecated → Better

Deprecated	Better
Index-based loops	`.iter()`, `.enumerate()`
`collect::<Vec<_>>()` then iterate	Chain iterators
Manual unsafe cell	`Cell`, `RefCell`
`mem::transmute` for casts	`as` or `TryFrom`
Custom linked list	`Vec`, `VecDeque`
`lazy_static!`	`std::sync::OnceLock`

Quick Review Checklist

No .clone() without justification
No .unwrap() in library code
No pub fields with invariants
No index loops when iterator works
No String where &str suffices
No ignored #[must_use] warnings
No unsafe without SAFETY comment
No giant functions (>50 lines)

Related Skills

When	See
Ownership patterns	m01-ownership
Error handling	m06-error-handling
Mental models	m14-mental-model
Performance	m10-performance

Related skills

More from zhanghandong/rust-skills and the wider catalog.

coding-guidelines

zhanghandong/rust-skills

Use when asking about Rust code style or best practices. Keywords: naming, formatting, comment, clippy, rustfmt, lint, code style, best practice, P.NAM, G.FMT, code review, naming convention, variable naming, function naming, type naming, 命名规范, 代码风格, 格式化, 最佳实践, 代码审查, 怎么命名

1.2k installsAudited

m10-performance

zhanghandong/rust-skills

CRITICAL: Use for performance optimization. Triggers: performance, optimization, benchmark, profiling, flamegraph, criterion, slow, fast, allocation, cache, SIMD, make it faster, 性能优化, 基准测试

881 installs

m07-concurrency

zhanghandong/rust-skills

CRITICAL: Use for concurrency/async. Triggers: E0277 Send Sync, cannot be sent between threads, thread, spawn, channel, mpsc, Mutex, RwLock, Atomic, async, await, Future, tokio, deadlock, race condition, 并发, 线程, 异步, 死锁

831 installs

m06-error-handling

zhanghandong/rust-skills

CRITICAL: Use for error handling. Triggers: Result, Option, Error, ?, unwrap, expect, panic, anyhow, thiserror, when to panic vs return Result, custom error, error propagation, 错误处理, Result 用法, 什么时候用 panic

810 installs

rust-refactor-helper

zhanghandong/rust-skills

Safe Rust refactoring with LSP analysis. Triggers on: /refactor, rename symbol, move function, extract, 重构, 重命名, 提取函数, 安全重构

806 installs

m01-ownership

zhanghandong/rust-skills

CRITICAL: Use for ownership/borrow/lifetime issues. Triggers: E0382, E0597, E0506, E0507, E0515, E0716, E0106, value moved, borrowed value does not live long enough, cannot move out of, use of moved value, ownership, borrow, lifetime, 'a, 'static, move, clone, Copy, 所有权, 借用, 生命周期

792 installs