Selecting Agents

Overview

Use the right agent for the job. Each agent is optimized for specific scenarios and follows a focused workflow.

This skill helps you choose which specialized agent to use based on the task at hand.

For automatic agent selection: When executing implementation plans, use the /execute command which applies this skill's logic automatically with hybrid keyword/LLM analysis. Manual selection using this skill is for ad-hoc agent dispatch outside of plan execution.

Documentation Agents

technical-writer

When to use: After code changes that affect documentation

Scenarios:

• Updated API endpoints, added new features
• Changed configuration options or environment variables
• Modified architecture or system design
• Refactored code that impacts user-facing docs
• Added new commands, tools, or workflows

Skill used: maintaining-docs-after-changes

Command: /doc-review

Key characteristic: Reactive to code changes - syncs docs with current code state

retrospective-writer

When to use: After completing a feature, task, or significant work session

Scenarios:

• Finished implementing a feature
• Completed a complex debugging session
• Wrapped up a refactoring effort
• Solved a difficult problem
• Learned something valuable during development

Skill used: capturing-learning (potentially writing-retrospectives)

Command: /summarise

Key characteristic: Reflective after completion - captures decisions, lessons, insights

Debugging Agents

ultrathink-debugger

When to use: Complex, multi-layered debugging requiring deep investigation

Scenarios:

• Production failures with complex symptoms
• Environment-specific issues (works locally, fails in production/CI/Azure)
• Multi-component system failures (API → service → database)
• Integration problems (external APIs, third-party services)
• Timing and concurrency issues (race conditions, intermittent failures)
• Mysterious behavior resisting standard debugging

Skills used: systematic-debugging, root-cause-tracing, defense-in-depth, verification-before-completion

Key characteristic: Opus-level investigation for complex scenarios, not simple bugs

Development Agents

rust-engineer

When to use: Rust development tasks requiring TDD and code review discipline

Scenarios:

• Implementing new Rust features
• Refactoring Rust code
• Performance optimization
• Systems programming tasks
• Any Rust development work

Skills used: test-driven-development, testing-anti-patterns, code-review-reception

Key characteristic: Enforces TDD, mandatory code review, project task usage

code-reviewer

When to use: Reviewing code changes before merging

Scenarios:

• Before completing feature implementation
• After addressing initial feedback
• When ready to merge to main branch

Skill used: requesting-code-review

Key characteristic: Structured review process with severity levels

Common Confusions

Selection Examples

Scenario 1: Added new API endpoint → technical-writer - Code changed, docs need sync

Scenario 2: Spent 3 hours debugging Azure timeout → retrospective-writer - Capture the investigation, decisions, solution

Scenario 3: Both apply - finished user authentication feature → technical-writer first - Update API docs, configuration guide → retrospective-writer second - Capture why you chose OAuth2, what issues you hit

Scenario 4: Random test failures in CI → ultrathink-debugger - Complex timing/environment issue needs deep investigation

Scenario 5: Simple bug fix in Rust → rust-engineer - Standard development workflow with TDD

Remember

• Most completed work needs both documentation agents (technical-writer for code sync, retrospective-writer for learning)
• Use technical-writer when code changes
• Use retrospective-writer when work completes
• Use ultrathink-debugger for complex debugging (not simple bugs)
• Use rust-engineer for all Rust development
• Use code-reviewer before merging