Key Takeaways
- Claude Code users should add value-change checks to MCP tool guards, not just empty-payload checks, to avoid no-op writes and false audit entries.
- Use a GET-before-write diff pattern.
The Technique
When building MCP tools that write to external APIs, your first instinct is to guard against empty payloads—if no fields are passed, don't fire the request. That's a good start, but it's not enough. The real question is: will this write actually change anything?
A developer recently uncovered this gap in their DEV.to MCP server's update_article tool. The guard checked if title, body_markdown, or published were None. If all were None, it raised an error. But if a caller passed title="Same Title It Already Has"—identical to the current value—the guard passed, and the tool fired a GET and a PUT against a live post.
Worse, the audit log recorded it as a change: fields_changed: ["title"] with title_before and title_after byte-identical. A false positive that looks exactly like a real edit.
Why It Works
This isn't just about saving API calls—it's about trust. An audit log exists to trace bad writes. If it can't distinguish a genuine edit from a defensive re-send, it's useless. The cost of a no-op write isn't just latency and tokens; it's the erosion of your ability to debug later.
For Claude Code users, this is especially critical. Agents often re-read current state before deciding to act. They may pass back values they just fetched, thinking they're making an update. If your MCP tool blindly writes those, you get noise in your logs and potential side effects (like triggering webhooks or incrementing revision counters).
How To Apply It
Here's the pattern to implement in your MCP tools:
- Fetch current state before building the payload (you may already do this for diffing).
- Compare each incoming field against the current value.
- Drop unchanged fields from the payload. If nothing remains, raise a
ValueErroror return a "no-op" flag.
Example in Python:
before = _dev(f"/articles/{article_id}")
article = {}
if title is not None and title != before.get("title"):
article["title"] = title
if body_markdown is not None and body_markdown != before.get("body_markdown"):
article["body_markdown"] = body_markdown
if published is not None and published != before.get("published"):
article["published"] = published
if not article:
raise ValueError("update_article called with no fields that would change")
result = _dev(f"/articles/{article_id}", method="PUT", data={"article": article})
_log_article_update(article_id, before, article.keys(), result)
This is a judgment call: raise vs. silently drop vs. return early. For MCP tools, raising is often best—it tells the agent its input was redundant, encouraging it to avoid the call altogether.
Try It Now
Review your MCP servers. For every tool that writes, ask:
- Does it fetch current state before writing?
- Does it filter out unchanged values?
- Does its audit log only record fields that actually differ?
If not, apply the diff pattern above. It's a small change that prevents false logs and wasted calls—exactly the kind of polish that makes MCP tools reliable in production.
Source: dev.to
