🎯

m01-ownership

🎯Skill

from goooice/rust-skills

VibeIndex|
What it does

Diagnoses and resolves Rust ownership, borrowing, and lifetime errors by tracing design choices and recommending targeted implementation strategies.

πŸ“¦

Part of

goooice/rust-skills(35 items)

m01-ownership

Installation

Add MarketplaceAdd marketplace to Claude Code
/plugin marketplace add ZhangHanDong/rust-skills
Install PluginInstall plugin from marketplace
/plugin install rust-skills@rust-skills
Quick InstallInstall with npx
npx skills add ZhangHanDong/rust-skills
git cloneClone repository
git clone https://github.com/ZhangHanDong/rust-skills.git
πŸ“– Extracted from docs: goooice/rust-skills
4Installs
-
AddedFeb 4, 2026

Skill Details

SKILL.md

"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, ζ‰€ζœ‰ζƒ, ε€Ÿη”¨, η”Ÿε‘½ε‘¨ζœŸ"

Overview

# Ownership & Lifetimes

> Layer 1: Language Mechanics

Core Question

Who should own this data, and for how long?

Before fixing ownership errors, understand the data's role:

  • Is it shared or exclusive?
  • Is it short-lived or long-lived?
  • Is it transformed or just read?

---

Error β†’ Design Question

| Error | Don't Just Say | Ask Instead |

|-------|----------------|-------------|

| E0382 | "Clone it" | Who should own this data? |

| E0597 | "Extend lifetime" | Is the scope boundary correct? |

| E0506 | "End borrow first" | Should mutation happen elsewhere? |

| E0507 | "Clone before move" | Why are we moving from a reference? |

| E0515 | "Return owned" | Should caller own the data? |

| E0716 | "Bind to variable" | Why is this temporary? |

| E0106 | "Add 'a" | What is the actual lifetime relationship? |

---

Thinking Prompt

Before fixing an ownership error, ask:

  1. What is this data's domain role?

- Entity (unique identity) β†’ owned

- Value Object (interchangeable) β†’ clone/copy OK

- Temporary (computation result) β†’ maybe restructure

  1. Is the ownership design intentional?

- By design β†’ work within constraints

- Accidental β†’ consider redesign

  1. Fix symptom or redesign?

- If Strike 3 (3rd attempt) β†’ escalate to Layer 2

---

Trace Up ↑

When errors persist, trace to design layer:

```

E0382 (moved value)

↑ Ask: What design choice led to this ownership pattern?

↑ Check: m09-domain (is this Entity or Value Object?)

↑ Check: domain-* (what constraints apply?)

```

| Persistent Error | Trace To | Question |

|-----------------|----------|----------|

| E0382 repeated | m02-resource | Should use Arc/Rc for sharing? |

| E0597 repeated | m09-domain | Is scope boundary at right place? |

| E0506/E0507 | m03-mutability | Should use interior mutability? |

---

Trace Down ↓

From design decisions to implementation:

```

"Data needs to be shared immutably"

↓ Use: Arc (multi-thread) or Rc (single-thread)

"Data needs exclusive ownership"

↓ Use: move semantics, take ownership

"Data is read-only view"

↓ Use: &T (immutable borrow)

```

---

Quick Reference

| Pattern | Ownership | Cost | Use When |

|---------|-----------|------|----------|

| Move | Transfer | Zero | Caller doesn't need data |

| &T | Borrow | Zero | Read-only access |

| &mut T | Exclusive borrow | Zero | Need to modify |

| clone() | Duplicate | Alloc + copy | Actually need a copy |

| Rc | Shared (single) | Ref count | Single-thread sharing |

| Arc | Shared (multi) | Atomic ref count | Multi-thread sharing |

| Cow | Clone-on-write | Alloc if mutated | Might modify |

Error Code Reference

| Error | Cause | Quick Fix |

|-------|-------|-----------|

| E0382 | Value moved | Clone, reference, or redesign ownership |

| E0597 | Reference outlives owner | Extend owner scope or restructure |

| E0506 | Assign while borrowed | End borrow before mutation |

| E0507 | Move out of borrowed | Clone or use reference |

| E0515 | Return local reference | Return owned value |

| E0716 | Temporary dropped | Bind to variable |

| E0106 | Missing lifetime | Add 'a annotation |

---

Anti-Patterns

| Anti-Pattern | Why Bad | Better |

|--------------|---------|--------|

| .clone() everywhere | Hides design issues | Design ownership properly |

| Fight borrow checker | Increases complexity | Work with the compiler |

| 'static for everything | Restricts flexibility | Use appropriate lifetimes |

| Leak with Box::leak | Memory leak | Proper lifetime design |

---

Related Skills

| When | See |

|------|-----|

| Need smart pointers | m02-resource |

| Need interior mutability | m03-mutability |

| Data is domain entity | m09-domain |

| Learning ownership concepts | m14-mental-model |

More from this repository10

🎯
m10-performance🎯Skill

Optimizes code performance by identifying bottlenecks, measuring impact, and guiding strategic improvements across algorithm, data structure, and memory efficiency.

🎯
m14-mental-model🎯Skill

Applies the M14 mental model framework to enhance decision-making and strategic thinking through structured cognitive analysis.

🎯
m04-zero-cost🎯Skill

Guides developers in choosing zero-cost abstractions by analyzing type system constraints and performance trade-offs in Rust generics and traits.

🎯
meta-cognition-parallel🎯Skill

Performs parallel three-layer meta-cognitive analysis by forking subagents to simultaneously analyze language mechanics, design choices, and domain constraints, then synthesizing results.

🎯
unsafe-checker🎯Skill

Identifies and reviews unsafe Rust code patterns, FFI risks, and potential memory unsafety in Rust projects.

🎯
rust-skill-creator🎯Skill

Dynamically generates Claude skills for Rust crates, standard library modules, and documentation by extracting and processing technical details from specified URLs.

🎯
coding-guidelines🎯Skill

Provides comprehensive Rust coding guidelines covering naming conventions, best practices, error handling, memory management, concurrency, and code style recommendations.

🎯
rust-refactor-helper🎯Skill

Performs safe Rust refactoring by analyzing symbol references, checking conflicts, and applying changes across project files using LSP.

🎯
m03-mutability🎯Skill

Diagnoses and guides resolution of Rust mutability and borrowing conflicts by analyzing ownership, mutation patterns, and thread-safety requirements.

🎯
m05-type-driven🎯Skill

Explores and demonstrates type-driven development techniques in Rust, showcasing advanced type system features and pattern matching strategies.