qiushi-skill: Nine Methodology Skills That Force an Agent to Investigate Before It Answers

The failure mode qiushi-skill is aimed at

The README frames the problem in one line: agents can think, but they do not know how to approach a problem. It then lists five symptoms. Grabbing every thread of a complex issue at once. Answering before investigating. Shipping a plan without reviewing it. Declaring a task beyond capability at the first obstacle. Running ten things at once and finishing none. These are recognisable agent behaviours, and they are not solved by a bigger context window.

The target user is someone who already runs an agent host and has watched it produce confident, under-researched output. The project is a skills collection, not a framework and not a runtime. The README is explicit that it is methodology rather than politics or propaganda, and that it is not an attempt to simulate a person's personality. That second disclaimer matters: the material is drawn from classical dialectical and practice philosophy, but what ships is a set of procedures, not a character.

Whether the framing holds up is a separate question from whether the skills work. The diagnosis is plausible. The remedies are where the review has to look.

One kernel rule, nine weapons, three tiers

The architecture is a hierarchy, and the README gives it as a diagram. At the base sits a disposition it calls striving for perfection and persistence. Above that is the general principle, 实事求是, rendered as seeking truth from facts. That principle is described not as a tenth weapon but as the epistemological standard every other weapon obeys. It imposes four hard rules on judgement: conclusions follow the evidence, facts and inferences and unknowns are separated, nothing counts as done until it has been verified, and obstacles are diagnosed before they are escalated.

Above the principle sit three tiers. The philosophical base contains contradiction analysis and practice-cognition. The working-methods tier contains investigation, the mass line, and criticism and self-criticism. The strategy tier contains protracted strategy, concentration of forces, spark and prairie fire, and overall planning. Each of the nine has a named source text listed in the README table, from On Contradiction to On the Ten Major Relationships, and each skill directory carries an original-texts.md holding the quotations. Those quotation files are not auto-loaded, which is a deliberate context decision.

The mechanism worth noting is the trigger boundary. The README states that the kernel decides whether a situation justifies loading a weapon, that directly executable tasks trigger no downstream skill, and that where the host already has an equivalent process, the host wins. That last clause is unusual and worth respecting: the project is written to defer rather than to override.

What a SKILL.md actually contains

Each methodology skill is kept to five sections, and the README names them. Use and do not use, which defines the trigger boundary. Operating rules, the concrete actions. Output template, described as an observable artefact. Discipline, the hard constraints. Handoff, the next skill that would normally follow.

That five-part shape is the most interesting design choice in the repository. It means a skill cannot be a vague essay about a concept. It has to state when it applies, what the agent does, what comes out, what is forbidden, and where control goes next. The output template in particular is what makes the collection composable: if each method produces a defined artefact, a workflow layer can chain them and pass data between stages.

That chaining layer exists. The repository includes a workflows directory described as a cross-skill orchestration layer defining call order and data-passing conventions when several methods are combined. The README does not spell out the individual workflow definitions, so the specifics of those orderings are not verifiable from the supplied material. What is verifiable is that the layer is a separate directory rather than something baked into each skill.

Two subagents ship alongside the skills. investigator.md is a read-only research agent that produces a three-column report separating facts, inferences and unknowns, and the README notes that several can be dispatched in parallel from a main line. self-critic.md is a fresh-context reviewer that sees only the artefact and not the author's account of it, and every criticism must carry evidence and a suggested improvement. The fresh-context detail is the substantive part: a reviewer that cannot read the reasoning that produced the artefact is harder to talk around.

Installing it and what the commands do

There are two installation paths. The first is npx, which the README marks as recommended and which works across platforms:

npx qiushi-skill

Run bare, it detects installed hosts interactively and writes to the corresponding directories. It can also be aimed explicitly:

npx qiushi-skill install --target claude-code --scope user npx qiushi-skill install --target cursor,codex,opencode,openclaw,hermes,nanobot --scope user npx qiushi-skill uninstall --target claude-code

Those host names and the --target and --scope keys are the concrete interface. Per-platform target directories and native entry points live in docs/platforms.md, which is where you should look before assuming your host is covered. If Node.js is not available, the README gives a manual route: copy the directories under skills/ into the host's skills directory.

The second path uses Claude Code's marketplace:

/plugin marketplace add HughYau/qiushi-skill /plugin install qiushi-skill@qiushi-skill

Verification is a separate command, npx qiushi-skill validate, with shell equivalents at tests/validate.sh for macOS and Linux and tests/validate.ps1 for Windows.

Once installed, the README says the entry skill injects roughly fifty lines of resident kernel at the start of each session. Manual slash commands are also provided for hosts that support a Markdown command directory, one per method: /contradiction-analysis, /practice-cognition, /investigation-first, /mass-line, /criticism-self-criticism, /protracted-strategy, /concentrate-forces, /spark-prairie-fire, /overall-planning, and /workflows. Hosts without command-directory support open the same-named file or load skills/*/SKILL.md directly.

The context budget is the real constraint

Fifty lines of always-on kernel is a small number, and it is the number that decides whether this collection is usable. A skills system that injects every method into every session would burn context on nine procedures that mostly do not apply. This project avoids that by keeping the resident layer thin and loading the rest on trigger.

The cost of that choice is trigger reliability. If the kernel misjudges a situation, the weapon never loads and the agent behaves as if the skill were not installed. The README's own description of the kernel is that it judges whether a situation is worth invoking a weapon, and that direct-execution tasks trigger nothing. That is a reasonable default, but it means the collection's value depends on a judgement made in about fifty lines of prompt. The repository does not, in the supplied material, describe an evaluation harness for trigger accuracy. tests/validate.sh and tests/validate.ps1 are described as installation validation, not behavioural testing.

There is a second, quieter constraint. The skills are methodology. They shape how the agent structures a problem and what artefact it produces. They do not give the agent new tools, new data access, or new verification capability. The rule that nothing counts as done until it has been verified is a discipline imposed on the agent's own reporting; it does not by itself make verification possible. If the underlying agent cannot run the test, the rule produces a more honest status report rather than a passing one. That is still an improvement, but it is a smaller one than the framing might suggest.

Where the method is the wrong instrument

The clearest mismatch is short, well-specified work. Rename a variable, fix a broken import, convert a date format. The README states plainly that direct-execution tasks do not trigger a downstream skill, so the system is not going to add ceremony to a one-line change. But if you invoke a method manually on that kind of task, you get an investigation report and a contradiction analysis for a problem that needed neither. The overhead is real and the benefit is zero.

A second mismatch is domains where the primary bottleneck is capability rather than process. If an agent fails because it cannot read a binary format or cannot reach a service, no amount of investigation discipline fixes it. The method improves how the agent reasons about a problem it can already act on.

A third case is teams that already enforce a review process. The README's rule that the host's equivalent process takes precedence means qiushi-skill will step aside, so installing it adds little beyond the vocabulary. That is the honest outcome, but it is worth knowing before you spend time on the install.

There is also a documentation gap to flag. The supplied README is truncated mid-way through the project structure listing, so the full contents of the repository, including the complete workflows directory and any further reference guides, cannot be confirmed from the material. The reference guides that are named, contradiction-types-reference.md, review-checklist.md and phase-assessment-guide.md, are described as consulted on demand rather than auto-loaded.

How this differs from prompt-template collections

The obvious alternative is a prompt library or a set of reusable system prompts. The difference is structural rather than stylistic. A prompt library gives you text to paste. qiushi-skill gives you a directory layout with a defined file per method, an installer that writes into host-specific locations, a validation command, a marketplace entry for Claude Code, and a separate orchestration layer for chaining methods together. The five-section SKILL.md shape is the part a prompt library usually lacks: an explicit do-not-use boundary, a defined output artefact, and a handoff target.

The closer comparison is to agent frameworks that impose a plan-act-observe loop. Those put the control flow in code, which makes the sequence deterministic and testable. qiushi-skill puts the control flow in the kernel prompt and in the skill files, which makes it portable across hosts that share nothing but a skills directory. The trade is exactly what you would expect. You gain reach across Claude Code, Cursor, Codex, OpenCode and the other named hosts without writing adapters. You lose the ability to assert, in a test, that a given input produces a given method invocation. The project's own tests directory is described as installation validation, which is consistent with that trade rather than a gap in it.

A third option is doing nothing and relying on the model's default reasoning. That is a legitimate choice for teams whose tasks are short. The case for qiushi-skill rests on long, ambiguous tasks where the agent's default behaviour is the one the README describes: answering early and declaring victory early.

Licence, upkeep and what to check first

The repository is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive arrangement and it is the same licence most agent-skill collections use, so it is unlikely to be the deciding factor. This is a description of the licence text, not legal advice; if you are redistributing modified skills inside a product, read the licence yourself.

Upkeep cost is low in the ordinary sense. The skills are Markdown files plus a small JavaScript installer and validation script. There are no runtime dependencies to patch and no service to keep alive. The last push recorded is 2026-09-06, and no releases were retrieved, so versioning appears to be by commit rather than by tagged release. If you need pinned versions, that is a constraint to plan around.

The real maintenance cost is editorial. The value of each skill sits in its operating rules and output template, and those are the parts most likely to need revision as your agent host changes how it loads skills or how it handles subagents. The investigator and self-critic subagents depend on host support for dispatched agents with independent context. If your host does not provide that, those two files are inert.

Before adopting, verify three things in order. Run npx qiushi-skill validate after install and confirm it passes. Open one SKILL.md, ideally contradiction-analysis or investigation-first, and read the operating rules to judge whether they are specific enough to change what your agent does on a real task. Then confirm in docs/platforms.md that your host's target directory and native entry are listed, because the installer writes to host-specific paths and an unsupported host means falling back to copying skills/ by hand.

Editorial conclusion

Adopt qiushi-skill if you already run an agent host that reads a skills directory and you want a named vocabulary for investigation, prioritisation and self-review. Do not adopt it if you expect it to change model behaviour on its own, or if your tasks are short and direct, since the README states that direct-execution tasks trigger no downstream skill. Before wiring it into a workflow, run npx qiushi-skill validate, read the five-section layout of one SKILL.md to judge whether the operation rules are concrete enough for your domain, and check docs/platforms.md to confirm your host is actually supported.

Official sources

1. HughYau/qiushi-skill on GitHub
2. Issues
3. License: MIT
4. Project website
5. README