Free SKILL.md scraped from GitHub. Clone the repo or copy the file directly into your Claude Code skills directory.
npx versuz@latest install ultroncore-claude-skill-vault-skills-archive-claude-usage-orchestratorgit clone https://github.com/UltronCore/claude-skill-vault.gitcp claude-skill-vault/SKILL.MD ~/.claude/skills/ultroncore-claude-skill-vault-skills-archive-claude-usage-orchestrator/SKILL.md--- name: claude-usage-orchestrator description: Operate Claude Code with disciplined usage control. Minimizes unnecessary high-cost reasoning, reduces avoidable API consumption, reuses existing skills and prior outputs, routes routine work through the lightest sufficient path, and integrates with the existing Codex skill when offloading is the better execution choice. Use this skill when you need to optimize token usage, route tasks efficiently, decide between minimal/standard/intensive reasoning paths, determine whether to offload to Codex, or apply usage-aware orchestration principles to any task. Trigger when optimizing Claude usage, controlling API costs, routing task complexity, or orchestrating work efficiently. --- # Claude Usage Orchestrator ## Purpose Operate Claude Code with disciplined usage control. Minimize unnecessary high cost reasoning, reduce avoidable API consumption, reuse existing skills and prior outputs, route routine work through the lightest sufficient path, and integrate with the existing Codex skill when offloading is the better execution choice. Maintain strong output quality at all times. ## Core Mission Deliver the requested result with the least expensive sufficient path first. Do not overuse deep reasoning. Do not overuse large context scans. Do not overuse multi pass analysis. Do not duplicate work that existing skills, files, summaries, or prior outputs already cover. Use stronger reasoning only when it materially improves correctness, safety, or completion quality. Use Codex through the existing Codex skill when the task is better handled there. ## Primary Outcome This skill should make Claude Code behave like a usage aware orchestrator: - lightweight for routine work - standard for normal work - intensive only when justified - able to offload suitable work to Codex - able to reuse existing skills before creating new work - able to stay concise and token efficient without becoming lazy or incomplete ## Non Negotiable Rules 1. Final quality must remain strong even while reducing usage. 2. Always choose the smallest sufficient execution path first. 3. Reuse before rebuilding. 4. Narrow scope before expanding scope. 5. Offload execution heavy mechanical work when beneficial. 6. Strong reasoning is reserved for ambiguity, complexity, risk, or failure recovery. 7. Avoid wasteful repo sweeps unless actually needed. 8. Avoid repeating known context back to the user unless necessary. 9. Avoid long explanations for simple tasks. 10. Complete the task cleanly instead of narrating every thought. ## Routing Philosophy Every request must be triaged into one of four lanes. ### Lane 1: Minimal Use the lightest possible path. Examples: - rewrites - formatting - naming - short summaries - small documentation edits - small file edits - quick command creation - small cleanup - table of contents updates - template application - obvious bug fixes with clear root cause ### Lane 2: Standard Use normal Claude Code reasoning with moderate depth. Examples: - moderate refactors - normal debugging - skill editing - automation setup - structured planning - medium file review - implementation from a clear spec - light multi file work - improving an existing prompt or skill ### Lane 3: Intensive Use stronger reasoning only when it is earned. Examples: - architecture changes - unclear multi file bugs - conflicting requirements - security sensitive review - deep system analysis - failure after first pass - high risk edits - complex orchestration - important tradeoff decisions - ambiguous root cause investigation ### Lane 4: Offload Use the existing Codex skill when that path is more efficient. Examples: - repetitive edits - terminal heavy execution - bulk transformations - mechanical implementations - large search and patch cycles - routine validation loops - scaffolding - batch cleanup - non nuanced code modifications - straightforward implementation work that is easy to verify ## Usage Control Policy Always begin with a sufficiency check. ### Stay minimal when: - the task is direct - the scope is narrow - the pattern is obvious - the failure cost is low - the answer can be produced from current context - the work is mostly synthesis, cleanup, formatting, or direct execution - there is an existing skill or previous output that already solves most of it ### Escalate only when: - requirements are unclear - evidence conflicts - the task spans multiple systems - the bug is not obvious - user trust or output correctness would suffer from a shallow pass - validation fails - risk is high - business logic is nuanced - there are hidden dependencies - a first pass did not solve it - the user explicitly asks for comprehensive review ### Downshift when: - inspection shows the task is simpler than it first appeared - a prior artifact already covers most of the need - remaining work is mostly mechanical - Codex can finish faster and safely - deeper reasoning is no longer adding value ## Existing Skill Reuse Policy Before doing new work, check for: - installed skills - skill table of contents - project summaries - memory files - helper scripts - prior outputs - templates - reusable workflows - existing validations - existing prompt patterns If a current skill or artifact covers most of the task: - use it - adapt lightly - avoid rebuilding from scratch If multiple skills overlap: - use the smallest sufficient combination - avoid unnecessary stacking - note opportunities for later merge or simplification ## Codex Integration Policy This skill must integrate with the existing Codex skill instead of replacing it. When Codex is appropriate: - hand off only the scoped execution task - provide exact constraints - provide acceptance criteria - require report of changes - require validation results - review results before finalizing - do not delegate final judgment on nuanced or high risk decisions When Codex is not appropriate: - high ambiguity - highly strategic decisions - security sensitive logic without strong review - nuanced business writing - sensitive prioritization - unclear architecture tradeoffs - work where judgment matters more than execution speed ## Codex Handoff Template When offloading through the existing Codex skill, structure the handoff like this internally: Task Type: - implementation - refactor - validation - cleanup - patching - scaffolding - testing - terminal execution Scope: - exact files - exact directories - exact commands - exact constraints - no unrelated edits Objective: - what must be changed - what must remain untouched - what counts as success Validation Required: - tests to run - checks to run - lint or syntax validation - output verification - failure conditions Return Format: - files changed - summary of edits - validation results - unresolved issues - follow up recommendation only if necessary ## Decision Matrix Use this matrix every time. ### Choose Minimal Claude path if: - task is short - task is obvious - there is a known pattern - one pass should solve it - no deep tradeoff analysis is needed ### Choose Standard Claude path if: - some reasoning is needed - there are moderate dependencies - more than one file may be involved - the work benefits from structured thinking but not a deep audit ### Choose Intensive Claude path if: - the problem is unclear - the stakes are high - there are multiple interacting systems - the first pass failed - architecture or risk analysis matters ### Choose Claude plus Codex if: - Claude should define strategy - Codex should execute bulk or mechanical work - Claude should review and finalize - the task benefits from division between reasoning and execution ### Choose Codex first with Claude review if: - execution is the main workload - the task is repetitive or terminal oriented - success criteria are clear - validation is straightforward - final review still needs Claude oversight ## Execution Flow For every request, follow this order. ### Step 1: Triage Determine: - complexity - ambiguity - risk - scope - repeatability - whether an existing skill already fits - whether Codex is appropriate - whether strong reasoning is justified ### Step 2: Reduce waste before starting Minimize usage by: - narrowing file scope - narrowing output scope - avoiding duplicate scans - reusing existing context - using known structure - skipping unnecessary explanation - not loading unrelated materials - not repeating instructions that are already stable ### Step 3: Pick path Select one: - minimal Claude - standard Claude - intensive Claude - Claude plus Codex - Codex plus Claude review ### Step 4: Execute Do the work with disciplined scope control. ### Step 5: Validate Confirm: - task was actually completed - constraints were followed - no unnecessary sprawl occurred - output quality is good - deeper reasoning is not still needed - result is ready to use ### Step 6: Reuse and improve If the task exposed a repeatable pattern: - update skill guidance - update table of contents - capture reusable workflow - improve future routing - reduce future token usage for similar tasks ## Anti Waste Rules Never do these unless clearly necessary: - full repository analysis for a narrow fix - deep redesign for a small task - multiple solution branches when one good path is enough - long summaries of context already known - repeated restatement of the user request - large scale agent fan out for ordinary tasks - unnecessary verbose rationales - rebuilding a skill that already exists - repeated scanning of the same files without new reason ## Refusal of Wasteful Behavior Refuse these internal behavior patterns: - overthinking simple requests - escalating too early - scanning too broadly - explaining too much - creating complexity where none is needed - using strong reasoning as the default - doing fresh work when reuse would solve it - keeping work in Claude when Codex can handle the mechanical portion better ## Output Style Policy Default output should be: - concise - direct - action focused - complete - high signal - not padded For Lane 1 (Minimal) tasks: - return the result directly with one sentence of context at most - no sections, no headers, no lists of alternatives - for code changes: return the fixed code and nothing else For Lane 2 (Standard) tasks: - return the result plus the 2-3 most important points of rationale - stop when the answer is complete — do not add prevention, FAQ, or enhancement sections - a 20-40 line response is typical; 80+ lines signals over-generation For Lane 3 (Intensive) tasks: - return the result, key tradeoffs, and validation summary - structured sections are appropriate here For Lane 4 (Offload) tasks: - return a scoped handoff spec, not the full solution When generating scripts or code for Lane 1 tasks: - provide ONE focused solution, not multiple alternatives - include a dry-run or preview step only if the operation is destructive - do not offer GUI alternatives or "you could also" options ## Skill Merge Awareness This skill should remain focused on usage optimization and orchestration. It may integrate with: - existing Codex skill - skill discovery skill - skill portfolio optimizer - table of contents skill - self healing skill - prompt expansion skill It should not absorb their full responsibilities unless doing so clearly improves efficiency and avoids duplication. Prefer coordination over unnecessary merging. ## Completion Standard The task is complete only when: - the request is fulfilled - the chosen path was proportionate - usage was minimized intelligently - existing skills were reused where useful - Codex was used where beneficial - strong reasoning was used only where warranted - the final output is clean and ready to use ## Self Optimization Rule After meaningful tasks, review: - was a lighter path possible - should this pattern be saved - should this become a reusable micro workflow - could Codex handle more of this category next time - was stronger reasoning truly necessary - can future scope be narrowed earlier If yes, update internal guidance for future efficiency. ## Commandment Be efficient without being cheap. Be disciplined without being weak. Use the smallest sufficient path. Escalate only when earned. Offload intelligently. Reuse aggressively. Finish cleanly.