Introduction

When using AI coding agents in large repositories, the common problem is not “inability to write code,” but rather guessing the wrong direction within local context: repeatedly implementing existing capabilities, writing shared logic into temporary directories or facades, bypassing public APIs, forming reverse dependencies, or treating early temporary structures as stable architecture.

DeepSeek Harness (DSH) emphasizes “everything is a plugin,” and its community directory is an independent site with no official affiliation with DeepSeek or Horizon. WeirdSky924/project-change-router-skill is a DSH plugin designed for such scenarios: before an agent modifies code, it first has the agent read the project’s local routing bundle, route report, and execution gate to determine how to proceed with the implementation.

Below is an introduction to its positioning, core capabilities, installation methods, and typical usage.

What is it

WeirdSky924/project-change-router-skill is an AI coding skill for large repositories, usable in Codex, Claude Code, and DeepSeek Harness. It is maintained by WeirdSky924 and licensed under MIT.

Its one-sentence positioning is:

Project-level direction, boundary, and reuse governance for AI coding agents.

It is not a substitute for detailed code reading, dependency tracking, test design, and architecture analysis, but rather provides a set of verifiable project-level constraints before coding:

  • Generates a local project-change-router/ bundle for the target repository.
  • Identifies repository modules, capabilities, owners, public entries, path ownership, and dependency directions.
  • Outputs a route report based on the request and changed paths, including strong constraints and recommended actions.
  • Normalizes gate evidence into traceable typed findings and determines the execution_gate using versioned rule tables.

Here is a key boundary: action is for handling suggestions and investigation directions, not final architecture commands. Writing state must read execution_gate.state; action=review itself does not grant or revoke write permissions.

Core Capabilities

Routing and Gates

This plugin separates “routing suggestions” from “writeability.”

It can orchestrate the following checks using run_change_flow.py:

  • route
  • freshness
  • dependency
  • public API
  • structure
  • governance
  • reuse

Gate states are expressed through the execution_gate. Based on verified facts, three states need to be distinguished:

  • blocked: Prohibit product code writing when there are blocking items.
  • conditional: required_commands must be executed first, and writing is restricted within a given envelope.
  • pass: Writing is allowed, but it also cannot cross the envelope.

The compact output retains security envelope fields, including:

execution_gate
veto_reasons
allowed_write_paths
forbidden_write_paths
unknown_evidence
artifact_path
artifact_digest
output_complete

These fields are used to express whether the current request can continue to write, which paths are allowed, which paths are forbidden, and whether the evidence is complete.

Checks and Evidence

The plugin performs guardrail checks on multiple issues that easily cause structural drift, including:

  • Duplicate implementation
  • Wrong boundaries
  • Public API bypass
  • Reverse dependencies
  • Runtime cycles

It also uses the following materials to validate freshness:

  • commit
  • content structure summary
  • index paths
  • stale entry
  • actual changed paths

For repository structure growth, it uses an exact baseline to prevent new net growth of the following types:

  • Central files
  • 800/1200 line files
  • Disabled implementation roots
  • Second canonical owner

It also provides the following auxiliary checks:

  • Validates bundle and report using schema.
  • Checks if routing quality degrades using an evaluation set.
  • Checks profile/catalog synchronization, ownership granularity, contract quality, forbidden density, evaluation coverage, and capability lifecycle using a governance audit.
  • Exposes path ownership, shared ownership, and uncovered modules via path-to-capability-map.yaml.

Output and Integration

By default, the plugin supports compact security envelope output and saves full evidence as a content-addressed artifact. This allows retaining fully traceable evidence while keeping token costs low.

It also supports the following output controls:

  • --format full-json: Returns the full report.
  • --format artifact-reference: Returns a minimal reference.
  • --field: Can only add ordinary fields.
  • --exclude-field: Cannot hide security fields.

In terms of agent integration, it supports:

  • Appending hint blocks when installing in Codex and Claude Code.
  • Exposing trigger descriptions via the DeepSeek Harness skill catalog.

Installation and Activation

Python requirements:

Python >= 3.10

DeepSeek Harness plugin validation follows Harness’s current Node requirements:

^22.19.0 || >=24.0.0

Only installing the filesystem skill does not launch an additional Node process.

First, install dependencies:

pip install -r requirements.txt

Or install using development mode:

pip install -e .[dev]

Then install to Codex, Claude Code, and DeepSeek Harness simultaneously:

python scripts/install_skill.py --target all --inject-hints

Installation paths are as follows:

  • Codex: %USERPROFILE%\.codex\skills\project-change-router
  • Claude Code: %USERPROFILE%\.claude\skills\project-change-router
  • DeepSeek Harness: $DSH_HOME/skills/project-change-router
  • When DSH_HOME is not set, DeepSeek Harness defaults to: ~/.dsh/skills/project-change-router

--inject-hints only appends marker blocks to Codex and Claude Code when rule entry hints are needed; it will not rewrite the entire file.

Typical Usage

Run the change flow below with a request and a changed path:

python scripts/run_change_flow.py --repo <repo-root> --request "Add invoice refund support" --changed-path services/billing/refund.py --format compact-json

This command generates a route report based on the request and modified paths. The default compact output retains security envelope fields:

execution_gate
veto_reasons
allowed_write_paths
forbidden_write_paths
unknown_evidence
artifact_path
artifact_digest
output_complete

If you need to view the full report, you can use:

--format full-json

If you only need a minimal reference, you can use:

--format artifact-reference

If using --field or --exclude-field, be aware that:

  • --field can only add ordinary fields.
  • --exclude-field cannot hide security fields.

During actual processing, it is recommended to first check execution_gate.state to determine if writing can continue:

  • When blocked, product code writing is prohibited.
  • When conditional, required_commands must be executed first, and writing is restricted within the given envelope.
  • When pass, you also cannot cross the envelope.

Scenarios and Considerations

This plugin is better suited for the following scenarios:

  • In large repositories where the agent cannot read the entire project completely every time.
  • Repositories containing multiple modules, capabilities, owners, and public entries.
  • Need to prevent duplicate implementation, wrong boundaries, public API bypass, reverse dependencies, and runtime cycles.
  • Need to add routing checks before changes in Codex, Claude Code, or DeepSeek Harness.

Considerations:

  • It does not replace detailed code reading, dependency tracking, test design, and architecture analysis.
  • It outputs routing suggestions, strong constraints, and evidence, not final architecture commands.
  • action=review itself does not grant or revoke write permissions; writing state must read execution_gate.state.
  • DSH plugins run with the permissions of the current dsh process, so you should check the source code, script behavior, and MIT license before installing.

Conclusion

The value of WeirdSky924/project-change-router-skill lies in adding a layer of project-level change constraints to AI coding agents: before writing code, confirm capability ownership, path boundaries, dependency directions, reuse risks, and the write gate. For large repositories, this helps transform “just write it” into “check evidence first, then decide to write.”

Related pages:

  • Directory page: https://www.skillhub.cn/plugins/WeirdSky924/project-change-router-skill
  • GitHub: https://github.com/WeirdSky924/project-change-router-skill