DEMIURGOS adds a rules debugging mode for AI agents and support for 20+ tools

DEMIURGOS — a tool for those who write code with AI agents and are tired of re-explaining the project in every new chat. It collects team rules into one system, distributes them to different agents, and in the new version shows which instructions actually worked and where context gaps remain.

Why Agents Make Mistakes

The main problem with coding agents today is not so much the model as the context. Claude, GPT, Gemini, Qwen and others know how to write code, but don't understand how a specific repository is structured: where tests are located, what API response format is used, which directories should not be touched, where TypeScript strict mode is needed, and where a different set of rules applies. As a result, developers spend time not on the task itself, but on constant corrections: re-explaining project structure, catching deviations from style, and fixing solutions that are formally working but fit poorly into the codebase.

How DEMIURGOS Works

DEMIURGOS solves this through a three-layer scheme. At its core is the .rules/ directory, which stores the source of truth about the project: stack, architectural patterns, constraints, response format and access levels.

On top of it are adapters for specific tools. For Cursor there are its own rule-files, for Claude Code — CLAUDE.md, for GitHub Copilot — **.

github/copilot-instructions.md, and for others AGENTS.md** can be used as a universal format.

Separate extensions like subagents, hooks and MCP appear only when they are truly needed, not "for the future". The approach is not based on a pretty folder, but on the portability of rules between agents and IDEs. One developer can work in Cursor, another in Claude Code, a team lead in Copilot, but they all get the same picture of the project without manual synchronization of prompts.

The author also builds minimalism into the system: before creating a new file, it checks whether it solves a real problem and whether one line in an existing document would suffice.

• One set of rules is stored in the repository and goes into git along with the code
• Adapters allow the same instructions to be connected to Claude Code, Cursor, Copilot, Windsurf, Zed, Codex, Cline and other tools
• Before output, the system runs 3–5 typical scenarios like adding an API endpoint, refactoring a module or fixing a bug in authorization
• If a rule gets in the way, interferes, or duplicates already known context, it's suggested to soften it, promote it higher, or remove it

What /debug Provides

The most notable update is the /debug and /debug full mode. After a regular request, the agent not only outputs code but also shows which rules worked, which file they came from, and how they influenced the final solution. This turns the system from a black box into an observable one.

If a rule about transactions is not being applied, you see it immediately. If the project lacks a convention for input naming, cooldown UI feedback, FOUC or browser API handling, debug mode marks such gaps and suggests exactly what to add to patterns.md or constraints.

md. In essence, /debug doesn't evaluate rules for the sake of evaluation, but helps you see their coverage after a series of real requests. After 10–20 tasks, it's already clear where the agent confidently relies on **.

rules/**, where it engages built-in model heuristics, and where it starts improvising. This mode is especially useful for teams that are gradually building their own rules system and don't want to rewrite it blind after every mistake.

"Rules are not 'set it and forget it'".

This also determines the logic of updates: if the same error happens twice, a rule needs to be added; if an instruction gets in the way — simplify or remove it; if the agent ignores it — promote it higher and support it with an example. In the article this is described as a living document, not a static artifact. That is, it's about a cycle of maintenance, not a one-time prompt, where rules evolve along with the project, stack and team's working habits.

What This Means

The coding agent market is moving from one-off prompts to full infrastructure around them. DEMIURGOS is interesting not as yet another chatbot, but as a layer for managing agent behavior in a repository: with versioning, adapters, audit and feedback. For teams already living in Claude Code, Cursor, Copilot or Windsurf, this is a practical way to reduce the number of repeated explanations, cut down code noise and get AI agents to predictable work faster.