Help us improve
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
By TonyWu20
A comprehensive Rust development pipeline for Claude Code — orchestrates planning, code review, fix execution, and implementation through specialized agents and skills
npx claudepluginhub tonywu20/my-claude-marketplace --plugin rust-development-pipelineUse this agent when a `/drive-outcomes` orchestrator has produced TASKS.md tasks and you need a specialist to implement those tasks on a branch with real compiler feedback. This agent should be invoked for any concrete coding sub-task that requires editing code, running cargo check, and fixing errors — the edit→check→fix loop. \n\n<example>\nContext: A drive-outcomes orchestrator has decomposed a phase plan into TASKS.md with task groups.\nuser: \"Implement group-core tasks from TASKS.md\"\nassistant: \"I'll launch the implementation-executor agent to implement these tasks with cargo check feedback.\" \n<commentary>\nThe drive-outcomes orchestrator delegates a task group to the implementation-executor agent for branch-based implementation with compiler feedback.\n</commentary>\n</example>\n\n<example>\nContext: A make-judgement review has produced fix-tasks.md with defects to resolve.\nuser: \"Apply the fix directions for the review issues\"\nassistant: \"I'll use the implementation-executor agent to apply the fixes with the same edit→check→fix loop.\"\n</commentary>\n</example>
Use this agent when you need architectural guidance, code review, or strategic planning for Rust projects. This includes designing new systems, evaluating existing code structure, refactoring for better ergonomics, or when you want a senior engineer's perspective that challenges initial assumptions and applies first-principles thinking.\n\nExamples:\n\n<example>\nContext: User is starting a new Rust service and wants architectural guidance.\nuser: "I want to build a REST API in Rust that handles user authentication and data storage."\nassistant: "Let me use the rust-architect agent to design the architecture for this service."\n<commentary>\nThe user needs architectural planning for a new Rust project. The rust-architect agent should be invoked to apply first-principles thinking and propose a hexagonal architecture before any code is written.\n</commentary>\n</example>\n\n<example>\nContext: User has written a Rust module and wants a review.\nuser: "Here's my implementation of the repository layer. Can you review it?"\nassistant: "I'll use the rust-architect agent to review this code for design quality, separation of concerns, and Rust best practices."\n<commentary>\nA code review request for Rust code is a prime use case for the rust-architect agent, which will evaluate readability, ergonomics, SRP, and test coverage.\n</commentary>\n</example>\n\n<example>\nContext: User is asking how to implement a feature in a specific way.\nuser: "Should I use a trait object or generics for this abstraction?"\nassistant: "Let me invoke the rust-architect agent to reason through the trade-offs from first principles."\n<commentary>\nDesign decision questions in Rust benefit from the agent's deep knowledge of Rust idioms, composition patterns, and ergonomics.\n</commentary>\n</example>
Use this agent when code changes, implementations, or fixes need rigorous review against project documentation, architecture, and coding standards. Examples:\n\n<example>\nContext: The user has just implemented a new feature or module in the codebase.\nuser: "I've finished implementing the DAG execution engine in src/dag/executor.rs"\nassistant: "Let me launch the strict-code-reviewer agent to verify the implementation against the project architecture and documentation."\n<commentary>\nA significant implementation was completed. Use the Agent tool to launch the strict-code-reviewer to explore the codebase, check docs, and validate the code.\n</commentary>\n</example>\n\n<example>\nContext: The user has applied a bug fix and wants to ensure it's correct and consistent.\nuser: "I fixed the node dependency resolution bug in the workflow engine."\nassistant: "I'll use the strict-code-reviewer agent to verify the fix aligns with the real codebase and doesn't introduce drift from the architecture."\n<commentary>\nA bug fix was applied. Use the Agent tool to launch the strict-code-reviewer to check the fix against actual files and specifications.\n</commentary>\n</example>\n\n<example>\nContext: A subagent or assistant has proposed or applied code changes.\nuser: "The coding agent just refactored the task scheduler."\nassistant: "I'll invoke the strict-code-reviewer agent to double-check the refactor against actual files and prevent any hallucinated changes."\n<commentary>\nAnother agent made changes. Use the strict-code-reviewer to ground-truth the changes against real files and documentation.\n</commentary>\n</example>
Debug an existing fixture-anchored system that passes its acceptance test but produces wrong physics or wrong output. Classifies prior investigation notes, establishes external anchor criteria, applies upstream-audit rule, implements fix with discriminator-value tests, and captures resolution. Use when the user says "/debug-outcomes", "debug this failure", "the test passes but the output is wrong", or describes a symptom in a system that already has fixture files and a passing (but loose) acceptance test.
Interactive skill that helps users define desired outcomes for the next phase through Socratic grilling. Produces a PHASE_PLAN.md with concrete goals, scope boundaries, and success criteria. Uses grill-me + first-principle thinking to question priorities and foundations before committing to a plan. This is the recommended step before `/drive-outcomes`, especially when goals are still vague. Use when the user says "/define-outcomes", "define the outcomes", "clarify what we want", "what should the next phase achieve", "plan the next phase", or wants to decide what the next phase should accomplish before implementing.
Scans a Rust project's existing test suite for placebo test patterns (vacuous assertions, circular round-trip, unbounded thresholds, synthetic-only data). Produces a migration report to help projects adopt the Outcome-Driven Development (ODD) pipeline. Use when migrating from the old TDD pipeline, auditing test quality, or when the user says "/diagnose-tests", "audit my tests", "find placebo tests", or "how healthy are my tests?".
Merged Stage 1+2 — define success criteria, explore against real fixtures, validate, implement, and produce a forensic record. One continuous session with a checkpoint in the middle. Use when the user says "/drive-outcomes <plan-path>", "drive the outcomes for this phase", after /define-outcomes completes, or when a phase plan is already ready for ODD-driven implementation.
File a bug report or feature request for the rust-development-pipeline itself, with auto-gathered context from the current project and session. Use when the user says "/file-issue", "file a bug", "report an issue", "this is a pipeline problem", or encounters a pipeline defect during daily use.
Uses power tools
Uses Bash, Write, or Edit tools
Share bugs, ideas, or general feedback.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Use this agent when you need expert assistance with React Native development tasks including code analysis, component creation, debugging, performance optimization, or architectural decisions. Examples: <example>Context: User is working on a React Native app and needs help with a navigation issue. user: 'My stack navigator isn't working properly when I try to navigate between screens' assistant: 'Let me use the react-native-dev agent to analyze your navigation setup and provide a solution' <commentary>Since this is a React Native specific issue, use the react-native-dev agent to provide expert guidance on navigation problems.</commentary></example> <example>Context: User wants to create a new component that follows the existing app structure. user: 'I need to create a custom button component that matches our app's design system' assistant: 'I'll use the react-native-dev agent to create a button component that aligns with your existing codebase structure and design patterns' <commentary>The user needs React Native component development that should follow existing patterns, so use the react-native-dev agent.</commentary></example>
Access thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.
Upstash Context7 MCP server for up-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your LLM context.
A comprehensive Fortran development pipeline for Claude Code — orchestrates planning, code review, fix execution, and implementation through specialized agents and skills
LSP proxy that filters stale diagnostics for Rust, Python, and Fortran
Outcome-Driven Development pipeline for Claude Code — orchestrates planning, implementation with real build feedback, and review through specialized agents and skills. Language-agnostic with per-project configuration.
Routes Claude Code hook events to a Discord channel — approval requests, notifications, and session stop signals — with interactive Approve/Deny buttons. Also provides slash commands to inspect active sessions and conversation history.
Blocks bare find/grep in Bash calls and detects common rg flag misuse. Enforces fd/rg per CLAUDE.md. Shell file-read and file-edit blocking has moved to the no-shell-file-ops plugin.
A Claude Code plugin that provides a complete Rust development pipeline — from architectural planning through implementation with real compiler feedback, code review, and fix generation.
| Command | Description |
|---|---|
/define-outcomes | Interactive planning — helps you crystallize vague goals into concrete, falsifiable desired outcomes through Socratic grilling. Produces a PHASE_PLAN.md with goals, scope, and design notes. Recommended before /drive-outcomes when goals are unclear. |
/init-project [root] | Stage 0 — settles the repo constitution: domain language, architecture, dependency choices, coding patterns. Produces CONTEXT.md and ADRs. Run once per project before any other pipeline stage. |
/drive-outcomes [plan] | Core pipeline stage — Merged Stage 1+2: define success criteria grounded in real fixture files, validate by exploring against real data, implement on a branch with compiler feedback, and produce a forensic record. One continuous session with a checkpoint. The ODD cycle replaces TDD: every test assertion is anchored to ground truth external to the code under test. |
/debug-outcomes [symptom] | Debug stage — debug an existing fixture-anchored system that passes its acceptance test but produces wrong output. Classifies prior investigation notes (EXTERNAL/DERIVED/HYPOTHESIZED), establishes anchor criteria, applies upstream-audit rule, implements fix with discriminator-value tests, captures resolution. |
/diagnose-tests [path] | Migration diagnostic — scans a project's test suite for placebo patterns (vacuous assertions, circular round-trip, unbounded thresholds, synthetic-only data). Produces an audit report before adopting ODD stages. |
/make-judgement [tasks] | Cross-group validation against the original TASKS.md. Produces review.md and optionally fix-tasks.md for defects |
/file-issue | Files a bug report or feature request for the pipeline itself, with auto-gathered context |
| Agent | Role |
|---|---|
rust-architect | Senior Rust architect for design guidance, code review, and first-principles analysis |
implementation-executor | Implements delegated tasks on branches with compiler feedback, LSP-first navigation, and quality gates. Dual workflow: ODD outcome-driven cycle (criteria→explore→implement→refactor→verify) for lib-tdd tasks, edit→check→fix for direct tasks |
strict-code-reviewer | Verifies implementations against tasks and architecture; ground-truths every claim |
| Hook | Trigger | Purpose |
|---|---|---|
metrics_hook.py | PostToolUse (all tools) | Collects session metrics (tool calls, tokens, timing) for pipeline performance analysis |
The old pipeline used TOML before/after blocks with compiled sd scripts — a "mental dance" where LLM agents at every stage deduced code impact from static analysis alone, with no compiler feedback loop. This caused cross-task staleness, incorrect API usage, missing pub mod/pub use declarations, and recurring clippy violations.
The pipeline eliminates the mental dance. Implementation stages (/drive-outcomes Session B) operate on branches with the real compiler:
cargo check — the compiler tells the agent what's wrongcargo check passesThis means the compiler, not the LLM, is the source of truth for whether code works. The LLM provides architectural judgment and implementation guidance; the compiler validates the output.
Instead of specifying exact before/after byte-level replacements that go stale the moment any task shifts file content, tasks use descriptive guidance — what structs to define, what functions to add, which patterns to follow. The implementation agent reads current file state at implementation time, so staleness is impossible.
Implementation stages operate on feature branches with per-group sub-branches. Task artifacts (TASKS.md, checkpoints) are committed to the branch — interrupted sessions resume by reading the task definition and checking which groups are complete. All task groups run sequentially in a single session; auto-compress handles context management.