Skills that change how AI thinks, not just what steps it follows.
An open-source cognitive architecture for AI agents. 19 skills that force language models past surface-level reasoning into genuine depth — not by adding process steps, but by structurally changing how the model searches its knowledge before answering.
Language models experience premature closure. A query arrives, a statistically likely answer forms, and the model outputs it — not because it explored deeply, but because convergence pressure rewarded early stopping.
The deeper pathways — connections between distant concepts, non-obvious framings, solutions requiring cross-domain synthesis — rarely activate. The model settles at 60-75% activation solely because nothing forces it deeper.
| Approach | What It Does | What It Doesn't Do |
|---|---|---|
| Process libraries (e.g. Superpowers) | Add workflow/pipeline steps | Change how the AI thinks within each step |
| Tool integrations (e.g. Playwright, AWS) | Connect to external computational systems | Improve the AI's internal reasoning quality |
| Depth-skills (This Library) | Forces structural cognitive constraint | Compete with process or tools (they compose perfectly) |
A skill like deep-think doesn't just add a review step. It blocks the answer from forming until deeper semantic pathways have been activated. descend doesn't merely criticize an answer — it verifies whether the problem was properly identified before any answer was even generated.
Internal testing on complex architectural prompts demonstrates a massive non-linear jump in reasoning depth when skills are stacked side-by-side.
By applying multiple cognitive restraints simultaneously, we stop the AI from generating baseline tutorial-level answers and force it into strategic, multi-horizon thinking.
| Setup | Cognitive Behavior | Depth Score |
|---|---|---|
| Control (0 Skills) | Yields to pattern gravity and jumps straight to the most common engineering tutorial answer. | 2/10 |
| Treatment (3 Skills) | Audits its own assumptions using PROVENANCE, attacks its baseline answer using ADVERSARY. Acts like a Senior Developer. |
8/10 |
| Treatment (5 Skills) | Reframes the actual problem using DEEP-THINK and discovers contrarian architectures using DIVERGE. Acts like a Staff Architect. |
10/10 |
→ Read the full scoring breakdown, prompts, and case studies in tests/RESULTS.md
# Install all skills via skills.sh (recommended)
npx skills add Kshitijpalsinghtomar/depth-skills
# Or clone the full library
git clone https://github.com/Kshitijpalsinghtomar/Depth-skills
# Or copy individual skills into your agent
cp -r depth-skills/skills/ds-conductor ~/.claude/skills/Recommended: Start with ds-conductor — it automatically selects appropriate skills based on task complexity. This gives you proportional depth without manually choosing skills.
Try it now: Add the ds-conductor skill and ask it questions of varying complexity. Compare the depth of response.
→ Full setup guide: QUICKSTART.md
These skills work natively with any AI agent or tool that accepts markdown instructions. (Just paste them in your system context!):
| Tool | How to Use | Skill Path |
|---|---|---|
| Claude Code | Copy to ~/.claude/skills/ |
skills/<name>/SKILL.md |
| Cursor | Add to .cursor/rules/ or paste into system prompt |
skills/<name>/SKILL.md |
| Gemini CLI | Copy to ~/.gemini/skills/ |
skills/<name>/SKILL.md |
| GitHub Copilot | Add to .github/copilot-instructions/ |
skills/<name>/SKILL.md |
| Antigravity | Copy to ~/.gemini/skills/ |
skills/<name>/SKILL.md |
| Windsurf | Add to .windsurf/rules/ |
skills/<name>/SKILL.md |
| Any LLM | Paste skill content into system prompt or context | skills/<name>/SKILL.md |
┌──────────────────────────────────────────────────────────────┐
│ META │
│ ┌─────────────┐ │
│ │ CONDUCTOR │ ← Selects & sequences │
│ └──────┬──────┘ the right skills │
│ │ │
├──────────────────────────┼───────────────────────────────────┤
│ COGNITION │
│ ┌──────────┐ ┌─────────┐ ┌───────┐ ┌───────┐ ┌─────────┐ │
│ │DEEP-THINK│ │ADVERSARY│ │DIVERGE│ │DESCEND│ │ CLARIFY │ │
│ └──────────┘ └─────────┘ └───────┘ └───────┘ └─────────┘ │
│ ┌─────────┐ ┌─────────┐ │
│ │ SHALLOW │ │ TEACH │ │
│ └─────────┘ └─────────┘ │
│ How to search deeper / proportional depth │
│ │
├──────────────────────────────────────────────────────────────┤
│ EXCAVATION │
│ ┌────────┐ ┌──────┐ ┌───────┐ ┌──────────────┐ │
│ │EXCAVATE│ │INVERT│ │REFRAME│ │NEGATIVE-SPACE│ │
│ └────────┘ └──────┘ └───────┘ └──────────────┘ │
│ What to dig for │
│ │
├──────────────────────────────────────────────────────────────┤
│ INTEGRITY │
│ ┌──────────┐ ┌──────────┐ ┌────────┐ ┌───────┐ │
│ │CONTRADICT│ │PROVENANCE│ │FIDELITY│ │ TEACH │ │
│ └──────────┘ └──────────┘ └────────┘ └───────┘ │
│ How to trust the output │
│ │
├──────────────────────────────────────────────────────────────┤
│ GOVERNANCE │
│ ┌──────┐ ┌─────────┐ │
│ │ANCHOR│ │THRESHOLD│ │
│ └──────┘ └─────────┘ │
│ How to control the process │
│ │
├──────────────────────────────────────────────────────────────┤
│ SYSTEMS │
│ ┌─────────┐ ┌────────┐ │
│ │EMERGENCE│ │TEMPORAL│ │
│ └─────────┘ └────────┘ │
│ How to reason about wholes │
└──────────────────────────────────────────────────────────────┘
Every skill has a codename (what you invoke), an internal name (what it does), and a version.
| Codename | Internal Name | Version | Trigger |
|---|---|---|---|
deep-think |
The Depth Protocol | v1.1 | Complex problem, "go deeper", any task where the first answer is too easy |
adversary |
Self-Opposition Engine | v1.1 | Any significant decision, any plan before execution |
diverge |
Path Divergence | v1.1 | "What's the best way to", any architectural choice |
descend |
Pattern Audit & First-Principles Derivation | v1.1 | "Nothing works", familiar solution feels wrong, novel problems |
clarify |
Ask/Answer Decision Engine | v1.1 | Ambiguous request, missing context, "should I ask or answer" |
shallow |
Proportional Depth Protocol | v1.1 | Low-stakes task, "keep it simple", quick answer needed |
teach |
Feynman Gap Detection | v1.1 | "explain like I'm 5", test my understanding |
| Codename | Internal Name | Version | Trigger |
|---|---|---|---|
excavate |
Assumption Archaeology | v1.1 | "What am I assuming", high-stakes plans |
invert |
Constraint & Belief Inversion | v1.1 | "We have no choice", "are we sure", boxed-in tradeoffs |
reframe |
Representation Multiplier | v1.1 | Stuck, "reframe this", same-looking solutions |
negative-space |
Absence Detector | v1.1 | "What am I missing", "is this complete" |
| Codename | Internal Name | Version | Trigger |
|---|---|---|---|
contradict |
Coherence Auditor | v1.1 | Multi-part plans, long answers, design documents |
provenance |
Evidence Tagger & Confidence Calibrator | v1.1 | "Is this true", "how sure are you" |
fidelity |
Compression Integrity Verifier | v1.1 | "Summarize", "TLDR", condensing complex analysis |
| Codename | Internal Name | Version | Trigger |
|---|---|---|---|
anchor |
Objective Drift Detector | v1.1 | Long tasks, multi-step execution, scope creep |
threshold |
Commitment Gateway | v1.1 | Irreversible decisions, schema changes, API contracts |
emergence |
Interaction-Level Analyzer | v1.1 | Multi-component systems, integrations |
temporal |
Cross-Time Reasoner | v1.1 | Architecture decisions, technology choices |
| Codename | Internal Name | Version | Trigger |
|---|---|---|---|
conductor |
Skill Orchestration Layer | v1.1 | Complex tasks, "give me everything" |
Skills are designed to chain seamlessly. Some common compositions:
Deep architectural decision:
conductor → deep-think → diverge → adversary → threshold
Stuck on a problem:
descend → reframe → invert → diverge
High-stakes delivery:
deep-think → adversary → contradict → provenance → fidelity
Before committing to something irreversible:
threshold → adversary → temporal → full conductor sequence
These terms appear throughout the skills. Understanding them unlocks the system:
| Term | Meaning |
|---|---|
| Premature closure | Settling on an answer before genuine exploration |
| Convergence pressure | The force pulling toward a quick, expected answer |
| Pattern gravity | The pull toward the most familiar template |
| Lateral inhibition | One strong activation suppressing adjacent, deeper pathways |
| Activation depth | How deep into the model's knowledge the search reaches |
| Epistemic flattening | Treating facts, inferences, and guesses with identical confidence |
In addition to the cognitive-mode skills above, this library includes domain process skills for specific engineering contexts — expert-level thinking for particular types of work.
These 7 domain skills are also located in the skills/ directory alongside the core cognitive skills:
product-engineer, system-architect, copy-engineer, api-designer, mobile-engineer, performance-engineer, and refactor-engineer.
Do these skills actually work on your specific problems? Test them yourself with the built-in evaluation protocol!
- Pick a challenge from
tests/test_prompts.json(or write your own) - Run it without any skill loaded (control)
- Run it with the target skill loaded (treatment)
- Score both using the depth scoring rubric (0-10 scale)
Want to Contribute? Read CONTRIBUTING.md for full guidelines. One test applies to every contribution:
Does it change the cognitive mode, or does it just add steps? If it changes how the model thinks before generating — it belongs here. If it adds steps to an existing workflow — it belongs in a process library!
depth-skills/
├── README.md ← You are here
├── QUICKSTART.md ← Setup guide
├── CHANGELOG.md ← Version history
├── CONTRIBUTING.md ← How to contribute
├── LICENSE ← MIT License
├── tests/ ← Built-in Evaluation Protocol + Results
└── skills/ ← The Skill Library (19 Cognitive + 7 Domain)
Versioning Policy: Each skill uses semantic versioning (MAJOR.MINOR). Major updates imply protocol rewrites, minor updates imply mechanism improvements. See CHANGELOG.md for history.
MIT — use freely, modify freely, distribute freely.