multi-file-changes

Manage complex code modifications across multiple files and cross-crate boundaries.

Updated Feb 14, 2026

Search Tags:#code quality #refactoring #software development #code changes #cross-crate #vendored code

Ready to run

npx skills add https://github.com/timinou/sakya --skill multi-file-changes

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: multi-file-changes
Source: https://github.com/timinou/sakya/tree/main/.claude/skills/multi-file-changes
Command: npx skills add https://github.com/timinou/sakya --skill multi-file-changes

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a structured methodology to prevent errors and ensure clarity when making significant code modifications that affect multiple files, vendored code, or cross-crate boundaries.

Core Features & Use Cases

Systematic Approach: Guides users through a disciplined process for complex code changes.
Error Prevention: Emphasizes reading, tracing, and verifying to minimize bugs.
Use Case: Before refactoring a core library function used across several microservices, consult this Skill to ensure all downstream impacts are considered and the change is implemented safely.

Quick Start

Follow the disciplines outlined in this skill before initiating any change that touches more than three files.

Frequently Asked Questions about multi-file-changes

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

FAQPage Schema

What is the best way to manage complex code modifications across multiple files?▼

To manage complex code modifications, apply a structured methodology that enforces reading before writing, tracing ownership chains, and verifying at each layer. This prevents errors when changes span multiple files or cross-crate boundaries.

How do I safely refactor vendored code without breaking dependencies?▼

To safely refactor vendored code, enumerate second-order effects and trace type and ownership chains before modifying. Respecting conditional compilation and matching existing patterns ensures the refactoring maintains code integrity across cross-crate boundaries.

When do I need a systematic approach for cross-crate code changes?▼

You need a systematic approach for cross-crate code changes when modifications touch more than three files or affect shared libraries. Applying disciplines like tracing ownership chains and verifying layers ensures coordinated, high-integrity refactoring.

How to trace second-order effects when modifying code across multiple files?▼

Trace second-order effects by reading existing code first, matching established patterns, and verifying modifications at each architectural layer. This disciplined enumeration prevents unexpected downstream bugs during multi-file refactoring.

Does this code change methodology support conditional compilation scenarios?▼

Yes, this code change methodology explicitly respects conditional compilation by enforcing disciplines that account for existing compilation conditions. It guides users to match patterns and verify modifications when handling complex cross-crate boundaries.