Quick Ultra Operator

Combine multiple Claude Code operations into a single ultra-powered workflow that reads context, analyzes code, implements changes, runs tests, and prepares a commit in one shot.

When to Use This Command

Run this command when...

• You want to go from a task description to a tested, staged solution in one command
• You need to chain multiple operations (analyze, implement, test, commit) without manual steps
• You are in a time-sensitive situation and want maximum automation end-to-end

Avoid this command when...

• You want to review and approve each step before it proceeds to the next
• The task is ambiguous and requires interactive clarification during execution

Quick Start

Copy
# .claude/commands/quick-ultra-operator.md
---
allowed-tools: ["Bash", "Read", "Write", "Edit", "Glob",
  "Grep", "WebSearch"]
---
Execute the full workflow: load context, analyze requirements,
implement changes, run tests, prepare commit. Report each step.

Example usage:

/quick-ultra-operator "Add rate limiting to /api/search with 100 requests per minute per IP"

Example output:

Ultra Workflow
==============
Step 1: Context loaded (Next.js + Express API)
Step 2: Analyzed /api/search (src/api/search.ts)
Step 3: Implemented rate limiter middleware
Step 4: Added unit tests for rate limiting
Step 5: All tests passing (47/47)
Step 6: Changes staged, commit message drafted

Files changed:
  A src/middleware/rateLimiter.ts
  M src/api/search.ts
  A src/api/search.test.ts

Ready to commit: "Add IP-based rate limiting to search API"

Core Concepts

Concept	Description
Pipeline execution	Runs a multi-step workflow from analysis to verification
Context loading	Reads project structure and conventions before implementation
Implementation	Writes code following detected project patterns and conventions
Verification	Runs tests and linting before declaring the task done

Task --> Load Context --> Analyze --> Implement
                                         |
                                    Write Tests
                                         |
                                    Run Tests
                                         |
                                  PASS? --> Stage + Draft Commit
                                    |
                                    No --> Fix & Retry

Configuration

Option	Default	Description
steps	all	Which steps to include (analyze, implement, test, commit)
auto-commit	false	Commit automatically if all tests pass
retry	1	Number of fix-and-retry cycles if tests fail
verbose	true	Show detailed output for each step
skip-tests	false	Skip the test verification step (not recommended)

Best Practices

1. Be specific in your task description -- "add rate limiting with 100 req/min per IP" is far better than just "add rate limiting."
2. Review the diff before committing -- even in ultra mode, always review what Claude changed.
3. Do not skip tests -- the verification step catches real issues before they reach the repository.
4. Use for well-scoped tasks -- ultra mode works best when the task is clear and bounded.
5. Keep auto-commit off -- let Claude stage changes but make the commit decision yourself.

Common Issues

1. Task too vague -- ultra mode cannot pause to ask clarifying questions. Be precise in the task description.
2. Test failure retry loop -- if tests keep failing after the retry limit, the task may need human intervention or different approach.
3. Unexpected file changes -- the pipeline may modify files you did not expect. Always review all changed files, not just the obvious ones.