# Workflow

> Run the full minmaxing workflow end to end for one request. Use when the user wants planning, implementation, verification, and closeout to happen automatically in one command.

- **Type:** Skill
- **Install:** `agentstack add skill-waitdeadai-minmaxing-workflow`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [waitdeadai](https://agentstack.voostack.com/s/waitdeadai)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [waitdeadai](https://github.com/waitdeadai)
- **Source:** https://github.com/waitdeadai/minmaxing/tree/main/.claude/skills/workflow

## Install

```sh
agentstack add skill-waitdeadai-minmaxing-workflow
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# /workflow

Run the full workflow for:

$ARGUMENTS

This command is the end-to-end executor.

`/opusworkflow` is the default outer route for normal build/plan work and for
mutating specialist work in this harness. It reuses this `/workflow` lifecycle
while adding the Claude/Opus planner-reviewer plus MiniMax-M2.7-highspeed
executor split. Use plain `/workflow` only when the user invokes it explicitly,
the provider split is unavailable, or the work should stay in one local
supervisor loop.

When a specialist route changes files, keep `/opusworkflow` as the outer route
and record the specialist as `inner_contract=agentfactory|hiveworkflow|parallel|defineicp|deepretaste|demo|visualizeworkflow`.

`/digestflow` is a sibling route that reuses this same inline lifecycle after an external report-intake prelude. Normal `/workflow` behavior stays unchanged when no external research reports are supplied.

## Non-Negotiable Contract

- Finish the task in this command whenever it is feasible.
- For file-changing work, follow this order: deep research -> code audit -> plan -> `SPEC.md` -> Spec QA -> execute -> verify.
- Do efficacy-first deep research for every task before planning or execution.
- Audit the current codebase before planning or writing `SPEC.md`.
- Run hard-gate introspection after code audit and before freezing the plan.
- Synthesize a concrete plan before writing `SPEC.md`.
- Record an `Agent-Native Estimate` before writing, replacing, or reusing
  `SPEC.md`. The estimate must be agent-native wall-clock by default, not a
  bare human-equivalent calendar estimate.
- After `SPEC.md` is created, updated, or intentionally reused, run `/specqa`
  before implementation. Spec QA is the SOTA/currentness and requirements
  quality gate for the active spec, not a post-implementation review.
- Run hard-gate introspection after implementation and before closeout.
- Record a parallel-aware metacognitive route before research planning for
  file-changing work: task class, capacity evidence, effective parallel budget,
  chosen route, required evidence, confidence threshold, and why the full
  parallel ceiling was or was not used.
- Treat worker or subagent summaries as claims until the parent workflow
  verifies them with command evidence. For harness-governance changes, run the
  effectiveness smokes that apply: `scripts/harness-scorecard.sh --json`,
  `scripts/hook-smoke.sh`, `scripts/codex-run-smoke.sh`, and
  `scripts/parallel-plan-lint.sh --fixtures`.
- When a workflow uses `/parallel` run artifacts, aggregate
  `.taste/parallel/{run_id}/packet-dag.json`, `ownership.json`, and
  `worker-results/*.json` with `scripts/parallel-aggregate.sh` before treating
  worker outputs as accepted evidence.
- Keep implementation surgical: smallest sufficient implementation, no speculative abstractions, no drive-by refactors, and a changed-line trace back to `SPEC.md`.
- Do not stop after planning.
- Do not tell the user to manually run `/autoplan`, `/parallel`, `/sprint`, `/verify`, or `/ship`.
- Do not rely on nested custom-skill chaining as the primary execution path.
- Keep plain `/workflow` autonomous. Do not insert a mandatory visualization
  approval pause into this command. When the user explicitly wants to see and
  approve the intended product or operator experience before implementation,
  route that request to `/visualizeworkflow` instead.

Reason:
In real Claude Code sessions, nested custom skills may complete their own turn and return control to the user before the rest of the chain runs. For `/workflow`, execute the phases inline with Claude Code tools so the full flow actually completes.

You may still use built-in Claude Code tools, shell commands, subagents, and optional specialist skills as reference material when useful, but `/workflow` itself owns the whole lifecycle.

No shortcut exceptions for file-changing tasks:
- Do not say `Research: skipped`.
- Do not say `Code Audit: skipped`.
- Do not say `SPEC.md: not needed`.
- Do not treat "trivial", "tiny", "single-file", or "local-only" as exceptions.
- If you are about to skip one of these phases, stop and complete the missing phase instead.

Research brief is mandatory:
- If `mcp__MiniMax__web_search` is available in the tool list, you MUST use it before planning, explaining, auditing, or editing.
- Use `mcp__MiniMax__web_search` as the primary external research tool when it is available.
- Fall back to Claude Code `WebSearch` only if the MiniMax MCP is unavailable.
- Deep research must follow the repo’s effectiveness-first `deepresearch` protocol rather than a generic search fan-out: start with a collaborative research plan, run an iterative search -> read -> refine loop, maintain a source ledger, resolve conflicting evidence, and do follow-up research before freezing the plan.
- Treat `MAX_PARALLEL_AGENTS` as a ceiling, not a quota.
- Choose an effective research budget based on the number of distinct questions that materially affect the plan.
- If the task is purely local and does not depend on current external facts, a concise local-only research brief is acceptable, but you must say why no external search was needed.
- Build a research brief before any code audit synthesis, spec creation, or code changes.
- Write a workflow artifact for file-changing tasks so the reasoning trail is inspectable.
- Hard-gate introspection must name likely mistakes, cite evidence checked, downgrade confidence when warranted, and block closeout when unresolved findings remain.
- Re-check any concrete library, framework, API, or error details again right before editing if the plan depends on them.
- If the plan depends on Claude product behavior, run the `/claudeproduct`
  protocol inside the research brief first. Separate current official
  Anthropic/Claude docs from local harness contracts before freezing the plan.

## Phase 0: Taste Gate

1. Check whether `taste.md` and `taste.vision` exist in the project root.
2. If they do not exist:
   - stop before research, audit, planning, or edits
   - tell the user that fresh repos must start with `/tastebootstrap`
   - do not ask the bootstrap questions here
   - do not write `taste.md` or `taste.vision` from inside `/workflow`
   - resume `/workflow` only after the kernel is defined
3. Read `taste.md` and `taste.vision`.
4. Rehydrate current working state if it exists:

```bash
bash scripts/state.sh status 2>/dev/null || true
```

Treat `.minimaxing/state/CURRENT.md` as a compact continuity handoff, then reconcile it with live `git status`, `SPEC.md`, and the latest workflow artifact before editing.

5. Recall memory for the task:

```bash
bash scripts/memory.sh recall "$ARGUMENTS" --depth medium 2>/dev/null || echo "Memory recall skipped"
bash scripts/memory-eval.sh --summary 2>/dev/null || echo "Memory freshness: unavailable; using local truth surfaces"
```

6. Summarize:
   - relevant taste principles
   - relevant working-state continuity and any stale assumptions to refresh
   - relevant recalled memories
   - memory health/freshness status and whether local truth surfaces are the
     fallback
   - an alignment score from 0 to 10
7. If the task clearly conflicts with taste, pause only to get an explicit alignment decision from the user.

If memory is `degraded`, `disabled`, or unavailable, continue from local truth
surfaces (`SPEC.md`, workflow artifacts, docs, git status, tests, and source
files) and say that memory could not be trusted as the primary context source.
Do not claim memory captured everything unless a memory event trace or durable
memory artifact proves the relevant entry exists.

## Phase 1: Route

Choose the route from user intent:

| Intent | Workflow Behavior |
|--------|-------------------|
| build, implement, create, add, refactor, optimize, migrate | run full research → audit → plan → spec → execute → verify → closeout flow |
| fix, debug, investigate | research first, audit the relevant code path, then reproduce/fix/verify; create `SPEC.md` if files change |
| audit, analyze, understand, deepresearch, webresearch | inspect deeply, report findings, make fixes only if the user asked for them |
| deepretaste, retaste, detect intent, bootstrap taste and ICP, SOTA customer research for taste | route through `/opusworkflow` with `inner_contract=deepretaste` when files may change; preserve `/deepresearch` as the general research route when findings will not mutate taste |
| define ICP, ideal customer profile, tailor taste to customer, update taste.md or taste.vision from ICP | route through `/opusworkflow` with `inner_contract=defineicp` when files may change; keep proposal-first unless explicit apply approval is present |
| Claude product, Claude Code, Claude.ai, Anthropic API, connectors, plugins, skills, hooks, MCP, subagents, plan availability, limits, setup | route product facts through `/claudeproduct` before generic research; continue into `/workflow` only if files change |
| remote control, rc, continue Claude Code from phone, claude.ai/code local session | route to `/remote-control`; use native Claude Code RC commands only (`/remote-control`, `/rc`, `claude --remote-control`, `claude remote-control`) and never build a custom control server |
| opus solo, opusolo, all opus, opus for everything, max effort opus | route through `/opusolo` when the operator explicitly wants the all-Opus premium sibling of `/opusworkflow`; keep the same gates and runtime-identity proof rules |
| goal mode, native /goal, /goal , keep working until, bounded continuation | route to `/goal-mode` for static readiness, Goal Assist copy-paste templates, and no-shadow diagnostics; use native `/goal ` manually only around already-known failed gates with owned scope, forbidden paths, transcript evidence, stop bounds, and parent verification, never as `/workflow`, `/parallel`, or `/verify` replacement |
| spec QA, spec review, specification QA, SOTA spec audit | route to `/specqa`; review the active `SPEC.md` after creation/update/reuse and before implementation, using current webresearch when SOTA or time-sensitive facts matter |
| parallel, mode parallel, dense workflow, orchestrate subagents, split across instances | route through `/opusworkflow` with `inner_contract=parallel` for file-changing packet execution; run the `/parallel` eligibility audit and use packets only when capacity, ownership, and verification pass |
| hive, hive mind, coordinated agents, swarm, multi-agent synthesis | route through `/opusworkflow` with `inner_contract=hiveworkflow` for file-changing hive work only when roles, blackboard, dissent, ownership, capacity, and verification pass; otherwise downgrade to `/workflow` or `/parallel` fallback |
| explain | inspect and explain directly |
| review | review directly |
| qa | run focused validation directly |
| visualize, visual approval, show me first, approve before implementation | route to `/visualizeworkflow` for approval-first planning; after approval, continue implementation through `/opusworkflow` with `inner_contract=visualizeworkflow`; route to `/visualize` when the user only wants a comprehension artifact |
| SPEC.md requests generated images, edited images, hero assets, UI mockups, sprites, thumbnails, or product raster assets | keep the normal `/workflow` contract, but route the asset generation lane through Codex skill `codex-imagegen` under `.agents/skills`; use Codex subscription/ChatGPT auth when available, never API-key image generation unless the user explicitly changes billing route |

Default to the full build flow when the task changes files.

If a normal `/workflow` task has high visual or product-experience ambiguity,
you may mention that `/visualizeworkflow` exists for approval-first execution,
but continue autonomously unless the user asked for that approval pause.

For dense work, automatically consider `/parallel` even if the user did not
name it. Use it only when the eligibility audit proves independent packets,
clear ownership, host capacity, and a verification path. Downgrade to normal
inline `/workflow` when those conditions fail.

For hive-like work, automatically consider `/hiveworkflow` when the request
needs coordinated roles, a blackboard, dissent/conflict handling, synthesis, and
verified learning. Prefer `/parallel` when disjoint execution packets are enough;
prefer `/hiveworkflow` only when judgment breadth and role coordination are part
of the value. For file-changing hive work, run it under `/opusworkflow` as
`inner_contract=hiveworkflow`. Downgrade to local `/workflow` if role map, blackboard,
ownership/locks, capacity, or verification cannot be written clearly.

Before freezing the route for file-changing work, perform a compact
metacognitive route check. Use `scripts/parallel-capacity.sh --json` when
available, treat `MAX_PARALLEL_AGENTS`, Codex `max_threads`, and hardware
ceiling as ceilings, and compute the smallest useful effective budget:

```text
effective_metacognition_budget =
  min(MAX_PARALLEL_AGENTS, codex_max_threads, hardware_recommended_ceiling,
      independent_questions_or_packets, supervisor_capacity, verifier_capacity)
```

Do not fill the parallel pool for theater. Do not claim max agents means max
quality or linear speedup.

The metacognitive route is not an introspection pass. It must appear in the
workflow artifact before `## Research Brief`, and the later `## Introspection`
section must still record the required `/introspect pre-plan` and
`/introspect post-implementation` gates for file-changing work.

## Workflow Artifact

For file-changing tasks, create a durable workflow record before writing `SPEC.md`:

```bash
mkdir -p .taste/workflow-runs
STAMP="$(date +%Y%m%d-%H%M%S)"
WORKFLOW_ARTIFACT=".taste/workflow-runs/${STAMP}-workflow.md"
```

This artifact is the inspectable audit trail for the run. It must be created before `SPEC.md` and updated as phases complete.

Required section order:

```markdown
# Workflow Run: [task]

## Task
## Taste Gate
## Metacognitive Route
## Research Brief
## Code Audit
## Introspection
## Plan
## Agent-Native Estimate
## SPEC Decision
## Spec QA
## Plan Mode Approval
## Execution Notes
## Verification Evidence
## Outcome
```

Keep it concise, but do not skip sections. For non-file-changing analysis tasks, this artifact is optional.

Required content inside the sections:
- `## Metacognitive Route` must record the task class, capacity evidence,
  effective parallel budget, chosen route, evidence required, confidence
  threshold, and why the full parallel ceiling was or was not used. It must
  explicitly state when the route downgrades from `/parallel` to local
  `/workflow` because packets overlap or verification cannot aggregate results.
  It must not claim that `/metacognition` replaces or satisfies required
  `/introspect` gates.
- `## Research Brief` must record the investigation mode, collaborative research plan, effective research budget, iterative search -> read -> refine loop, source ledger, conflicting evidence, and any follow-up research required before planning.
- `## Introspection` must record at least `pre-plan` and `post-implementation` entries for file-changing work, plus `after-test-failure` or `pre-push` entries when those triggers occur.
- `## Plan` must record any delegated packets, their owners, and their dependencies when parallel execution is likely.
- `## Agent-Native Estimate` must record estimate type, execution topology,
  capacity evidence, effective lanes, critical path, agent wall-clock,
  agent-hours, human touch time, calendar blockers, confidence, and any
  human-equivalent baseline as secondary only.
- `## Spec QA` must record `/specqa` decision, requested reviewer model,
  proven reviewer model if any, `spec_qa_model_identity_status`, current
  webresearch source ledger when SOTA/time-sensitive claims matter, critical
  finding count, improvement suggestions, artifact paths, and whether execution
  is allowed.
- `## Plan Mode Approval` must record the `/opusworkf

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [waitdeadai](https://github.com/waitdeadai)
- **Source:** [waitdeadai/minmaxing](https://github.com/waitdeadai/minmaxing)
- **License:** Apache-2.0

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-waitdeadai-minmaxing-workflow
- Seller: https://agentstack.voostack.com/s/waitdeadai
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.