strong-relation

Identify and record cross-file strong coupling relationships with direction and strength judgments.

2|Updated Jun 8, 2026
One-click install
npx skills add https://github.com/HACK-WU/skills --skill strong-relation-hack-wu
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: strong-relation
Source: https://github.com/HACK-WU/skills/tree/main/skills/strong-relation
Command: npx skills add https://github.com/HACK-WU/skills --skill strong-relation-hack-wu

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? When reviewing or modifying code, changing module A often requires changing module B, but these cross-file couplings are only discoverable by reading the entire codebase. This Skill makes such hidden dependencies explicit and searchable, so you know what must change together before you edit. ## Core Features & Use Cases - Coupling Identification: Detects contract coupling (shared DTOs, interface signatures, message formats, shared table schemas) and business coupling (rule dependencies, call ordering, state consistency) across modules. - Direction & Strength Judgment: Evaluates each relation along two orthogonal lines—contract/structure and semantics/behavior—producing triples of source, target, direction, and strength (must-change / should-change / optional). - Persistent Memory Integration: Writes confirmed relations into ki-search via the ki-memory-write skill, grouped by functional module, and verifies writes with ki_query_group. - Use Case: After expert-team creates a module expert asset, automatically record that module's strong couplings so later code reviews can query "if I change A, what else must change". ## Quick Start Ask the AI to record the strong coupling relationships for a specified module, for example: "Record the strong relations between the order module and its dependencies."

Frequently Asked Questions about strong-relation

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

FAQPage Schema
How do I find cross-module code dependencies before refactoring?

Run the strong-relation analysis on the target module to detect contract coupling (shared DTOs, interfaces, message formats) and business coupling. It uses GitNexus impact queries to locate candidates, then confirms real coupling strength by reading the shared data structures in source code.

What counts as a strong coupling between two files?

A strong coupling means changing A requires or strongly suggests changing B: shared data structures, interface signature contracts, message formats, shared table schemas, or business rule dependencies. Ordinary calls, read-only operations, and optional plugin-style dependencies are treated as weak and not recorded.

How is the direction of a code dependency determined?

Direction is judged along two orthogonal lines: the contract/structure line (who consumes whose data structures) and the semantic/behavior line (whose behavior the other side adapts to). The two lines can point in opposite directions, and both are recorded when they do.

Does this work without GitNexus or ki-search available?

GitNexus is optional; without it the analysis falls back to reading source code directly. If ki-search is unavailable, the skill degrades gracefully by presenting the coupling list in the conversation instead of blocking the workflow.

When should I not use strong-relation analysis?

Do not use it for intra-module knowledge (use expert-team), for drawing ER or data-flow diagrams (use data-flow-model), or for analyzing the impact of one specific bug fix (use bug-impact-analysis). It only records persistent cross-module coupling contracts.