Skip to content
Skillpedia
Security280k · #85

module-regression

Helps your agent manage changes in large projects. Ensures code changes in one part don't break other parts.

What it does

Helps ensure that changes in one part of a large project don't break other parts. It keeps a record of which parts depend on others and how to test if everything still works.

When to use it

  • ✓When you change a part of a large project and want to be sure you haven't broken anything elsewhere.
  • ✓If an error in one part of the project appeared days after another part was changed.
  • ✓To organize tests that depend on each other in complex projects.

Example of what to ask your AI

“Check if the change in the 'user authentication' module broke the 'profile management'.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/affaan-m/ECC/blob/main/pi/core/skills/module-regression/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/pi/core/skills/module-regression/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

It uses a file called REGRESSION.md to list dependencies between project parts. After a change, it runs tests for the affected parts to see if anything failed.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add affaan-m/ECC --skill module-regression

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/pi/core/skills/module-regression/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Module Regression Ledger

When to Activate

  • The repository has at least three interdependent modules, or a previous change to A has broken B.
  • A change modifies a module's externally observable behavior and must prove both that module and downstream consumers still work.
  • The project already has executable tests or reconciliation commands that should be organized by dependency.

Anti-Patterns

  • Creating a regression ledger for a small repository with no cross-module dependencies.
  • Guessing dependencies manually or treating one scan as permanent truth.
  • Replacing executable acceptance-command exit codes with model review.

Related Skills

  • test-collaboration: TEST-IDs, test assets, and defect-regression evidence.
  • ai-regression-testing: executable regression tests derived from important defects.
  • contract-first: cross-service or cross-client contract verification.
  • change-impact: pre- and post-implementation blast-radius analysis.

Problem

In large projects, modules depend on one another. People and agents often verify only the changed module while downstream consumers fail silently. The defect appears days later when an aggregate, export, or external behavior is wrong.

The remedy is a regression ledger (REGRESSION.md) plus a deterministic audit: after any relevant change, run the changed module and all affected downstream consumers. Delivery requires every command to pass.

Three Required Fields per Module

## Module 03 — Shop Data Cleaning
Downstream consumers: 05-aggregation, 07-final-export
Dependency evidence: `<repository dependency graph or reproducible scan command>`
Regression acceptance command: `pytest tests/test_03.py && python scripts/reconcile.py --module 03`
Propagation rule: external behavior change → run 05 and 07; internal-only change with a green module check → downstream may be exempted
  1. Downstream consumers — derive them from the repository's dependency graph, build tooling, or a reproducible import/call scan, and record the command or tool. Extraction differs by ecosystem; this skill does not pretend a universal scanner can parse every language. Mark edges unverified when they cannot be established mechanically. An affected unverified edge blocks an all-green verdict until a human confirms its scope or the related module is included in the run.
  2. Regression acceptance command — the ledger's core asset. Each module needs an executable command that proves it still works: tests, reconciliation scripts, or golden-sample diffs. Without it, the audit collapses into “the model looked and found no problem.”
  3. Propagation rule — state which downstream modules must run after a change and when an exemption is justified.

Connection to TESTS.md

REGRESSION.md does not maintain business rules or test gaps. It references stable TEST-IDs from the test-registry artifact:

Related test points: TEST-ORDER-001, TEST-REFUND-003
  • What rules must be protected, their coverage state, and the evidence location belong to test-collaboration and the test registry.
  • Which modules and commands must rerun after a change belong to this skill and the regression ledger.
  • The current session plans the ledger commands. Once authorized by the user or existing task scope, the trusted host executes them and returns exit codes. This skill adds no dedicated agent or slash command.

Ledger Discipline

  • Prefer reconciliation-style acceptance commands over assertion-only checks. External facts such as golden samples, upstream totals, and accounting relationships are harder to weaken accidentally than mocks or loose assertions.
  • Refresh downstream lists only from reproducible evidence. When dependencies change, rerun the recorded repository tool or scan; do not hand-edit an edge without evidence.
  • Keep the ledger at the repository root or under docs/, and link it from the project's instruction/map artifact so it does not become an orphan.

Audit Flow

Invoke module-regression through the host's skill entry point, such as $module-regression in Codex. The current session plans and reports the audit. Repository commands run through the trusted host runner within existing user authorization; ask only when a command needs new authority. Successful exit codes are regression evidence, never canonical ECC completion or integration authority.

…

FAQ

What is a 'regression ledger'?

It's a record (like a ledger book) that notes which parts of a project depend on others and which commands should be run to check if everything still works after a change.

Why can't I just test the part I changed?

In large projects, changing one part can affect others that aren't directly tested. The ledger ensures all impacted parts are checked.

What happens if a test fails?

If a test for the affected parts fails, it means the change introduced a problem (regression), and the change shouldn't be approved until the issue is fixed.

Details

Original description by the author

Govern cross-module regression in large repositories with a REGRESSION.md ledger that records each module's downstream consumers and executable acceptance command. After a change, run the changed module and every affected downstream command, and use observed exit codes as regression evidence under the project's delivery policy. Use for module regression, regression ledgers, impact audits, downstre

repo: affaan-m/ECC

Popularity

GitHub stars
280k
Ranking position
#85
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills