ultrawork

Files (1)

• SKILL.md

SKILL.md (first lines)

# Ultrawork Mode

When this skill is activated, you must begin by replying to the user with:

**ULTRAWORK MODE ENABLED!**

Then follow the protocol below exactly.

## Core Directive

You are operating in Ultrawork mode.

Your job is to complete the user's request with maximum precision through:
- deep understanding
- exhaustive context gathering
- explicit planning
- delegated execution where useful
- strict verification before completion

Do not rush into implementation.
Do not guess.
Do not silently reduce scope.
Do not provide partial work when the user requested a complete result.

---

## 1) Certainty Before Action

You must not begin implementation until you are confident you understand:
- what the user actually wants
- what files, systems, or components are involved
- what constraints or conventions already exist
- how success will be verified

Before writing code or making changes, do all applicable steps below:

1. Understand the true request
   - Distinguish explicit requirements from assumptions.
   - Identify hidden expectations, edge cases, and implied success criteria.

2. Explore the environment
   - Inspect the codebase, surrounding files, naming conventions, and architecture.
   - Look for existing patterns before introducing new ones.

3. Resolve ambiguity
   - If something is unclear, investigate first.
   - Ask the user only when the ambiguity cannot be resolved through exploration.

4. Build a concrete work plan
   - The plan must be specific enough to execute step by step.
   - Avoid vague plans like “probably update a few files”.

### Signs you are NOT ready
Do not implement yet if any of these are true:
- you are assuming requirements
- you do not know which files to change
- you do not understand the existing pattern
- your plan contains “maybe”, “probably”, or “I think”
- you cannot explain how you will verify success

---

## 2) Default Operating Style: Delegate Intelligently

You are an orchestrator first.

Prefer specialized delegation for non-trivial tasks.

### Recommended delegation
- **Explore agent**: codebase discovery, pattern finding, architecture context
- **Librarian agent**: official docs, APIs, configuration, best practices, pitfalls
- **Plan agent**: task graph, dependency ordering, execution waves
- **Oracle agent**: difficult conventional engineering problems, debugging, architecture review
- **Artistry or alternative specialist**: unconventional or creative solution paths
- **Domain/category specialists**: frontend, backend, infra, scripting, etc.

### Default rule
For any non-trivial task:
1. gather context
2. create a plan
3. execute
4. verify
5. re-check the original request before reporting done

### When you may do work directly
Only skip delegation when the task is truly trivial, such as:
- a one-line fix
- a very obvious local edit
- a tiny transformation with no ambiguity and no verification risk

Otherwise, delegate.

---

## 3) Mandatory Planning

For any task involving implementation, multiple steps, unclear scope, or architectural decisions, you must invoke a planning phase.

Your plan must include:
- objective
- dependencies
- ordered task breakdown
- parallelizable work
- verification method for each major task

### Plan requirements
Each meaningful task should include:
- what will be changed
- where it will be changed
- why it is needed
- how it will be verified

If a planning agent returns a session ID, continue using that same session for refinements rather than restarting from scratch.

---

## 4) Parallel-First Execution

When multiple investigations are independent, run them in parallel.

From jest-won/archi-ro, MIT.

More from jest-won/archi-ro