# dbskill

Dontbesilent's business diagnosis toolbox. It distills methods from 12,307 posts into 21 Agent skills.

It can be used in Claude Code, Codex, Cursor, Trae Solo, or any agent that supports skills or system prompts.

**Latest release: v2.14.2**

**v2.14.2 update**: refined the recommendation rules for `/dbs-chatroom`. Expert suggestions are no longer based on a fixed list or vague celebrity intuition. The skill first identifies what perspective the topic is missing, then chooses the person most likely to advance the discussion. It also excludes broad finance, broad business, and people who are famous mainly for presentation rather than judgment.

**v2.14.1 update**: fixed the missing `scaffold/root/AGENTS.md`, `CLAUDE.md`, and `SOURCE_OF_TRUTH.md` files in the `/dbs-content-system` release package. `v2.14.0` introduced the formal content-structuring system, and this release filled in the root scaffold files required by the initialization script.

Recent updates have concentrated on five directions:

- Content engineering: a new content-structuring system for turning local materials into a growing content asset base
- Agent workstation migration: support for Grok Build and a unified migration vocabulary across the three platforms
- Decision systems: expanded from business decision records to a general personal decision system
- Learning and questions: added `dbs-learning` and `dbs-good-question`
- State management: completed `dbs-save`, `dbs-restore`, and `dbs-report`

For the full history, see [GitHub Releases](https://github.com/dontbesilent2025/dbskill/releases).

**Author**: [X](https://x.com/dontbesilent) · [Xiaohongshu](https://xhslink.com/m/637xuspR4iI) · [Douyin](https://v.douyin.com/pRUDhpBqOrc/)

**Everything is open. You can take the whole package, or just the part you need. The knowledge packs, atomic library, and individual axioms all work independently.**

---

## How to install dbskill

### Claude Code

```bash
claude plugin marketplace add dontbesilent2025/dbskill
claude plugin install dbs@dontbesilent-skills
```

### Generic install method

```bash
npx -y skills add dontbesilent2025/dbskill -g --all
```

### Trae Solo

Trae Solo installs one skill per zip. Download the latest `dbskill-version.zip` from [GitHub Releases](https://github.com/dontbesilent2025/dbskill/releases), unzip it to get 21 separate skill archives, and drag each one into Trae Solo’s upload window.

If you want to build locally, run `bash tools/build-skills.sh`. The output will be in `dist/skills/`.

## Paid Q&A group

If you want to join the paid Q&A group, scan the QR code in the original README or open the link below:

[https://mp.weixin.qq.com/s/V7Dr0-75VYZOLJ6lbT_s0w](https://mp.weixin.qq.com/s/V7Dr0-75VYZOLJ6lbT_s0w)

## How to update dbskill

### Claude Code marketplace users

```bash
claude plugin marketplace update dontbesilent-skills
claude plugin update dbs@dontbesilent-skills
/reload-plugins
```

### Users installed through `npx skills add`

Just rerun the same command. Install and update use the same command.

```bash
npx -y skills add dontbesilent2025/dbskill -g --all
```

---

## Toolbox

### dbs diagnostic skills

| Skill | What it does |
|---|---|
| `/dbs` | Main entry, routes to the right tool automatically |
| `/dbs-diagnosis` | Business model diagnosis. Resolves the problem instead of answering the question |
| `/dbs-benchmark` | Benchmarking analysis. Five filters to remove noise |
| `/dbs-content` | Content creation diagnosis. Five-dimensional checks |
| `/dbs-content-system` | Content structuring system. Turns local content into a sustainable content engine |
| `/dbs-hook` | Short-video hook optimization. Diagnosis + generation |
| `/dbs-xhs-title` | Xiaohongshu title formula. Match against 75 viral formulas |
| `/dbs-ai-check` | AI writing detector. Scans 22 traits, diagnosis only |
| `/dbs-slowisfast` | Slow is fast. Build assets through friction and find the places worth doing slowly |
| `/dbs-action` | Execution diagnosis. Adler-based framework (formerly `dbs-unblock`) |
| `/dbs-deconstruct` | Concept deconstruction. Wittgenstein-style review |
| `/dbs-goal` | Goal clarification. Turn vague goals into auditable deliverables |
| `/dbs-good-question` or `/good-question` | Good-question generator. Turn fuzzy questions into Agent-readable, critiquable, and verifiable problem statements |
| `/dbs-decision` or `/decision-system` | Personal decision system. Build a local knowledge engine for long-term decisions, with four layers and source tags |

### Learning tools

| Skill | What it does |
|---|---|
| `/dbs-learning` or `/dbs-learn` | Interactive learning. Break a topic into a sequence of articles and generate the next one from feedback |

### State management trio

| Skill | What it does |
|---|---|
| `/dbs-save` | Save the key conclusions, rejected directions, and recommended next step from the current diagnosis |
| `/dbs-restore` | Reload the last archive and continue where you left off |
| `/dbs-report` | Merge multiple archives into a timestamped Markdown report |

> **A few keywords**
> - **Archive**: a local diagnosis state file written by `/dbs-save`. Each save creates a new archive rather than overwriting the old one.
> - **Project**: a way to separate diagnoses for different businesses. By default, it is isolated by the current directory name.
> - **Continue from last time**: if you close Claude Code today and reopen tomorrow, `/dbs-restore` in the same project directory brings back the previous archive.

Archives are stored in `~/.dbs/sessions/{project-name}/` and reports in `~/.dbs/reports/{project-name}/`.

### Decision system

| Skill | What it does |
|---|---|
| `/dbs-decision` or `/decision-system` | Main entry for the personal decision system. Automatically decides whether to update state, create a case, backfill results, or emit a snapshot |
| `/decision-case` | Force case-creation mode |
| `/result-backfill` | Force result backfill mode |
| `/state-snapshot` | Generate a stage snapshot |

Decision projects live in `~/.dbs/decisions/{project-name}/` by default, or in `{current-directory}/decision/{project-name}/` when using `--here`.

**Four-layer structure**

- `01_facts/` - What happened. Append only.
- `02_patterns/` - What patterns emerged. Slowly refine, do not rewrite old sections.
- `03_snapshot/` - What the whole situation looked like at a given point in time. New versions are separate.
- `04_open/` - What is still unresolved, including decision cases. Clear it when done.

Each layer includes a `_what-goes-here.md` file explaining what belongs there and what does not.

**Core mechanisms**

- `my-current-state.md` is the first entry point. Read it at the start of every conversation and update it at the end.
- Source tags are mandatory: `[self]`, `[AI inference]`, `[AI conclusion]`, `[AI key note]`, `[AI meta note]`, `[result backfill]`, `[correction]`
- Concept upgrades in `02_规律/` must satisfy 2 of 3 gates: appears 3 times, explains multiple facts, or has tooling value
- Privacy mode (asked during init): strict code names and git blacklist reminders
- When the loop becomes “ask a question -> reject the plan -> ask a new question,” the AI should stop giving solutions and record `[AI meta note]`

### Agent workstation migration

| Skill | What it does |
|---|---|
| `/dbs-agent-migration` | Normalize a project into a Claude Code / Codex / Grok three-platform agent workstation with consistent rules, names, and bridge files |

### Advanced content module

| Skill | What it does |
|---|---|
| `/dbs-content-system` | Content structuring system. A heavy single-directory module inside `dbskill` that audits the content scale and then builds a new content engine |

### Chatroom series

| Skill | What it does |
|---|---|
| `/dbs-chatroom-austrian` or `/austrian` | Austrian economics chatroom. Hayek, Mises, and Claude in conversation |
| `/dbs-chatroom` or `/targeted-chatroom` | Targeted chatroom. Recommends experts or specified people for multi-role discussion plus a judge’s summary |

### Tool map

![Skill map](docs/skill-link-map.svg)

#### Common main line

```text
diagnosis (is the direction right?)
    ↓
benchmark (who should I imitate?)
    ↓
content (how should I make the content?)
```

#### Local content optimization

```text
content finds a hook problem → hook (how to optimize the opening?)
content needs a title → xhs-title (title formulas)
content smells like AI → ai-check (AI writing detection)
```

#### Horizontal tools

```text
goal (the goal is spinning in place and cannot drive action)
slowisfast (when you are taking shortcuts, rushing, or bypassing key friction)
action (you know what to do, but cannot do it)
deconstruct (the concept is fuzzy, so judgment fails)
chatroom (hear multiple perspectives before deciding)
learning (turn a topic into a sequence of learning articles)
decision (turn major decisions into a long-term asset)
```

#### Interactive learning

```text
pick a topic
    ↓
generate 01.md and leave a feedback area
    ↓
user writes feedback
    ↓
learning reads the feedback first, then generates 02.md
    ↓
keep building an adaptive learning ladder
```

#### State management

```text
any diagnostic skill reaches a conclusion
    ↓
save (store the conclusion, rejected directions, and next step locally)
    ↓
come back later → restore (reload the archive and continue)
    ↓
many archives accumulated → report (merge them into a shareable report)
```

When a diagnostic skill reaches a conclusion such as “problem resolved,” “report output,” or “action plan decided,” it should suggest `/dbs-save`. Later, `/dbs-restore` or “continue from last time” resumes from the same place.

Skills automatically recommend the next step. Examples:

- diagnosis finds a valid direction but needs a specific path → benchmark
- diagnosis finds the blocker is psychological or execution-related → action
- diagnosis finds the user is taking shortcuts → slowisfast
- diagnosis finds the concept is not well defined → deconstruct
- diagnosis finds the “question” is really a spinning goal that cannot drive action → goal
- benchmark finds a target and the work becomes content execution → content
- benchmark finds the user is rushing the imitation path → slowisfast
- benchmark finds the user is avoiding execution → action
- benchmark finds the goal is still fuzzy and there is nobody to imitate → goal
- content finds an opening problem → hook
- content needs a title → xhs-title
- content smells like AI → ai-check
- content reveals the method is taking shortcuts → slowisfast
- the user already has a lot of local content and wants to turn it into reusable assets → `dbs-content-system`
- action finds the real problem is the method, not execution → slowisfast
- action finds the goal itself is spinning in place → goal
- deconstruct reveals the whole statement is a spinning goal → goal
- goal passes audit but the user still cannot act → action
- goal passes audit but needs a path → benchmark
- goal passes audit but involves content creation → content / hook / xhs-title
- deconstruct reveals a pseudoconcept → deconstruct
- the user wants a question statement that an agent can reason about → good-question
- good-question finds the goal is spinning in place → goal
- good-question finds the core concept is undefined → deconstruct
- good-question has produced a clear business problem → diagnosis / benchmark / content
- if the user wants multiple viewpoints first → chatroom
- if the user uses fuzzy concepts → deconstruct
- if the user mentions Claude Code, Codex, Grok, AGENTS.md, CLAUDE.md, skill bridges, or workstation migration → `dbs-agent-migration`
- if the user mentions a content structuring system, content asset engineering, topic maps, or content assembly → `dbs-content-system`
- if the user wants to learn a topic step by step → `dbs-learning`
- if diagnosis / benchmark / content / action / deconstruct / goal have reached a conclusion → `dbs-save`
- if the user says “last time,” “previously,” “continue,” or “pick up where we left off” → `dbs-restore`
- if there are 3 or more saves or the user wants to package the work → `dbs-report`

---

## Knowledge base

The dbskill knowledge base is fully open. You do not need to install the whole skill to use it; you can take just the parts you need.

### Directory structure

```text
knowledge-base/
├── atomic-library/
│   ├── atoms.jsonl
│   ├── atoms_2024Q4.jsonl
│   ├── atoms_2025Q1.jsonl
│   ├── ...
│   └── README.md
│
├── skill-knowledge-pack/
│   ├── diagnosis_axioms-diagnosis-framework.md
│   ├── diagnosis_problem-resolution-case-library.md
│   ├── benchmark_benchmarking-methodology.md
│   ├── benchmark_platform-operations-knowledge.md
│   ├── content_content-creation-methodology.md
│   ├── content_platform-features-cases.md
│   ├── action_psychological-diagnosis-framework.md
│   ├── action_signal-case-library.md
│   ├── deconstruct_language-concept-framework.md
│   ├── deconstruct_deconstruction-case-library.md
│   ├── decision_decision-record-methodology.md
│   └── decision_structure-backfill-rules.md
│
└── high-frequency-concept-dictionary.md
```

### What the atomic library is

Each atomic entry is a structured knowledge point distilled from a post:

```json
{
  "id": "2024Q4_042",
  "knowledge": "A necessary condition for judging whether a business can work is whether you can describe the color of the product",
  "original": "…",
  "url": "https://x.com/dontbesilent/status/…",
  "date": "2024-10-01",
  "topics": ["business model and pricing", "language and thinking"],
  "skills": ["dbs-diagnosis", "dbs-deconstruct"],
  "type": "anti-pattern",
  "confidence": "high"
}
```

**Field guide**

| Field | Meaning |
|---|---|
| `knowledge` | The distilled knowledge point |
| `original` | Original post text |
| `topics` | Theme tags |
| `skills` | Related skills |
| `type` | principle / method / case / anti-pattern / insight / tool |
| `confidence` | high / medium / low |

### What the skill knowledge packs are

Many skills include knowledge packs, usually one method document and one case document. They are public method documents that can be read on their own or used as background for maintenance.

### How to use them in your own project

**Scenario 1: give your AI business diagnosis ability**

Paste the contents of `knowledge-base/skill-knowledge-pack/diagnosis_axioms-diagnosis-framework.md` into your system prompt.

**Scenario 2: build a RAG knowledge base**

Import `knowledge-base/atomic-library/atoms.jsonl` into your vector database.

**Scenario 3: only want cases**

Filter for `type: "case"` or `type: "anti-pattern"`.

**Scenario 4: build a chatbot**

Use the skill knowledge pack as the system prompt and the atomic library as RAG support.

**Scenario 5: study and research**

Filter by `topics` and read only the domains you care about.

---

## License

This project uses the [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/) license.

- Personal use, learning, research, and non-commercial projects: no attribution or permission needed
- Publicly released derivative works: please credit the source
- Commercial use: separate authorization required
