Code Simplifier

rtk-ai/rtk/.claude/skills/code-simplifier

by rtk-aie4f05094d613No license82K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated today

Review RTK Rust code for idiomatic simplification. Detects over-engineering, unnecessary allocations, verbose patterns. Applies Rust idioms without changing behavior.

Instructions onlySoftware Development

AI-generated overview

Reviews Rust code in the RTK project and applies idiomatic simplifications without changing behavior.

What it does: The skill guides an agent through reviewing Rust code in RTK and rewriting verbose or over-engineered patterns into idiomatic equivalents. It lists seven simplification patterns, including iterator chains over manual loops, join instead of push loops, Option/Result chaining, struct destructuring, early returns, avoiding redundant clones, and if let for single-variant matches. It also names project constraints that must never be simplified away and suggests verification commands such as cargo fmt, clippy, and test.
When to use it: Use it when Rust code in RTK is described as verbose, over-engineered, or in need of refactoring toward idiomatic style. It fits requests to simplify or make code more idiomatic while preserving behavior.
Requirements: Instructions only; no scripts are shipped. It assumes access to the RTK Rust codebase and the ability to read, search, and edit files, plus a Rust toolchain with cargo, rustfmt, and clippy for the suggested verification commands.

RTK Code Simplifier

Review and simplify Rust code in RTK while respecting the project's constraints.

Constraints (never simplify away)

LazyLock regex — cannot be moved inside functions even if "simpler"
.context() on every ? — verbose but mandatory
Fallback to raw command — never remove even if it looks like dead code
Exit code propagation — never simplify to Ok(())
#[cfg(test)] mod tests — never remove test modules

Simplification Patterns

1. Iterator chains over manual loops

rust

// ❌ Verboselet mut result = Vec::new();for line in input.lines() {    let trimmed = line.trim();    if !trimmed.is_empty() && trimmed.starts_with("error") {        result.push(trimmed.to_string());    }}
// ✅ Idiomaticlet result: Vec<String> = input.lines()    .map(|l| l.trim())    .filter(|l| !l.is_empty() && l.starts_with("error"))    .map(str::to_string)    .collect();

// ❌ Verboselet mut result = Vec::new();for line in input.lines() {    let trimmed = line.trim();    if !trimmed.is_empty() && trimmed.starts_with("error") {        result.push(trimmed.to_string());    }}
// ✅ Idiomaticlet result: Vec<String> = input.lines()    .map(|l| l.trim())    .filter(|l| !l.is_empty() && l.starts_with("error"))    .map(str::to_string)    .collect();

2. String building

rust

// ❌ Verbose push looplet mut out = String::new();for (i, line) in lines.iter().enumerate() {    out.push_str(line);    if i < lines.len() - 1 {        out.push('\n');    }}
// ✅ joinlet out = lines.join("\n");

// ❌ Verbose push looplet mut out = String::new();for (i, line) in lines.iter().enumerate() {    out.push_str(line);    if i < lines.len() - 1 {        out.push('\n');    }}
// ✅ joinlet out = lines.join("\n");

3. Option/Result chaining

rust

// ❌ Nested matchlet result = match maybe_value {    Some(v) => match transform(v) {        Ok(r) => r,        Err(_) => default,    },    None => default,};
// ✅ Chainedlet result = maybe_value    .and_then(|v| transform(v).ok())    .unwrap_or(default);

// ❌ Nested matchlet result = match maybe_value {    Some(v) => match transform(v) {        Ok(r) => r,        Err(_) => default,    },    None => default,};
// ✅ Chainedlet result = maybe_value    .and_then(|v| transform(v).ok())    .unwrap_or(default);

4. Struct destructuring

rust

// ❌ Repeated field accessfn process(args: &MyArgs) -> String {    format!("{} {}", args.command, args.subcommand)}
// ✅ Destructurefn process(&MyArgs { ref command, ref subcommand, .. }: &MyArgs) -> String {    format!("{} {}", command, subcommand)}

// ❌ Repeated field accessfn process(args: &MyArgs) -> String {    format!("{} {}", args.command, args.subcommand)}
// ✅ Destructurefn process(&MyArgs { ref command, ref subcommand, .. }: &MyArgs) -> String {    format!("{} {}", command, subcommand)}

5. Early returns over nesting

rust

// ❌ Deeply nestedfn filter(input: &str) -> Option<String> {    if !input.is_empty() {        if let Some(line) = input.lines().next() {            if line.starts_with("error") {                return Some(line.to_string());            }        }    }    None}
// ✅ Early returnfn filter(input: &str) -> Option<String> {    if input.is_empty() { return None; }    let line = input.lines().next()?;    if !line.starts_with("error") { return None; }    Some(line.to_string())}

// ❌ Deeply nestedfn filter(input: &str) -> Option<String> {    if !input.is_empty() {        if let Some(line) = input.lines().next() {            if line.starts_with("error") {                return Some(line.to_string());            }        }    }    None}
// ✅ Early returnfn filter(input: &str) -> Option<String> {    if input.is_empty() { return None; }    let line = input.lines().next()?;    if !line.starts_with("error") { return None; }    Some(line.to_string())}

6. Avoid redundant clones

rust

// ❌ Unnecessary clonefn filter_output(input: &str) -> String {    let s = input.to_string();  // Pointless clone    s.lines().filter(|l| !l.is_empty()).collect::<Vec<_>>().join("\n")}
// ✅ Work with &strfn filter_output(input: &str) -> String {    input.lines().filter(|l| !l.is_empty()).collect::<Vec<_>>().join("\n")}

// ❌ Unnecessary clonefn filter_output(input: &str) -> String {    let s = input.to_string();  // Pointless clone    s.lines().filter(|l| !l.is_empty()).collect::<Vec<_>>().join("\n")}
// ✅ Work with &strfn filter_output(input: &str) -> String {    input.lines().filter(|l| !l.is_empty()).collect::<Vec<_>>().join("\n")}

7. Use `if let` for single-variant match

rust

// ❌ Full match for one variantmatch output {    Ok(s) => process(&s),    Err(_) => {},}
// ✅ if let (but still handle errors in RTK — don't silently drop)if let Ok(s) = output {    process(&s);}// Note: in RTK filters, always handle Err with eprintln! + fallback

// ❌ Full match for one variantmatch output {    Ok(s) => process(&s),    Err(_) => {},}
// ✅ if let (but still handle errors in RTK — don't silently drop)if let Ok(s) = output {    process(&s);}// Note: in RTK filters, always handle Err with eprintln! + fallback

RTK-Specific Checks

Run these after simplification:

bash

# Verify no regressionscargo fmt --all && cargo clippy --all-targets && cargo test
# Verify no new regex in functionsgrep -n "Regex::new" src/<file>.rs# Fixed, reused patterns should be in `LazyLock<Regex>` statics
# Verify no new unwrap in productiongrep -n "\.unwrap()" src/<file>.rs# Should only appear inside #[cfg(test)] blocks

# Verify no regressionscargo fmt --all && cargo clippy --all-targets && cargo test
# Verify no new regex in functionsgrep -n "Regex::new" src/<file>.rs# Fixed, reused patterns should be in `LazyLock<Regex>` statics
# Verify no new unwrap in productiongrep -n "\.unwrap()" src/<file>.rs# Should only appear inside #[cfg(test)] blocks

What NOT to Simplify

static RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(...).unwrap()); — the .unwrap() here is acceptable, it's init-time
.context("description")? chains — verbose but required
The fallback match arm Err(e) => { eprintln!(...); raw_output } — looks redundant but is the safety net
std::process::exit(code) at end of run() — looks like it could be Ok(())but it isn't

Source and attribution

Source:rtk-ai/rtkin.claude/skills/code-simplifierat commite4f0509

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Code Simplifier

RTK Code Simplifier

Constraints (never simplify away)

Simplification Patterns

1. Iterator chains over manual loops

2. String building

3. Option/Result chaining

4. Struct destructuring

5. Early returns over nesting

6. Avoid redundant clones

7. Use `if let` for single-variant match

RTK-Specific Checks

What NOT to Simplify

Source and attribution

More from rtk-ai/rtk

Design Patterns

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices

Code Simplifier

RTK Code Simplifier

Constraints (never simplify away)

Simplification Patterns

1. Iterator chains over manual loops

2. String building

3. Option/Result chaining

4. Struct destructuring

5. Early returns over nesting

6. Avoid redundant clones

7. Use if let for single-variant match

RTK-Specific Checks

What NOT to Simplify

Source and attribution

More from rtk-ai/rtk

Design Patterns

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices

7. Use `if let` for single-variant match