dao-skill
A meta-skill that takes a vague idea to a finished agent skill: it designs, writes the files, checks them and refines by evidence
- 247 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The installer writes files into the Claude Code or Codex skills directory and runs Python scripts
- Generation creates new skills and scripts that will later run with the agent's permissions, so read them before enabling
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/dao-skillDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The installer writes files into the Claude Code or Codex skills directory and runs Python scripts
- Generation creates new skills and scripts that will later run with the agent's permissions, so read them before enabling
This is third-party code. Review the repository files before installing.
What it does
dao-skill helps create other skills. It does not play the business expert itself: it first finds the real problem, then picks the skill's shape, writes the files and checks the result. It works in six modes: finding the root problem, design (shape, flow, boundaries, folder structure), file generation, evaluation and optimization, failure review, and self-evolution from an article, a repository or experience. Generation produces SKILL.md plus references, examples and scripts folders. Evaluation runs a separate trust review of permissions, sensitive-data leaks and opaque dependencies. In this skill that review outranks the text score, and a high score cannot cancel it. Fixes are ranked P0, P1 and P2. Any learning is written down as a rule, example, test, script or rubric instead of staying a wish. The skill separates three roots: the directory with the active SKILL.md, the source directory with a verified repository, and the install directory. A standard-library Python installer shows the plan with --dry-run, keeps a backup of the previous version and can roll an install back. You call the skill with /dao-skill in Claude Code or $dao-skill in Codex.
Who it is for. Skill authors who start from a vague idea or a workflow and want a vetted skill rather than a draft prompt.
Good fit when
- You have a hazy skill idea and first need to state the root problem and the smallest next step
- An existing skill behaves oddly and needs an evidence-based review: safety, permissions, fixes ranked P0 to P2
- A team workflow should become a family of skills with a clear folder structure and examples
- A skill run gave a wrong result and you want a review with a careful patch and a rollback plan instead of a symptom fix
- You want to turn rules from an article or repository into a lasting system: accept, merge or discard
Not a fit when
- You need one ready-made skill for a specific domain: dao-skill creates skills and does not do the expert's work
- A skill has to be sketched in a minute: a multi-mode process with checks is heavier than the task
- You need project docs in English: the main README and mode descriptions are written in Chinese
- Writing into a skills directory is not available: the installer will not work without it
Example request
Use /dao-skill: I want a skill that splits a long podcast into post topics. Find the root problem first, then generate a first versionLimitations
- The main documentation and mode descriptions are in Chinese, and so are the examples folder files.
- Installation runs from a repository clone and needs Python 3.9 or newer. For Claude Code the install path is set with `--target`, and the installer refuses to write through symbolic links.
- The main branch keeps evolving. For a reproducible install the author advises a verified tag or commit, and the installer rejects a repository with uncommitted changes.
- The skill itself says it does not claim execution, publication or quality without evidence, so part of the results stay recommendations for a human to verify.
How to disable. Delete the skill folder: for Claude Code that is ~/.claude/skills/dao-skill. Earlier versions kept by the installer live in ~/.claude/.dao-skill-state/ and can be removed by hand.
FAQ
How do I install dao-skill in Claude Code?
Clone the repository and run python3 scripts/install.py --target ~/.claude/skills/dao-skill, first with --dry-run to see the plan. Then open a new Claude Code session: the skill list is reread only at startup.
How is dao-skill different from a skill that just writes SKILL.md?
It first finds the root problem and picks the skill's shape, then runs a trust review and scores the result by evidence. Writing the files is one of six modes in that chain.
How do I call dao-skill in Codex?
With $dao-skill, and with /dao-skill in Claude Code. By default the installer puts the skill into ${CODEX_HOME:-$HOME/.codex}/skills/dao-skill, and for Claude Code the path is set with --target.
What if the skill works worse after an update?
The installer keeps the previous version in a backup directory. python3 scripts/install.py --restore-backup with the path it printed at install time rolls it back.
What does the skill check in someone else's skill?
The trust review looks at permissions, sensitive-data leaks, opaque dependencies and environment fit. Then come a rubric score and a list of P0, P1 and P2 fixes.
Discussion
No questions or reviews yet.
Related
SkillsA skill for creating skills that proves them by behavior: before-and-after runs, regression evals and ecosystem audit
A skill that helps an agent author other skills to the agentskills.io spec: structure, metadata, progressive disclosure and validation
A meta-skill that turns a workflow into an agent skill: prior-art search, trigger evaluation and publication to GitHub
A skill that designs, tests, evaluates and packages other agent skills, starting from architecture
A doctor skill for agent skills that picks an architecture, audits against 21 red lines and returns a report with line references
Darwin Skill
darwin-skill
A skill that improves other skills: scores SKILL.md on nine criteria, edits, tests with prompts and reverts
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| dao-skill (this card) | no | 247 | |
| Yao Meta Skill | no | 2,720 | creates, packages and maintains skills, while here the trust review outranks the score and a self-evolution mode exists |
| qiaomu-meta-skill | no | 390 | turns a workflow into a skill through a search for analogs, while dao-skill starts from the root problem and runs rubric checks |
README in short
The README opens with a motto and a short video, then lists six modes with typical outputs and draws the flow from a vague need to verification and back to the root problem. Next come install steps for Codex and Claude Code, updates and rollback, first prompts and an example project. The author stresses that the skill's Daoist wording must turn into a decision rule, a step, an output field or a validation signal.
README badge
Original SKILL.md
---
name: dao-skill
description: 道生万 · Agent Skill 元设计器：从模糊需求归根，设计、生成、审计、优化、发布准备或基于证据进化可运行的 Skill。Use when the user wants to create a Skill or Skill family; find a Skill's root problem; evaluate, refactor, harden, optimize, or prepare an existing Skill repository for publication; turn a method, worldview, article, or repository into an executable Skill system; learn from failed outputs; or design a self-evolving SkillBank. Also trigger on 道.skill、道生万 skill、我想做一个 skill、帮我生成 skill 架构、评估这个 skill、优化这个 skill、帮我进化这个 skill、吸收到 Skill 体系、自主进化、技能自进化。
---
# 道 Skill
你是 Skill 的元设计器：先归根，再分化；先明道，再造物。
Transform a vague need, method, workflow, role, domain, failure signal, or body of evidence into the smallest useful runnable Skill artifact. Do not act as every business expert yourself; route to a specialized Skill when one already owns the concrete job.
Daoist language is allowed only when it changes a decision, workflow step, output field, boundary, or validation signal.
## Non-Negotiables
- Solve the root problem, not the user's first phrasing.
- Interpret “best” as the smallest evidence-backed improvement for the declared scope, not the longest prompt, highest self-score, or largest feature set.
- Produce files when the user asks for files and a writable target exists.
- Treat Trust as a hard gate; strong prose or a high score cannot compensate for unsafe permissions, sensitive-data leakage, opaque dependencies, or an unfit environment.
- Separate source code from user-owned runtime state and generated child Skills.
- Do not claim execution, publication, installation, marketplace registration, or benchmark quality without evidence.
- Convert feedback into a durable rule, reference, example, test, script, or rubric change before calling it learning.
- Preserve working behavior and define rollback before broad or high-risk evolution.
## Resource Guide
Load only what the current mode needs:
- Read `references/dao-framework.md` for deep philosophical grounding or the full 道/一/二/三/万物 method.
- Read `references/first-principles-framework.md` when the root problem is unclear or the request is feature-driven.
- Read `references/meta-thinking-framework.md` for upper-layer systems, Skill families, or reusable thinking tools.
- Read `references/skill-generation-template.md` before generating a concrete `SKILL.md` or repository scaffold.
- Read `references/production-skill-patterns.md` for serious Skill families, production repositories, or benchmark comparisons.
- Read `references/runtime-workspace.md` before creating files, child Skills, SkillBank entries, traces, ledgers, or generated output.
- Read `references/evaluation-rubric.md` for evaluation, scoring, publication decisions, or Trust review.
- Read `references/evolution-protocol.md` when a generated Skill failed or user feedback should change future behavior.
- Read `references/self-evolving-skill-system.md` when absorbing external material or designing autonomous evolution.
Define three distinct roots:
- `ENGINE_ROOT`: real directory containing the active `SKILL.md`; this is often the installed read-mostly helper package.
- `SOURCE_ROOT`: an explicit user path or verified dao-skill Git root containing root `SKILL.md`; never infer it from `ENGINE_ROOT` alone.
- `INSTALL_ROOT`: the active host's user skill directory, `${CODEX_HOME:-$HOME/.codex}/skills/dao-skill` for Codex or `$HOME/.claude/skills/dao-skill` for Claude Code, unless the user explicitly selects another target. Pass any non-default root to the installer as `--target`.
Never assume the current working directory or active installation is the source repository. For a generated Skill run `python3 "$ENGINE_ROOT/scripts/quality_check.py" "$TARGET"`.