Sonmat Dev Admits Tool Had the Same Bug It Set Out to Fix

The Bug Hunter Becomes the Bug

There is a particular kind of humility that comes from publicly calling out other projects for a flaw — and then discovering your own tool has the exact same problem. That is precisely what happened to the developer behind sonmat, a discipline plugin for Claude Code that was supposed to be 'different.'

In a candid blog post titled 'Another confession,' the sonmat maintainer admits that the tool — built explicitly to fix a well-known rule-propagation bug in Claude Code plugin workflows — shipped with the very same defect it was designed to eliminate.

The Core Problem: Rules That Don't Travel

The bug in question is deceptively simple but fundamentally disruptive. In Claude Code's architecture, discipline plugins define rules and constraints in the main session. However, when the agent spawns subagents (or 'workers') to handle tasks, those rules don't make the trip across. The workers operate without the guardrails the developer carefully set up.

This means that any behavioral constraints, coding standards, or workflow disciplines configured through plugins effectively vanish the moment Claude Code delegates work to a subagent. For teams relying on these plugins to enforce consistency — think style guides, security policies, or project-specific conventions — the gap is a serious liability.

According to the sonmat developer, this isn't an edge case. It is a systemic issue affecting 'every Claude Code discipline plugin' in the ecosystem. The post even references a related issue filed against superpowers, another popular plugin, where the maintainer reportedly closed the ticket as 'not planned.'

Sonmat's Promise — and Its Shortfall

Sonmat was built with this exact failure mode in mind. The developer had diagnosed the problem, named names, and positioned sonmat as the solution. The tool featured what the developer described as a 'nicely-crafted hook' — a mechanism designed to ensure rules would persist across session boundaries and into subagent contexts.

But the confession reveals that the implementation fell short. Despite the architectural awareness and the deliberate design choices, sonmat's hook did not actually propagate rules into worker sessions as intended. The developer's own testing eventually surfaced the same behavior pattern seen in competing tools.

The post frames this not as a failure of intent but as evidence of how deeply the propagation problem is embedded in Claude Code's plugin model. Even developers who understand the issue at a theoretical level can miss it in practice because the main session behaves correctly — the bug only manifests in the delegated workloads where it is harder to observe.

Why This Matters for the Claude Code Ecosystem

Claude Code has rapidly become one of Anthropic's most popular developer-facing products, and its plugin ecosystem is growing. Discipline plugins, in particular, serve a critical governance function — they are how teams impose structure on an otherwise free-form AI coding assistant.

If the underlying architecture makes it difficult or impossible for plugins to enforce rules in subagent contexts, the entire category of discipline tooling is undermined. Developers may believe their guardrails are active when they are not, creating a false sense of security.

The sonmat developer's transparency is notable here. Rather than quietly patching the issue and moving on, the public confession serves as a warning to the broader community: if you are using any discipline plugin for Claude Code, you should verify whether your rules actually apply in subagent workflows.

What Comes Next

The post hints that a fix is in progress — the developer notes the tool 'really wasn't' different from its competitors, adding the qualifier 'not yet, anyway.' This suggests an updated version of sonmat is being developed with a working propagation mechanism.

The deeper question, however, is whether this is a problem individual plugin developers can solve at all, or whether Anthropic needs to address rule propagation at the platform level. Until Claude Code's subagent architecture natively supports passing plugin-defined constraints to workers, every discipline plugin will be fighting the same uphill battle.

For now, the sonmat saga is a refreshingly honest reminder: in software development — even AI-assisted software development — the hardest bugs to catch are the ones you are already looking for.