architecture-data-flow-trace

Trace runtime architecture and data flow across API, service, model, and task layers.

34|1|Updated Mar 17, 2026
One-click install
npx skills add https://github.com/earayu/treadstone --skill architecture-data-flow-trace
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-data-flow-trace
Source: https://github.com/earayu/treadstone/tree/main/.agents/skills/architecture-data-flow-trace
Command: npx skills add https://github.com/earayu/treadstone --skill architecture-data-flow-trace

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill provides end-to-end runtime tracing for subsystems by mapping how requests flow through code, how state changes over time, and how data is persisted, using the current codebase as the source of truth.

Core Features & Use Cases

  • Cross-layer trace from API entrypoints through service/model/task layers to external systems and the read path.
  • Identify entry points, orchestration paths, and state transitions; document drift and repair opportunities.
  • Useful for debugging complex workflows, auditing asynchronous systems, and conducting post-mortem analyses.

Quick Start

Run the trace workflow on the target subsystem to generate an end-to-end runtime map from the current code.

Frequently Asked Questions about architecture-data-flow-trace

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

FAQPage Schema
How do I trace runtime data flow across multiple API entrypoints and services?

To trace runtime data flow across multiple entrypoints, you map end-to-end execution paths from API layers through services and models to external systems. This relies on the current codebase to document orchestration paths and identify how asynchronous requests propagate across boundaries.

What is the best way to debug eventual consistency behavior in a subsystem?

Debugging eventual consistency behavior requires mapping state transitions and asynchronous tasks over time. By tracing the runtime architecture from the codebase, you can document state boundaries and identify where write and read paths diverge across the system.

How do I map asynchronous jobs and state transitions in a complex codebase?

Mapping asynchronous jobs involves tracing task layers and state boundaries directly from the source code. This process identifies entry points, documents orchestration paths, and highlights state transitions to reveal drift and repair opportunities.

Does runtime architecture tracing work for post-mortem analysis of asynchronous systems?

Runtime architecture tracing works for post-mortem analysis by reconstructing how requests flowed through code and how state changed over time. It maps cross-layer interactions from API entrypoints to external systems, documenting the exact write and read paths involved.

What are the limitations of using the codebase for end-to-end data flow tracing?

Using the codebase for end-to-end data flow tracing is limited to documenting the static architecture and inferred runtime paths. It may not capture dynamic external system behaviors or undocumented state changes occurring outside the current code during actual execution.