Introduction¶

A common problem when developing features with DSH is that the model possesses the ability to write code, review, and break down tasks, but there are no ordering constraints between these actions. You can see it start modifying files before requirements are even clarified, or see it breaking down tasks before standards are implemented. Process artifacts are scattered in the conversation, making it hard to review later “what the decision was at the time and why it was done this way.”

dsh-matt-flow is the plugin designed to address this issue. It is maintained by yuwang and belongs to the “Workflow” category. Instead of inventing a new set of AI capabilities, it orchestrates Matt Pocock’s Agent Skills into a development process with preconditions and solidifies this process as a DSH agent preset. Below, we introduce its composition, installation methods, and things to note during use.

What is this¶

One-sentence positioning: It adds a matt-flow agent preset to DSH, connecting the six stages of “Grill → Spec → Tickets → Implement → Review → Done”. The progression of stages is verified by the flow_stage tool.

Problems it solves:

1. Forces you to think clearly before writing code. The Grill stage does not allow writing code; decisions are recorded in .scratch/<feature>/decisions.md.
2. Forces the leaving of reviewable artifacts. Specs, tickets, and review conclusions are written to fixed paths.
3. Chains multiple skills in order using a single preset, rather than manually remembering which skill to use each time.

It is worth noting that this plugin is only responsible for orchestration. It does not copy or rewrite any skills; skills themselves are read from ~/.agents/skills and automatically follow updates to the upstream mattpocock/skills (via npx skills update).

Configuration Info: Version 0.7.3, License MIT, 1 GitHub star, maintainer yuwang. It contains no npm dependencies and only uses Node built-in modules (fs, path, os, child_process); on the browser side, it only uses the React provided by the host.

Core Functionality¶

Below is an introduction to the three layers of this package. It is installed as a bundle, and all three layers take effect simultaneously:

Responsibilities of the three tools:

1. flow_stage: Records and advances the stage of a feature. Status is written to .scratch/<feature>/flow.json. Advancement must be step-by-step and must satisfy preconditions; backtracking (rework) is allowed.
2. flow_ask: In the Grill stage, turns decisions into cards in the conversation. Each question has a set of options plus an additional input box, with a maximum of three questions per turn. After clicking “Submit Selection”, the answer is sent as the next message, and the model proceeds to the next step.
3. flow_skills: Checks the status of skills or manually retries if installation fails.

Why only one entry appears on the plugin page: The browser-side code can only aggregate from the top-level Loader entry, while the host behavior must remain within the preset subtree (otherwise it would pollute all sessions). Because of this, the same package is mounted twice: the top-level matt-flow-ui row has uiOnly: true, and apply() returns immediately; the matt-flow row inside the preset is responsible for the actual registration. This is the reason why only one entry is shown on the plugin page.

Installation & Enablement¶

Install from GitHub; the command comes from the plugin README:

dsh plugin add git+https://github.com/yuwang/dsh-matt-flow

You can also fill in the address above in the DSH Plugins page. After installation, DSH needs to be restarted once. Then, create a new session and select “Matt Engineering Flow” (Matt Flow) in the preset selector. Existing sessions are not affected; presets are only loaded when creating new sessions.

When developing locally, install via directory:

dsh plugin --profile desktop add /path/to/dsh-matt-flow

Uninstall:

dsh plugin --profile desktop remove dsh-matt-flow

Process data under .scratch/ will not be uninstalled or cleaned up.

There is one prerequisite after installation. Before entering the Spec stage for the first time, there needs to be a docs/agents/issue-tracker.md in the repository, explaining where issues are placed (GitHub, GitLab, or local markdown) and the triage tag vocabulary, etc. If you haven’t run /setup-matt-pocock-skills from the Matt suite before, you can let the model write one directly based on local markdown; the default path is .scratch/<feature>/.

The skills suite (37 skills) will be automatically installed to ~/.agents/skills when the preset is activated for the first time, provided the machine has node and npx and can access the npm registry and GitHub. If installation fails, it will not crash; the status will be recorded as failed, and no automatic retry will occur within the next 24 hours. Installation status can be viewed using flow_skills.

Where to select the preset:

1. On the blank page of a new session, in the preset chip (default showing “Standard / Standard”) next to the workspace selector in the bottom input toolbar, click to open the preset menu and select “Matt Engineering Flow”.
2. Settings → Agent Presets (settings.agentPreset), listing cards grouped by “Built-in / Custom”. “Matt Engineering Flow” is in the Custom group; you can “View Configuration” (read-only YAML) or set it as the default for new sessions.

If it hasn’t appeared in the menu yet, refresh the page once. The preset list refreshes when the connection resets; currently existing sessions will not automatically switch.

Stages & Prerequisites¶

The order of the six stages is fixed: grill → spec → tickets → implement → review → done.

Conditions to satisfy before entering the next stage:

The prerequisites only verify what can be verified: file existence, whether content is sufficient, and whether evidence is non-empty. The plugin does not pretend to verify “tests actually ran”; that evidence is written by the model itself, which you can see in the history of flow.json.

Three commands to use as needed:

Typical Usage¶

1. Create a new session, select “Matt Engineering Flow” as the preset, and speak your ideas.
2. The model will pull the grilling skill to clarify the design with you, rather than directly modifying code. Decisions are made into cards (options plus input box), with a maximum of three questions per turn.
3. Once agreed upon, write the spec, break down tickets, implement according to the list, review, and finish.
4. Throughout the process, use the capsules on the left side of the input box to see the current stage, progress, and the preconditions for the next stage; clicking the floating layer shows the full process and what to do at each step.

It will leave behind these artifacts:

1. .scratch/<feature>/decisions.md — Decisions for this change.
2. .scratch/<feature>/spec.md — The specification.
3. .scratch/<feature>/issues/*.md — Tickets, including blocking relationships.
4. CONTEXT.md / docs/adr/ — Terminology and difficult-to-revoke decisions; created as needed, nothing is written if they don’t exist.

Before the model calls flow_stage({action:"advance", to:"spec"}) to advance, the prerequisites require it to write the decisions into evidence first. You can check progress and the next stage’s preconditions at any time using flow_stage({action:"status", feature:"..."}).

Scope & Notes¶

Suitable scenarios:

1. There is a requirement to implement and you want to leave reviewable decisions and specifications.
2. Multi-person collaboration, where others need to understand “why this was done” when taking over.
3. Want to force yourself to think clearly before writing code.

Unsuitable scenarios: One-off small scripts, pure Q&A, emergency online troubleshooting. These should be done directly, with records supplemented later.

Things to note:

1. The plugin runs with the permissions of the current dsh process. It will start a subprocess npx -y skills@latest add mattpocock/skills -g -s '*' -y to install skills into ~/.agents/skills, which will affect all agents on this machine that read that directory, not just DSH. The trigger condition is very narrow: it only executes when 7 essential skills are missing; no automatic retry for 24 hours after failure; if you don’t want it to execute, don’t use this preset. It is recommended to check the plugin source code and license (MIT) before installing.
2. The plugin does not request extra permissions, does not read credentials, and does not initiate network requests other than the aforementioned npx. The files it will write are limited to process artifacts under .scratch/<feature>/, docs/agents/issue-tracker.md, ~/.dsh/matt-flow-bootstrap.json, and logs in the system temporary directory.
3. It does not take over model behavior. The prompts are strong constraints rather than hard constraints; the only real enforcement is the preconditions of flow_stage; theoretically, the model can completely bypass it and directly modify code. To enforce stronger constraints, ctx.tools.guard() needs to be added.
4. The preset is a snapshot. The plugin set is copied from the official standard preset. If DSH upgrades and standard adds/removes plugins, this preset will not automatically follow; it is recommended to sync once after upgrading by comparing with @deepseek-ai/dsh-web-app/presets/standard.patch.yml.
5. The UI is limited to status capsules and decision cards; there is no task board.
6. Not tested on Windows; the code includes fallbacks for log directories, npx.cmd, cmd.exe, and --copy adaptation, but there is no real device verification.
7. When troubleshooting, first check dsh-matt-flow-load.log and dsh-matt-flow-apply.log in the system temporary directory. No load line means the module was not imported; load but no apply indicates an injection issue. On macOS/Linux, logs are in /tmp; on Windows, they are in %TEMP%.

Conclusion¶

The value of dsh-matt-flow lies in turning the discipline of “Grill first, then Spec, then Implement” into the default path in the preset, while persisting stage state, decisions, and artifacts to local files that are reviewable. If you are already using Matt Pocock’s skills suite, it is equivalent to adding a layer of orchestration and gatekeeping to these skills.

Directory Page: https://www.skillhub.cn/plugins/yuwang/dsh-matt-flow
GitHub: https://github.com/yuwang/dsh-matt-flow

(The community directory is an independent site and has no official affiliation with DeepSeek / Hyperscience.)