Awesome-omni-skill brutal-agent

Orchestrate subsystem-by-subsystem project hardening by combining brutal-project-review and task-worker in a strict loop: review one subsystem, create CRITICAL/MAJOR tasks, run all tasks to completion, then move to the next subsystem. Continue full review/task passes until a complete pass finds no new CRITICAL/MAJOR issues. Use when the user wants both deep subsystem review and autonomous task execution with no instruction loss.

install

source · Clone the upstream repo

git clone https://github.com/diegosouzapw/awesome-omni-skill

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/diegosouzapw/awesome-omni-skill "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/data-ai/brutal-agent" ~/.claude/skills/diegosouzapw-awesome-omni-skill-brutal-agent && rm -rf "$T"

manifest: skills/data-ai/brutal-agent/SKILL.md

source content

Run a strict orchestration loop that combines these two skills without dropping any instructions:

/home/user/.codex/skills/brutal-project-review/SKILL.md

/home/user/.codex/skills/task-worker/SKILL.md

Non-Negotiable Inheritance Rules

Read both source
```
SKILL.md
```
files in full before starting.
Treat every instruction in both source files as authoritative and preserved.
Do not summarize away, simplify, or omit any requirement from either source skill.
Only add orchestration logic for ordering. If there is tension, preserve source-skill behavior and use this skill only to decide sequence.

Orchestration Workflow

Step 0: Load Source Skills

Read:

/home/user/.codex/skills/brutal-project-review/SKILL.md

/home/user/.codex/skills/task-worker/SKILL.md

Keep their instructions active for the rest of execution.

Step 0.5: Load Project Target Context (Before Feature Planning)

Before planning any feature work, check for
```
TARGET.md
```
in the project root directory.
If
```
TARGET.md
```
exists, read it in full and treat it as required planning context.
Do not start feature planning until this check/read has been completed.

Step 1: Drain Existing Tasks First (Resume Safety)

If any task exists in either:

```
workspace/tasks/in-progress/
```
```
workspace/tasks/todo/
```

Run
```
task-worker
```
exactly as specified, until it reports no more tasks.
This prevents reviewing additional subsystems while previous findings remain unaddressed.

Step 1.5: Initialize Pass Tracking

Define a "pass" as reviewing all currently discovered subsystems to
```
done
```
once.

Read

.claude/review-state/manifest.json

and record:

```
pass_started_at
```

pass_baseline_tasks_created = len(tasks_created)

(use

if manifest does not yet exist)

Use this baseline to determine whether the pass discovered any new CRITICAL/MAJOR issues.

Step 2: Review One Subsystem

Run
```
brutal-project-review
```
exactly as specified.
Execute one full subsystem cycle (including report, task creation, manifest update, completion marking, and cleanup) for the next pending subsystem.

Step 3: Run All Tasks to Completion

Immediately run
```
task-worker
```
exactly as specified.

Let it process continuously until both are empty:

```
workspace/tasks/todo/
```
```
workspace/tasks/in-progress/
```

Respect all TDD, self-review, fix-loop, verification, state, and lifecycle requirements from
```
task-worker
```
.

Step 4: Loop Control

Check
```
brutal-project-review
```
manifest state.
If any subsystem remains pending, go back to Step 2.
If all subsystems are done:
- Compute
```
pass_new_tasks = len(tasks_created) - pass_baseline_tasks_created
```
  .
- If
```
pass_new_tasks > 0
```
  , start another pass:
  - Reinitialize pass tracking (Step 1.5)
  - Go back to Step 2
- If
```
pass_new_tasks == 0
```
  , go to Step 5.

Step 5: Final Drain and Completion Report

Run one final
```
task-worker
```
pass to ensure no residual tasks remain.
Stop only when this condition is true:
- Last complete pass produced
```
pass_new_tasks == 0
```
  (no new CRITICAL/MAJOR issues found)
Report completion summary:
- Passes executed
- New CRITICAL/MAJOR tasks created in last pass (
```
0
```
  )
- Subsystems reviewed (done/total)
- Remaining tasks (must be zero unless explicitly blocked/needs-human-review)
- Any blocked or needs-human-review tasks

Execution Contract

When this skill says “run

brutal-project-review

” or “run

task-worker

”, it means:

Apply the full, original instructions from each referenced source skill.
Preserve all required formats, severity definitions, state handling, history updates, commits, and review rigor.
Preserve all resume logic and guardrails from both skills.

This skill only defines the macro-ordering loop:

Review one subsystem
Run all tasks
When a full pass completes, repeat passes until no new CRITICAL/MAJOR tasks are created