M03 Mutability
- 1.5k installs
- 1.3k repo stars
- Updated May 24, 2026
- actionbook/rust-skills
m03-mutability is an agent skill for resolve rust borrow checker mutability errors with cell, refcell, mutex, and interior mutability.
About
The m03-mutability skill is designed for resolve Rust borrow checker mutability errors with Cell, RefCell, Mutex, and interior mutability. Mutability > Layer 1: Language Mechanics Core Question Why does this data need to change, and who can change it? Before adding interior mutability, understand: Is mutation essential or accidental complexity? Invoke when the user hits cannot borrow as mutable, already borrowed, or interior mutability questions.
- Is mutation essential or accidental complexity?.
- Who should control mutation?.
- Is the mutation pattern safe?.
M03 Mutability by the numbers
- 1,458 all-time installs (skills.sh)
- +52 installs in the week ending Jul 28, 2026 (Skillselion tracking)
- Ranked #10 of 129 Rust skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
m03-mutability capabilities & compatibility
- Capabilities
- is mutation essential or accidental complexity? · who should control mutation? · is the mutation pattern safe?
What m03-mutability says it does
CRITICAL: Use for mutability issues. Triggers: E0596, E0499, E0502, cannot borrow as mutable, already borrowed as immutable, mut, &mut, interior mutability, Cell, RefCell, Mutex, R
CRITICAL: Use for mutability issues. Triggers: E0596, E0499, E0502, cannot borrow as mutable, already borrowed as immutable, mut, &mut, interior mutability, Cel
npx skills add https://github.com/actionbook/rust-skills --skill m03-mutabilityAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1.5k |
|---|---|
| repo stars | ★ 1.3k |
| Security audit | 3 / 3 scanners passed |
| Last updated | May 24, 2026 |
| Repository | actionbook/rust-skills ↗ |
How do I resolve rust borrow checker mutability errors with cell, refcell, mutex, and interior mutability?
Resolve Rust borrow checker mutability errors with Cell, RefCell, Mutex, and interior mutability.
Who is it for?
Rust developers fixing E0596, E0499, E0502 and interior mutability patterns.
Skip if: Skip for non-Rust languages or high-level architecture without borrow errors.
When should I use this skill?
User hits cannot borrow as mutable, already borrowed, or interior mutability questions.
What you get
Completed m03-mutability workflow with documented commands, files, and expected deliverables.
- Mutability design decision
- Corrected borrow-safe code
Files
Mutability
Layer 1: Language Mechanics
Core Question
Why does this data need to change, and who can change it?
Before adding interior mutability, understand:
- Is mutation essential or accidental complexity?
- Who should control mutation?
- Is the mutation pattern safe?
---
Error → Design Question
| Error | Don't Just Say | Ask Instead |
|---|---|---|
| E0596 | "Add mut" | Should this really be mutable? |
| E0499 | "Split borrows" | Is the data structure right? |
| E0502 | "Separate scopes" | Why do we need both borrows? |
| RefCell panic | "Use try_borrow" | Is runtime check appropriate? |
---
Thinking Prompt
Before adding mutability:
1. Is mutation necessary?
- Maybe transform → return new value
- Maybe builder → construct immutably
2. Who controls mutation?
- External caller →
&mut T - Internal logic → interior mutability
- Concurrent access → synchronized mutability
3. What's the thread context?
- Single-thread → Cell/RefCell
- Multi-thread → Mutex/RwLock/Atomic
---
Trace Up ↑
When mutability conflicts persist:
E0499/E0502 (borrow conflicts)
↑ Ask: Is the data structure designed correctly?
↑ Check: m09-domain (should data be split?)
↑ Check: m07-concurrency (is async involved?)| Persistent Error | Trace To | Question |
|---|---|---|
| Repeated borrow conflicts | m09-domain | Should data be restructured? |
| RefCell in async | m07-concurrency | Is Send/Sync needed? |
| Mutex deadlocks | m07-concurrency | Is the lock design right? |
---
Trace Down ↓
From design to implementation:
"Need mutable access from &self"
↓ T: Copy → Cell<T>
↓ T: !Copy → RefCell<T>
"Need thread-safe mutation"
↓ Simple counters → AtomicXxx
↓ Complex data → Mutex<T> or RwLock<T>
"Need shared mutable state"
↓ Single-thread: Rc<RefCell<T>>
↓ Multi-thread: Arc<Mutex<T>>---
Borrow Rules
At any time, you can have EITHER:
├─ Multiple &T (immutable borrows)
└─ OR one &mut T (mutable borrow)
Never both simultaneously.Quick Reference
| Pattern | Thread-Safe | Runtime Cost | Use When |
|---|---|---|---|
&mut T | N/A | Zero | Exclusive mutable access |
Cell<T> | No | Zero | Copy types, no refs needed |
RefCell<T> | No | Runtime check | Non-Copy, need runtime borrow |
Mutex<T> | Yes | Lock contention | Thread-safe mutation |
RwLock<T> | Yes | Lock contention | Many readers, few writers |
Atomic* | Yes | Minimal | Simple types (bool, usize) |
Error Code Reference
| Error | Cause | Quick Fix |
|---|---|---|
| E0596 | Borrowing immutable as mutable | Add mut or redesign |
| E0499 | Multiple mutable borrows | Restructure code flow |
| E0502 | &mut while & exists | Separate borrow scopes |
---
Interior Mutability Decision
| Scenario | Choose |
|---|---|
| T: Copy, single-thread | Cell<T> |
| T: !Copy, single-thread | RefCell<T> |
| T: Copy, multi-thread | AtomicXxx |
| T: !Copy, multi-thread | Mutex<T> or RwLock<T> |
| Read-heavy, multi-thread | RwLock<T> |
| Simple flags/counters | AtomicBool, AtomicUsize |
---
Anti-Patterns
| Anti-Pattern | Why Bad | Better |
|---|---|---|
| RefCell everywhere | Runtime panics | Clear ownership design |
| Mutex for single-thread | Unnecessary overhead | RefCell |
| Ignore RefCell panic | Hard to debug | Handle or restructure |
| Lock inside hot loop | Performance killer | Batch operations |
---
Related Skills
| When | See |
|---|---|
| Smart pointer choice | m02-resource |
| Thread safety | m07-concurrency |
| Data structure design | m09-domain |
| Anti-patterns | m15-anti-pattern |
Related skills
Rust Async PatternsGenerate correct, production-grade async Rust code using Tokio, async-trait, channels, streams and proper error handling.16.3k38.3k
Rust Best PracticesGet concise, high-signal Rust style guidance that an agent can apply directly to code suggestions and reviews.14.5k100
Tauri V2Get expert guidance when creating cross-platform desktop and mobile apps using web technologies and Rust.6.5k14
Rust TestingGenerate comprehensive Rust tests following TDD with unit, integration, async, property-based, and mocked tests.5.8k234kRust PatternsGenerate and review idiomatic Rust code that follows ownership rules, error handling conventions, and concurrency best practices.5.4k234k
Rust SkillsEnsure every line of Rust they generate follows battle-tested idioms for ownership, error handling, performance and API design.3.6k367Forks & variants (1)
M03 Mutability has 1 known copy in the catalog totaling 784 installs. They canonicalize to this original listing.
- zhanghandong - 784 installs
How it compares
Use m03-mutability for borrow and interior mutability errors rather than trait bound or generic polymorphism skills in the Rust actionbook series.
FAQ
What does m03-mutability do?
Resolve Rust borrow checker mutability errors with Cell, RefCell, Mutex, and interior mutability.
When should I use m03-mutability?
User hits cannot borrow as mutable, already borrowed, or interior mutability questions.
Is m03-mutability safe to install?
Review the Security Audits panel on this page before installing in production.