Severity-adaptive display:
- Errors — prominent, always shown
- Warnings — subtle, collapsed by default
- Clean — minimal success indicator
cargo fmt, clippy, cargo check, and deep LSP analysis — in one composable package.
Built by samschillace in an Amplifier session · February 2026
Rust developers had semantic code intelligence — but the rest of the Rust workflow was stuck outside the agent.
Go-to-definition worked, but no way to run cargo fmt, clippy, or cargo check through the agent.
Edit a file, introduce a type error — no feedback until you leave the agent and run cargo check yourself.
Understanding architecture meant text search. No trait tracing, no call hierarchies, no semantic depth.
Persistent rust-analyzer with warm server, custom extensions, and all 14 LSP operations.
rust_check tool + auto-check hook. Every .rs edit triggers quality analysis automatically.
Composite bundle — includes both. Plus two expert agents: rust-dev and code-intel.
One call. Four checks. Structured output with file, line, code, message, and severity.
// Check a file
rust_check({ "paths": ["src/main.rs"] })
// Check entire project
rust_check({ "paths": ["."] })
// Run specific checks only
rust_check({ "paths": ["src/"], "checks": ["lint", "types"] })Catches incomplete code before it ships:
todo!() // caught
unimplemented!() // caught
unreachable!() // caught
// TODO // caught
// FIXME // caught
// Smart exemptions:
unreachable!() in match arms → OK
todo!() in test files → OKZero false positives. Tested against real-world Rust codebases — not synthetic examples.
The code-intel agent uses LSP to trace the shape of a codebase — traits, implementations, call hierarchies, and design patterns.
// Real output: unified-llm-rust analysis
4 architectural layers mapped
├─ Core traits: Provider, ModelProvider, StreamingProvider
├─ Adapter layer: 5 ProviderAdapter implementations
├─ Streaming model: chunked response → Stream<Item=Result<Chunk>>
└─ Entry point: generate() ← 35 callers traced
Design pattern detected:
Explicit BoxFuture return types over #[async_trait]
→ Better control over Send bounds and performanceWrite or edit a Rust file — the hook fires cargo fmt, clippy, and cargo check in the background. Results appear inline with severity-adaptive display.
Severity-adaptive display:
Edit 1: 3 errors, 2 warnings
E0308: mismatched types
E0599: no method named `foo`
E0425: cannot find value `bar`
Edit 2: 2 warnings (errors fixed ✓)
clippy::unused_variable
Edit 3: ✓ CleanThe rust-analyzer server stays alive for 5 minutes between calls. First call starts the proxy — every call after that is instant.
First Call
Server startup + workspace indexing
Subsequent Calls
Server already warm, cached analysis
// Server lifecycle
Call 1 → start_proxy() → rust-analyzer boots → response
Call 2 → proxy alive → instant → response
Call 3 → proxy alive → instant → response
...
5min → idle timeout → server shutdown → clean exitThree rust-analyzer specific extensions — available via the customRequest operation.
See what derive(Debug) or vec![] actually expand to. Invaluable for debugging proc macros.
Find all test functions that exercise a given function or module. Trace test coverage without running anything.
Get docs.rs links for any symbol. Jump from code to documentation in one operation.
⚠ Note:
Custom extensions work with standalone rust-analyzer builds. The rustup component build has limited extension support — this is a known upstream limitation, clearly documented in the bundle.
Every LSP operation tested against real Rust codebases and confirmed working.
Full architectural map produced. All trait hierarchies traced, module boundaries identified, public API surface documented.
Streaming model documented, 5 ProviderAdapter implementations found, design patterns identified automatically.
✓ All 14 LSP operations verified working
hover · goToDefinition · findReferences · diagnostics · incomingCalls · outgoingCalls · documentSymbol · inlayHints · goToImplementation · rename · codeAction · workspaceSymbol · prepareCallHierarchy · customRequest
Every claim in this deck traces back to source code, test results, or direct observation in Amplifier sessions.
Data as of: February 20, 2026
Add the bundle. Write Rust. Get instant feedback.
# Full experience (LSP + quality + agents)
amplifier bundle use git+https://github.com/microsoft/amplifier-bundle-rust-dev@main#subdirectory=behaviors/rust-dev.yaml --app
# Just LSP (rust-analyzer navigation, no quality hooks)
amplifier bundle use git+https://github.com/microsoft/amplifier-bundle-rust-dev@main#subdirectory=behaviors/rust-lsp.yaml --app
# Just quality checks (cargo fmt/clippy/check, no LSP)
amplifier bundle use git+https://github.com/microsoft/amplifier-bundle-rust-dev@main#subdirectory=behaviors/rust-quality.yaml --app