data-substrate-analysis

Analyze typing strategies, mutation patterns, and serialization in Python and TypeScript codebases.

5|Updated Dec 23, 2025
One-click install
npx skills add https://github.com/Dowwie/agent_framework_study --skill data-substrate-analysis
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: data-substrate-analysis
Source: https://github.com/Dowwie/agent_framework_study/tree/main/.claude/skills/data-substrate-analysis
Command: npx skills add https://github.com/Dowwie/agent_framework_study --skill data-substrate-analysis

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill analyzes fundamental data primitives, type systems, and state management patterns within a codebase to standardize data modeling decisions and improve reliability across frameworks.

Core Features & Use Cases

  • Classify typing strategies across files (Pydantic, TypedDict, and loose dicts) and map their validation boundaries in the codebase.
  • Assess mutation behavior and immutability patterns to identify safer state-handling approaches.
  • Document serialization strategies (JSON, pickle, custom methods) and lifecycle of data objects for maintainability.
  • Compare data modeling approaches across frameworks to guide architectural decisions.

Quick Start

Point the skill at your codebase. It will scan files like types.py, schema.py, models.py, and state.py, categorize typing strategies, report on mutability and serialization, and outline recommended data-modeling practices.

Frequently Asked Questions about data-substrate-analysis

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

FAQPage Schema
How do I analyze data primitives and state management patterns in a Python or TypeScript codebase?

You can analyze data primitives and state management by running static analysis on source files like types.py, schema.py, models.py, and state.py to classify typing strategies, immutability, and serialization without executing code.

How do I assess mutation behavior and immutability patterns for safer state handling?

Assess mutation behavior and immutability by scanning state.py and models.py to identify mutation patterns, evaluate lifecycle management of data objects, and recommend safer state-handling approaches for maintainability.

Does this static analysis tool execute my code to evaluate serialization strategies?

No, this static analysis does not execute code; it scans source files to document serialization strategies like JSON, pickle, or custom methods and outputs a structured report on data object lifecycles.

Can I compare data modeling approaches across different frameworks to guide architectural decisions?

Yes, you can compare data modeling approaches across frameworks by generating a structured report that outlines typing strategies, mutation patterns, serialization approaches, and recommended practices to guide architectural decisions.

What are the limitations of static analysis for evaluating type systems and state patterns?

Static analysis cannot execute code or capture runtime behavior, limiting its evaluation to source file structures, typing classifications, and documented patterns rather than actual runtime state mutations or dynamic serialization outputs.