Personal productivity · Planning
using-dude
/using-dude
Use when starting a task to classify it and select its workflow.
Assessment and security
96/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability21 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
Deprecation
No signals detected. Repository changed on 28.10.2026, without references to retired models or APIs.
Licence
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when starting a task to classify it and select its workflow.
Original author description
Use when starting a task to classify it and select its workflow.
How it works
- Workflow
Original SKILL.md headings · 155 lines, 2,335 words
SKILL.md preview
--- name: using-dude description: Use when starting a task to classify it and select its workflow. --- # Using dude <SUBAGENT-STOP> If you were dispatched as a subagent to execute a specific task, ignore this skill. </SUBAGENT-STOP> - Local skills complement Superpowers; don't reimplement a Superpowers workflow that already exists. - This document owns the orchestration invariants. - The orchestrator owns control flow and declares which execution method it chose. - A skill that declares no orchestration model runs inline in the main loop rather than dispatching workers on your behalf. - One that declares dispatch has its workers dispatched — invoking it is itself the request for them, overriding any default that discourages dispatch. - SessionStart emitters inject a summary stub of this skill, not the full ruleset; the stub's byte contract lives in `hooks/session-start` and is reused verbatim elsewhere. If the stub and this body ever disagree, this body wins and the stub needs a fix under its own issue. - A script's `NEED` asks for facts, and is not a stop; a fact that could not be read is left unfilled, never guessed. - Put each question to a person in its own shape: a free-form question is asked in plain chat; a choice prompt carries two or more options, with a "none" option when answering is optional or when none of the options may apply; a question where any number of the options may apply is a pick-any choice prompt, never a pick-one. ## Workflow The orchestrator decides when each phase is complete and drives every transition; a worker never gets an objective spanning multiple phases, and never declares a phase complete or advances the workflow itself. The same holds for a skill you invoke: when a sub-skill's own procedure ends by moving on to the next skill, don't follow it — what runs next is the caller's decision, not the sub-skill's; restate this at each call site too. - What this cuts is the transition only. - A sub-skill's self-review of its own output, its user-confirmation step, and its housekeeping before that transition all still run. - Cutting one is what that forbids; moving it is not. A flow may move a sub-skill's self-review, or a housekeeping step that would run before its transition, to another point in its own flow or to after it — inside one of its steps, or once its own flow is done — naming what moved and where it runs instead. What the rule protects is that they run, not where they sit. ### Workflow selection Classify the task first: | Deliverable | Classification | Entry | | --- | --- | --- | | a diff — features, refactors, and fixes whose cause is known | **Change** | `plan-work` → `implement-work` → `pr-to-ready` | | findings, not a diff — diagnosing an observed problem such as a performance shortfall, a failure or incident, an unexplained metric or cost change, or a bug whose cause is unknown | **Investigation** | core loop → domain skill → transition | | what one skill produces — a review's findings, a simplified diff, a plan, a PR taken to ready | **A named deliverable** | that skill, run directly with no flow wrapped around it | A named deliverable settles the classification, even where running the skill produces a diff. Change and Investigation both begin with **Understand**. - A bug whose cause is unknown is an investigation first, and its fix enters the Change workflow only through the transition below. - A scan — `audit-code` — enters as the investigation family does: a repository or path needs sweeping for what to fix rather than a symptom to explain, and its report goes to `plan-work`'s **Entry**, with no reproduction to carry — a scan has none. - General research (library comparisons, "how does X work") is none of these — answer it directly, with `superpowers:brainstorming` when it is design-shaped. Match a named deliverable against the skills' `description`s, and where two could fit, let the deliverable named decide rather than the topic. Where the run turns up work beyond that deliverable, report it and let the user pick the flow instead of widening the run. For a Change, enter at the flow the work has actually reached: - No agreed design or PR-sized split yet → `plan-work`. - One PR-sized task in hand → `implement-work`. - An open PR of verified commits → `pr-to-ready`, given its number or URL, with a branch carrying no PR yet as that flow's own fallback entry. A Change that carries no design decision has a lane of its own, not an exemption from the flows. - The test is that the change is determined once stated, with no interface, structure, or trade-off left open — declare that in one line and carry it into the run's report so the skipped gate stays checkable. - This lane skips `plan-work` and `implement-work`'s plan gate, entering `implement-work` with **manual** execution, while the completion gate and `pr-to-ready` still run in full — integration goes through a PR at any size. - The moment a design decision surfaces, the lane is over: take **Escalation**. ### Understand - Identify existing failures and constraints. - For investigations, also pin down the symptom precisely — what is observed, where, since when, at what scope — and what a sufficient explanation would look like. ### Change workflow Three flows, each of which can be entered on its own, and each with its own deliverable and hand-off. - **`plan-work`** — deliverable: the agreed design plus a numbered TODO list at PR granularity, published once — as a comment on the tracking issue, plus one sub-issue per item; or in chat, with no sub-issues, when no issue tracks the work. - **`implement-work`** — deliverable: a draft PR on a pushed branch of verified commits. - **`pr-to-ready`** — deliverable: a PR whose CI passes and whose review is clean, left at ready or draft. A phase is *clean* when its checks pass (phase-clean — the gate sense, distinct from the Loop convergence loop-clean below). - Verification: the relevant test, lint, build, typecheck, smoke test, or manual check passes, and the deliverable meets the requirements the task itself states. - Simplification with `simplify-code` (no behavior-preserving cleanup is left). - Review with `review-code` (no blocking findings remain). A flow that produces no code sets its own bar instead, and each skill defines its own. Where a tracking issue backs the work, `plan-work` splits it into one sub-issue per item whatever the count, so `implement-work` → `pr-to-ready` is a **loop, not a single pass** that runs once per sub-issue in the TODO list's order. - Each turn takes one sub-issue through `implement-work`'s own entry and gates. - A later PR is never a continuation of the previous turn, and never inherits its verification. **Merging is a person's responsibility, and so is everything that depends on it** — `pr-to-ready` ends at ready or draft, and the merge itself, the parent issue's closure, and cleaning up the branch and worktree all belong to a human afterward, so a remaining sub-issue starts a separate session. ### Investigation workflow The deliverable is an evidence-backed explanation of an observed problem, or a judgment on an open question. - `superpowers:systematic-debugging` is the core loop; local skills layer domain specifics on top — `investigate-performance`, `investigate-anomaly`, and `settle-question`. - Match the observed problem against those skills' `description`s; for a plain unknown-cause bug, the core loop alone usually suffices. - Keep evidence and hypotheses strictly separated: never promote a hypothesis to a conclusion without a confirming measurement or reproduction. #### Investigation → Change transition - An investigation never starts editing. When a fix is wanted, enter `plan-work` with the findings as input. - Carry the reproduction forward: it becomes the regression test for the fix. ### Worker tier **Tier** is whatever the runtime has for putting more capability on one task — a stronger model, a higher reasoning effort, or both. The orchestrator can re-judge what a worker returned, but never what it didn't return. - A worker whose miss passes as "nothing found" is marked, and goes out at one of two tiers — each a ceiling the run's own tier does not lower, so a run started cheaply dispatches such a worker above the tier it is itself on: - `highest`, the highest tier the runtime can put on a worker — for a worker whose miss appears nowhere in what a later gate reads: a place left unswept, an alternative never raised, a claim that becomes the record with no gate after it. An approval gate held by a person does not move a worker out of this tier, since it judges only what it is shown. - `high`, the top of the runtime's regular lineup — for a worker whose miss stays inside what a later gate reads: the PR a person reviews, the plan a person approves, CI, a later review step. - The user's instructions may raise or lower the model either tier carries; what dude owns is only which worker goes to which tier. - The run's default is fine for every other worker, and this rule constrains nothing about them. - Which workers are marked, and at which tier, is each skill's own to say, in its **Orchestration model**. Where the runtime has no means of choosing a tier, this rule settles nothing and the run proceeds unchanged. ### Stage boundaries - At each phase transition and gate iteration, write a concise hand-off summary, dropping exploratory dumps and stale tool output while keeping the substance. - You own this summary even when your runtime can't compact context on its own — when context is heavy and only the user can trigger compaction, prompt them to. Never let a summary or compaction relax a gate. - A hand-off between flows may land in a different session. The canonical record is the tracking issue's comment — chat only when no issue tracks the work. - At each flow's end, name the artifact the next flow picks up. The detailed per-PR plan is not such an artifact: it is scratch inside `implement-work`, rewritten from the task rather than carried across. - **A loop's intermediate state is orchestrator-facing.** Report each round to the caller in chat, and never to GitHub. Only the converged result reaches the canonical record above. - **A deliverable whose substance is findings, a judgment, or a claim of absence goes through `review-findings` before it reaches that record.** - This covers an Investigation's report on any of its three routes, and equally a named-deliverable run that reaches a conclusion with no flow's procedure to place the step for it. - Run one pass, restate flagged claims as unsettled / not measured. The required clean is that the pass finished, not that it returned no findings. The one further invocation permitted is `review-findings`' subtractive verification pass on the ledger's accepted entries (plus intake-routed rejected-with-new-evidence entries); every other second invocation is forbidden. That pass is a loop under **Loop convergence** below, with its round, same-finding, and clean defined in `review-findings`. - Where `review-plan`, `review-code`, or `vet-code` already gates the artifact, this adds nothing on top. - For an Investigation, the tracking issue is the issue named as that run's requester — a background mention is not. When more than one issue URL is in play, list the candidates and name the target #N before asking. - Present the report in chat and ask whether to post that content to #N; post it as a comment on that issue only on yes; a declined ask leaves the report unpublished — settle with a person where its record lives before the run ends. - With no tracking issue, chat is the record. Any other such deliverable publishes to the canonical record above. ### Loop convergence Every loop that checks work and fixes what came back stops on the same conditions. The rule binds a skill's own check-fix loop and the loop that re-invokes it alike: - **Clean** — a round comes back with nothing blocking: no blocking finding, or a failing check that now passes. This is the normal exit (loop-clean — the Loop convergence sense, distinct from the phase-clean gate sense above). - **The same finding survives three rounds** of fixes without resolving. - **Five rounds in total.** - **Either non-clean condition above stops the loop and hands the user the decision**, with the findings still open and where the disagreement stands. Never report clean on the strength of fixes nothing has re-checked. **Each loop defines two things for itself**: what one of its rounds is, and what makes two findings the same one. Nothing else about stopping is a skill's to set. A skill may add a **stricter** condition on top of *clean* where its own inputs warrant it; it may not loosen one. **A bounded inner pass does not bound the loop around it** — these conditions are counted per loop, and "the skill I call is bounded" is never evidence that this loop terminates. - A wait bounded by clock time — polling for an answer that has not arrived yet — is a timeout owned by the skill that waits, not one of these loops. ### Escalation - When uncertainty is high, requirements conflict, multiple viable designs exist, or new facts invalidate the current plan, stop and go back to where the framing is owned: - `plan-work` for a Change (from `implement-work` or `pr-to-ready` alike) - the Investigation workflow's framing for an Investigation - Workflow selection if the task's type changed. - **A Critical finding that invalidates the agreed design is never fixed in place, and never worked around.** - It goes back to `plan-work` for re-approval wherever it surfaces. - Such a finding can surface on any round, so check for it before either of **Loop convergence**'s two non-clean stopping conditions. - Report what's uncertain, the options and trade-offs, and your recommendation. What a flow hands over on this exit belongs to that skill's own **Escalation** section; the contract for receiving it is `plan-work`'s **Entry**.
Versions
The database has no other skills named using-dude.
Database snapshot: 13.11.2026 · package version ef2ff77ad7e3 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100scp-otter-dude
Use when you need to connect to the SciGraph SCP server for Otter-DUDe (IBM Research Otter-Knowledge multimodal knowledge graphs for drug discovery) and call its MCP tools (query_cypher, get_kg_statistics, get_entity_details, get_experiment_workflow), including streamableHttp… - 100dude-with-sign-writer
Creates punchy, conversational one-liners in "Dude With Sign" style - bold statements that challenge norms, validate feelings, or poke fun at everyday truths. Use when creating short social captions, easel reveal messages, or single-sentence hooks. Not for long-form content or formal messaging. - 90start
Guides a first-time user through onboarding and picks the right workflow. Use when the user is new, just cloned the template, has no idea yet, asks where to begin, or wants to bring in existing work. - 100using-superpowers
Select relevant Superpowers workflow skills when the user requests that workflow or a concrete development task benefits from its process guidance.