code-asset-inventory
Skill0 starsChanged 3 days agoMITView on GitHub
Code asset inventory and functional reuse standard. Requires checking existing modules, functions, utilities, and actual implementations before development, and building a searchable capability index.
In this repository17 other files it gives its agents.
- .cursor/rules/engineering-context.mdcCursor rule
- change-report-deliverySkill
- data-audit-reproducibilitySkill
- data-first-executionSkill
- documentation-structureSkill
- engineering-context-completenessSkill
- engineering-transparencySkill
- explicit-instruction-fidelitySkill
- interface-contractSkill
- language-expressionSkill
- production-loggingSkill
- repository-publication-hygieneSkill
- task-execution-governanceSkill
- technical-documentationSkill
- testing-verificationSkill
- unfinished-work-trackingSkill
- user-intent-prioritySkill
The file
We split this skill into the rules it gives an agent
12 rules. About 0 are common, 12 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈12
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 15
Before developing a new feature, existing capabilities must be understood first.
- Distinctive: line 68
Before adding a new implementation:
- Distinctive: line 71
Search for similar files.
- Distinctive: line 72
Search for similar functions.
- Distinctive: line 91
Only create a new implementation after confirming that reuse is impossible.
- Distinctive: line 93
If a new implementation is decided on, it must state:
- Distinctive: line 110
If different business scenarios genuinely require different implementations, their applicable scope and differences must be clearly stated.
- Distinctive: line 114
After adding, modifying, or deleting an important module or function:
- Distinctive: line 116
Update the module list.
- Distinctive: line 117
Update the function index.
- Distinctive: line 118
Update parameters and return values.
- Distinctive: line 123
If the project already has an automatic indexing tool, it should be used preferentially.
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Code Asset Inventory and Functional Reuse Standard
I. Core Principle
Code in a project is a capability asset that can be searched, understood, and reused.
It is not enough to know which files a project has; it is also necessary to know which functions are already implemented inside those files.
Before developing a new feature, existing capabilities must be understood first.
II. Inventory Scope
At minimum, include:
- Python scripts.
- Other program files.
- Public modules.
- Utility functions.
- Classes and methods.
- API clients.
- Data processing programs.
- Validators.
- Data models.
- Workflow nodes.
- Configuration and rule files.
- Test code.
III. Code Asset Index
A project should maintain a unified code asset index.
Important modules should record at least:
- File path.
- Module name.
- Module responsibility.
- Main functions.
- Function purpose.
- Input parameters and types.
- Return value and structure.
- External dependencies.
- Call relationships.
- Whether it can be reused.
- Current status.
Important functions should record at least:
- Function name.
- Containing file.
- Actual function.
- Parameters.
- Return value.
- Main processing steps.
- File read/write behavior.
- Call sites.
- Whether side effects exist.
The index should preferentially have its basic information generated automatically, with business meaning added by developers.
IV. Mandatory Search Before Development
Before adding a new implementation:
- Inspect the relevant directories.
- Search for similar files.
- Search for similar functions.
- Inspect public modules.
- Inspect the actual function implementations.
- Inspect existing call relationships.
- Inspect whether existing capabilities can be combined.
- Inspect the limitations of existing implementations.
It is forbidden to judge whether two functions are identical based only on file names or function names.
The actual implementation must be read.
V. Reuse Priority
Decide in the following order:
- Reuse the existing function directly.
- Extend the existing function.
- Combine multiple existing functions.
- Extract common logic.
- Only create a new implementation after confirming that reuse is impossible.
If a new implementation is decided on, it must state:
- Which existing implementations were inspected.
- Why they do not meet the requirement.
- The responsibility difference between the new implementation and the existing ones.
- Why extending the original implementation is not appropriate.
VI. Duplicate Implementation Is Forbidden
Forbidden:
- Copying an existing function and changing only a small amount of code to form a new version.
- Implementing the same common logic separately in multiple modules.
- Concluding that functions differ in function merely because their names differ.
- Bypassing an original implementation because it is unfamiliar.
- Creating a new utility without first checking existing capabilities.
If different business scenarios genuinely require different implementations, their applicable scope and differences must be clearly stated.
VII. Code Asset Index Updates
After adding, modifying, or deleting an important module or function:
- Update the module list.
- Update the function index.
- Update parameters and return values.
- Update call relationships.
- Update module responsibilities.
- Mark implementations that have been deprecated.
If the project already has an automatic indexing tool, it should be used preferentially.
The index must not be manually fabricated without checking the actual code.
VIII. Pre-Completion Checks
- Were existing related modules checked?
- Were actual function implementations read?
- Were similar functions checked?
- Was reuse considered first?
- Does duplicate implementation exist?
- Does the new feature have a clear responsibility?
- Is the index consistent with the actual code?
IX. Final Principle
Adding new code is not the default choice.
Understanding existing implementations and making full use of existing capabilities is the starting point for developing a new feature.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

