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

DEMIURGOS is a tool for people who write code with AI agents and are tired of re-explaining their project in every new chat. It collects a team's rules into a single system, distributes them to different agents, and in the new version shows which instructions actually took effect and where the context has holes.

Why agents make mistakes

The main problem with coding agents today lies less in the model than in the context. Claude, GPT, Gemini, Qwen and others can write code, but they don't know how a specific repository is organized: where the tests live, what format the API responses use, which directories are off limits, where TypeScript strict mode is required and where a different set of rules applies.

As a result, developers spend their time not on the task but on constant corrections: re-explaining the project structure, catching deviations from the style guide, and fixing solutions that technically work but fit poorly into the codebase.

How DEMIURGOS works

DEMIURGOS tackles this problem with a three-layer scheme. At its base is the .rules/ core, which holds the source of truth about the project: stack, architectural patterns, constraints, response format and access level.

Adapters for specific tools are built on top of it. Cursor gets its own rule files, Claude Code gets CLAUDE.md, GitHub Copilot gets .github/copilot-instructions.md, and AGENTS.md can serve as a universal format for the rest. Extensions such as subagents, hooks and MCP appear only when they are really needed, not "just in case."

The approach is built not around a tidy folder but around portability of rules between agents and IDEs. One developer can work in Cursor, another in Claude Code, a team lead in Copilot, and all of them get the same picture of the project without manually syncing prompts.

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

• One set of rules lives in the repository and goes into git together with the code
• Adapters let you connect the same instructions to Claude Code, Cursor, Copilot, Windsurf, Zed, Codex, Cline and other tools
• Before delivering the result, the system runs 3–5 typical scenarios, such as adding an API endpoint, refactoring a module or fixing a bug in authorization
• If a rule gets in the way, is ignored or duplicates context that is already known, the system suggests softening it, moving it higher or deleting it

What /debug does

The most noticeable update is the /debug and /debug full modes. After a normal request, the agent not only produces code but also shows which rules fired, which file they came from and how they influenced the final solution.

That turns the system from a black box into something observable. If a rule about transactions isn't being applied, you see it immediately. If the project has no convention for input naming, cooldown UI feedback, FOUC or browser API handling, the debug mode flags those gaps and suggests what exactly to add to patterns.md or constraints.md.

In essence, /debug doesn't grade rules for the sake of grading; it helps you see their coverage after a series of real requests. After 10–20 tasks it becomes clear where the agent confidently relies on .rules/, where it falls back on the model's built-in heuristics, and where it starts to improvise. The mode is especially useful for teams that grow their rule system gradually and don't want to rewrite it blindly after every mistake.

"Rules are not 'set and forget.'"

This also sets the logic for updates: if the same mistake happens twice, add a rule; if an instruction gets in the way, simplify or remove it; if the agent ignores it, move it higher and back it up with an example. The article describes the rules as a living document rather than a static artifact.

In other words, this is not about a one-off prompt but about a maintenance cycle in which the rules evolve along with the project, the stack and the 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, auditing and feedback.

For teams already working in Claude Code, Cursor, Copilot or Windsurf, it is a practical way to reduce repeated explanations, cut noise in the code and get an AI agent to predictable behavior faster.