Shared Code Quality Standards for React + Rust Monorepo

Where this fits

Imagine you're maintaining a pnpm/Turbo monorepo with a React 19 + TypeScript frontend and a Rust (Tauri 2) backend. Your coding agents—a reviewer and an author—disagree on what “clean” means: the reviewer flags unwrap() calls as bugs, the author defends them as idiomatic. That friction slows every PR. The code-quality skill centralizes your team's clean-code standards into a single file both agents consume, so reviews and fixes align without constant manual intervention.

Why agents benefit

• The reviewer and author share the same severity taxonomy (High/Medium/Low), so reported violations map directly to fixing actions.
• It prevents over-application of DRY: the skill explicitly warns against deduplicating coincidental similarity, so agents don't create needless abstractions.
• Stack-specific smells (e.g., any in TypeScript, panic! in Rust) are called out with remediation context, enabling precise, actionable feedback.
• The skill is model-invocation-disabled, meaning it's loaded as a library, not triggered spontaneously—predictable usage in agent pipelines.
• It keeps human-defined heuristics (like “functions >~50 lines are medium”) consistently enforced across sessions and agents.

Practical scenarios

Reviewer catches error swallowing before it hits production

A developer submits a Rust command handler that calls .unwrap() on a Result from a file operation. The reviewer agent, loaded with this skill, flags it as High severity and suggests propagating the error with context()—exactly matching your team's fallibility policy.

Author refactors duplicated logic without breaking shared mutable state

The author agent spots two functions with similar loop patterns in a React hook. Instead of blindly extracting a helper, it checks the skill's DRY guidance: if the similarity is coincidental (different data shapes, independent state), it leaves it alone, avoiding premature abstraction.

Telemetry props stop being passed through five components

A TypeScript component tree passes a userId prop down three levels just to reach a button. The reviewer notices the prop drilling (Medium severity) and suggests context or a custom hook, but also checks the skill's KISS/YAGNI notes to confirm the current complexity warrants it.

Add it to your agent workflow

Install with:

npx skills add saeedkolivand/ai-job-hunter-app --skill code-quality

Then configure your reviewer and author agents to reference the skill's standards file (e.g., via path or skill ID). The skill is model-invocation-disabled, so you explicitly load it in your agent's system prompt or context—it won't fire on its own.

Compare before adopting

Before you commit, assess:

• Quality signals: Does this reflect your team's standards, or a generic set? The README is specific to React 19 + Rust Tauri—if your stack differs, you'll need to adapt.
• Maintenance freshness: Check the GitHub repo's commit history and issue responsiveness. A skill that goes stale may encode outdated anti-patterns.
• Alternatives: Other quality skills exist, but few combine cross-language standards with severity tiers this directly.
• Workflow fit: Decide if the explicit, library-style invocation fits your agent orchestration. If you rely on auto-invoked skills, this might require reconfiguration.

Why it is worth tracking

The project has 48 stars and a focused niche—a concrete signal that teams building Tauri/React monorepos see value in shared agent standards. Watch for updates that align with new React/Rust idioms, and evaluate it if you're wrestling with inconsistent agent code reviews. For a wider view of agent skills, see OpenAgentSkill to spot similar patterns and community momentum.