Reading
An open-source cognitive architecture that uses 16 structured skills to force language models to think deeply instead of settling for statistically most likely answers.
Section 01
Depth Skills is an open-source cognitive architecture consisting of 16 structured skills. It aims to solve the "premature closure" problem of large language models by changing their cognitive patterns to force deep thinking, unlock their existing knowledge potential, and improve reasoning quality and output reliability.
Section 02
When we ask a large language model a question, an answer often forms in milliseconds. This isn't because it has explored deeply, but because convergence pressure rewards early stopping. The model tends to choose the statistically most likely response, while deeper thinking paths—cross-domain concept connections, non-obvious framework shifts, solutions requiring integration of multi-domain knowledge—are never activated.
This phenomenon is called "Premature Closure". The model doesn't lack deep knowledge; instead, there's no mechanism to force it to search those deep paths. Most skill libraries try to solve this by adding steps, but Depth Skills takes a different approach: changing the cognitive pattern itself.
Section 03
Depth Skills is an open-source cognitive architecture with 16 structured skills, specifically designed to force language models beyond surface-level reasoning. Unlike adding workflow steps, these skills change how the model thinks before generating an answer. Each skill targets a different dimension of premature closure, creating mandatory written outputs that enter the context window and physically alter what the model generates next.
The core idea of this architecture is: not to make AI smarter, but to make AI use more of the knowledge it already has. Language models typically use only 60-75% of their knowledge depth because early answers are rewarded, and users rarely push them to think deeply. Depth Skills are forcing functions—they ensure deep paths are activated before an answer is formed.
Section 04
Depth Skills organizes the 16 skills into six functional levels, each addressing a specific type of cognitive problem:
Conductor is the orchestration layer of the entire system, responsible for selecting and ordering other skills. When facing complex tasks, the Conductor decides which skills to invoke and in what order, ensuring optimal allocation of cognitive resources.
This layer solves the problem of "how to search more deeply" and includes four core skills:
Deep-think is the system's core protocol. When facing complex problems or when the first answer feels too simple, this skill forces the model to activate deeper knowledge paths before generating an answer. It physically changes the generation process by creating intermediate thinking outputs.
Adversary introduces a self-opposition mechanism. Before any major decision or plan execution, this skill requires the model to actively find flaws, weaknesses, and unconsidered edge cases in its own reasoning. It's not just "checking the answer"—it implants doubt and scrutiny before the answer is formed.
Diverge targets questions like "What's the best way?". When facing architectural choices or strategic decisions, this skill forces the model to explore multiple paths instead of rushing to choose the first seemingly reasonable one. It counteracts "pattern gravity"—the tendency to choose the most familiar template.
Descend is used in situations where "nothing works" or "familiar solutions feel wrong". It requires the model to return to first principles, re-derive the essence of the problem, and verify if the problem is correctly understood—rather than optimizing answers on an incorrectly defined problem.
This layer solves the problem of "what to excavate" and focuses on discovering hidden assumptions and blind spots:
Excavate performs assumption archaeology. In high-risk plans, it forces the model to explicitly list all implicit assumptions, including those taken for granted.
Invert targets situations like "We have no choice" or "Are we sure?". It breaks thought patterns by inverting constraints and beliefs to find overlooked alternatives.
Reframe handles the "stuck" state. When a problem seems to have only one solution, this skill forces the creation of multiple problem formulations, reframing the problem from different angles.
Negative-space is an absence detector. It doesn't check what exists; it looks for what's missing. When asking "Is this complete?", it specifically probes attention blind spots—the dimensional spaces the model has never illuminated.
This layer solves the problem of "how to trust the output":
Contradict is a coherence auditor for multi-part plans. It checks internal consistency in long answers and design documents, looking for contradictions.
Provenance is an evidence marker and confidence calibrator. When asked "Is this true?" or "How sure are you?", it requires the model to clearly distinguish between facts, inferences, and guesses—avoiding epistemological flattening (treating different types of knowledge with the same confidence).
Fidelity verifies compression integrity. In "summary" or "TLDR" tasks, it ensures that complex analyses retain their core meaning after compression.
This layer solves the problem of "how to control the process":
Anchor is a goal drift detector. In long tasks and multi-step executions, it continuously checks for deviations from the original goal to counteract scope creep.
Threshold is a commitment gateway. Before irreversible decisions, pattern changes, or API contract finalization, it forces an additional layer of review to ensure consequences match the importance of the decision.
This layer solves the problem of "how to reason about the whole":
Emergence is an interaction-level analyzer. In multi-component systems and integration scenarios, it specifically analyzes emergent properties from component interactions, not just individual components.
Temporal is a cross-time reasoner. In architectural decisions and technical choices, it forces consideration of the time dimension—how decisions evolve over time and what their long-term consequences are.
Section 05
Depth Skills are designed to allow chaining combinations, with recommended skill sequences for different task types:
Deep Architecture Decision: Conductor → Deep-think → Diverge → Adversary → Threshold
Solving Stuck Problems: Descend → Reframe → Invert → Diverge
High-Risk Delivery: Deep-think → Adversary → Contradict → Provenance → Fidelity
Checking Completeness: Negative-space → Excavate → Emergence
Before Irreversible Commitment: Threshold → Adversary → Temporal → Full Conductor Sequence
This combination isn't just a workflow; it's a layered superposition of cognitive patterns. Each skill changes the model's activation state, and the next skill deepens it further.
Section 06
Depth Skills are fully compatible with mainstream AI development tools:
~/.claude/skills/.cursor/rules/ or paste into system prompts~/.gemini/skills/.github/copilot-instructions/.windsurf/rules/Installation can be done via npm: npx skills add Kshitijpalsinghtomar/depth-skills, or manually configure by cloning the repository directly.
Section 07
Depth Skills provide a built-in evaluation protocol. Users can choose test cases from 20 real-world challenges, run them both without skills (control group) and with target skills (experimental group), and compare differences using a 0-10 depth scoring standard. This community-driven validation method ensures the effectiveness of the skills can be independently verified.
Section 08
Depth Skills are fundamentally different from process libraries (like Superpowers, GSD) and tool integrations (like Playwright, AWS). Process libraries add workflow steps, tool integrations connect external systems, while Depth Skills change the quality of the model's thinking within each step.
A skill like "Deep-think" doesn't add a review step; it prevents the answer from forming before deep paths are activated. "Negative-space" doesn't check what exists; it finds what's missing. "Descend" doesn't criticize the answer; it verifies if the problem was correctly identified before any answer is formed.
These skills can be combined with process and tool libraries. Use Superpowers for TDD discipline, and Depth Skills to improve the quality of thinking in each step.
For AI agent developers and users, Depth Skills provide a systematic method to improve output quality. It doesn't require changing models or increasing computing resources; instead, it uses structured cognitive interventions to unlock the greater potential of existing models.
In high-risk scenarios—such as medical diagnosis assistance, legal analysis, safety-critical code reviews, and complex business decisions—the value of Depth Skills is particularly evident. It doesn't provide absolute guarantees, but systematic depth assurance, ensuring the model doesn't stay on the surface when it should think deeply.
For researchers, this architecture provides a testable, iterable framework for understanding and improving the reasoning process of language models. Each skill is composable, versionable, and can be continuously improved through community evaluation.
Depth Skills represent a new AI interaction paradigm. Instead of accepting the model's first response, we force deep exploration through structured cognitive skills. This approach recognizes a fundamental fact: the knowledge depth of language models far exceeds their default usage depth; the key is to create the right conditions to unlock this depth.
As AI agents are deployed in more complex, high-risk scenarios, cognitive architectures like Depth Skills will become increasingly important. They provide a path to improve reliability and quality on top of existing technology without waiting for the next generation of models.
For developers and teams looking to improve AI agent outputs, Depth Skills provide a ready-to-use toolbox. Starting with the "Deep-think" skill, gradually exploring other skills, and building a custom skill combination based on specific scenarios may be one of the most cost-effective ways to enhance the quality of AI applications.
Keep going with more reads from the same topic.
Splinter is a minimalist, high-performance key-value (KV) and vector storage system enabling zero-latency inter-process communication via shared memory and atomic operations. With only 766 lines of core code, it supports millions of operations per second and 768-dimensional vector storage, offering a new architectural approach for local LLM inference and data-intensive applications.
Folkering OS is the world's first AI-native bare-metal operating system, entirely written in Rust no_std without relying on Linux, POSIX, or libc. It can generate commands from scratch, compile them into WASM, and run them in 10 seconds, achieving true self-evolution.
This project explores how to use Large Language Models (LLMs) to detect logical vulnerabilities in Ethereum smart contracts, especially business logic flaws that are difficult for traditional static analysis tools to capture, such as economic manipulation and execution order errors.
A self-hosted MCP server that provides cross-session persistent coordination, task management, event bus, and observability for AI agents. It supports 35 tools and can be integrated into clients like Claude Code and Cursor with zero code changes.