trace-writes

Trace memory writes in x64 processes using hardware breakpoints and disassembly.

15|4|Updated Mar 7, 2026
One-click install
npx skills add https://github.com/vzco/arc-probe --skill trace-writes
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: trace-writes
Source: https://github.com/vzco/arc-probe/tree/main/plugins/arc-probe/skills/trace-writes
Command: npx skills add https://github.com/vzco/arc-probe --skill trace-writes

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Find out which code writes to a specific memory address by using hardware breakpoints and live inspection, turning memory corruption mysteries into actionable insights.

Core Features & Use Cases

  • Set hardware watchpoints on a target address to observe reads or writes.
  • Disassemble the instruction at the access point to identify the writer.
  • Correlate memory writes with function boundaries to isolate responsible code paths.
  • Use case: debug a crash caused by a rogue write to a critical memory address in a running x64 process.

Quick Start

Use trace-writes to monitor memory writes by setting a hardware breakpoint on the target address and then inspecting the breakpoint hits to identify the writer.

Frequently Asked Questions about trace-writes

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I trace memory writes to find what code is modifying a specific address?

To trace memory writes, you set a hardware breakpoint on the target address to monitor access, then disassemble the instruction at the breakpoint hit to identify the writer. This maps the memory modification back to the responsible code path.

How do hardware breakpoints work for debugging memory corruption in an x64 process?

Hardware breakpoints monitor memory writes by pausing execution when a specific x64 address is accessed. They allow live inspection of breakpoint logs to isolate the exact instruction causing the memory corruption.

Can I use trace-writes to debug rogue writes in multi-threaded x64 applications?

Yes, you can trace memory writes in multi-threaded x64 scenarios. The Skill applies hardware breakpoints and correlates breakpoint hits with function boundaries to isolate the responsible code path across concurrent threads.

What is the best way to identify the instruction causing a crash by writing to a critical memory address?

The best way to identify the writer is to set a hardware watchpoint on the corrupted address, wait for the crash to trigger it, and then disassemble the instruction at the access point to map the write back to the originating code.

How do I map a memory write breakpoint hit back to the responsible function boundary?

You map a memory write breakpoint hit back to the responsible function by inspecting the breakpoint logs and correlating the access point address with known function boundaries in the disassembly to isolate the code path.

Does tracing memory writes with hardware breakpoints require disassembly to find the writer?

Yes, tracing memory writes requires disassembly. After the hardware breakpoint triggers on the target address, you must disassemble the instruction at the access point to identify exactly which code performed the write.