The history of nop-chaos-flux has already recorded this kind of drift multiple times. Workstream 8 of docs/plans/436-deep-audit-2026年05月24日-full-remediation-plan.md fixed an active-doc drift: the documentation described component:open/close/toggle, component:refresh, the old package split, old source anchors, and an outdated component inventory as current facts, while the live repo was no longer like that. docs/logs/2026/05-26.md recorded a proof drift: the E2E tests still asserted that the spreadsheet's 30 row headers were mounted simultaneously, while the live spreadsheet shell had already been virtualized, so the correct proof could only assert that visible row headers were mounted. Code, documentation, and tests might each be locally reasonable, but the owner/proof/precedence relationships among them had already drifted.
Thus, the basic premise of AGE is:
Repository = Source of Truth
Chat = Transient work surface
Under this premise, the core question is not:
Did the Agent invoke the right skill this time?
but:
After many Agent perturbations, does the repository still converge in a controlled manner along the domain structure?
The basic picture of AGE is:
State space -> Attractor -> Trajectory -> Control
The state space here is not the "source code state space." Source code answers what the current implementation is, but it cannot alone answer where the system should converge, why a certain design is valid, which behavior has been proven, why a certain deviation was accepted, and from where the AI should recover context next time.
AGE is concerned with the state of the entire repository engineering reality: source code, tests, owner docs, requirements, plans, logs, bug notes, schemas, XML models, database models, XDSL, AGENTS.md, docs/index.md, CI configuration, and audit evidence together constitute a state.
These are not several separable materials, but the distribution of the same set of semantic commitments across different carriers. Code has authority over implementation facts; owner docs have authority over convergence direction; tests have authority over proven behavior; logs/bug notes have authority over the evolution trajectory; plans/audits have authority over whether the current cycle of changes is closed. What AGE must maintain is the relationships among these authorities, not the sanctification of any single file format.
A Skill occupies a different position. AGE organizes the repository itself; skills are external capabilities or control inputs that act upon the repository.
External capabilities can change the system, but they cannot replace the internal structure of the system. A bug-diagnosis skill can be used in many repositories, many domains, many bug types. Its organizing logic is general task capability, not the topology of domain concepts inside a specific repository.
What truly needs to be preserved inside the repository are the relationships among source code, documentation, tests, models, plans, logs, and audit evidence — relationships such as owner, proof, precedence, and freshness. Skills can help modify these things, but they cannot replace the relationships themselves.
At this point, we realize that the skill’s semantic hash is insufficient to solve the problem. What a skill stores is:
task intent -> capability package
What AGE needs to preserve is:
domain concept -> semantic commitment -> implementation location -> proof evidence -> audit/memory -> subsequent obligations
These two structures are not the same. A skill can tell an Agent how to review, but it cannot automatically know which owner doc holds the current semantic fact. A skill can tell an Agent how to write tests, but it cannot automatically know which domain commitment this test protects. A skill can tell an Agent how to update documentation, but it cannot automatically determine whether a piece of information should go into an owner doc, a bug note, a log, a lesson, a reference, or a skill.
These judgments are not invocation capabilities; they are the semantic authority structure of the repository.
5. Why age-skill Is a Wrong Abstraction
Turning AGE into an age-skill is superficially tempting: take AGE’s rules, procedures, checklists, and document templates and write them into a callable capability package. When the Agent needs AGE, it loads this skill.
But this places AGE at exactly the wrong level. A skill is a capability package that is matched and loaded after a task occurs; AGE should be the repository structure that already exists before the task begins. It determines how the task is understood, where information is read from, whose voice prevails in a conflict, and how closure is proved after completion.
AGE cannot wait to appear only after a certain skill is selected. It should already be embodied in:
- The operational boundary of
AGENTS.md
- The routing structure of
docs/index.md
- The fact ownership of owner docs
- The conflict rules of source-of-truth precedence
- The obligation declarations of plans
- The proof relations of tests
- The closure gates of audits
- The trajectory memory of logs, bug notes, and lessons
- The action constraints of freshness/autonomy
If these relationships exist only inside an age-skill, they are not repository structure but merely the content of a procedure bundle. Whenever the Agent does not match this skill, or the skill conflicts with the live repo, AGE becomes ineffective.
Making age-skill an always-on or global skill does not solve this problem either. At best, it can prescribe "read these owner docs first, check precedence this way, do a closure audit like that." But the real owner, proof, precedence, and freshness relationships must still exist among the repository’s files, tests, logs, plans, and audit evidence.
So the problem is not whether age-skill is loaded every time; the problem is that a skill is still a capability package imposed on the repository from the outside. AGE must become the underlying topology of the repository itself. As long as owner, proof, precedence, and freshness are not internalized as repository state, AGE is demoted to an external operating method rather than an intrinsic convergence structure.
6. The Missing Concepts That AGE Supplies
Under the image of controlled convergence and structure preservation, what AGE supplies is not a new checklist, but a set of first-class system concepts that skill-ification practices lack.
1. Attractor
To what structure should the system return in the long run? This cannot be decided by any single skill. It needs to be carried by owner docs, architectural baselines, domain design, and source-of-truth precedence. Without an attractor, a skill can only tell the Agent how to do things; it cannot tell the repository where it should converge.
2. Trajectory
Completing a single task does not mean the system direction is correct. Logs, bug notes, lessons, plans, and audit records record how the repository arrived at its current state step by step. Without trajectory memory, the AI starts anew from a local cross-section each time, making it hard to judge whether the system is converging or drifting.
3. Semantic Authority
When a skill, plan, code, test, and documentation disagree, whose voice prevails? AGE requires owner, routing, and precedence, rather than letting the currently invoked skill adjudicate on the fly. Semantic authority is not part of the execution steps; it is the internal order of the repository’s state space.
4. Proof Relation
It is not enough for tests to "have coverage." Tests must declare which semantic commitment they protect. Audit is not a checklist, either, but an examination of whether commitments have disappeared, weakened, or migrated to non-authoritative carriers. Proof relation makes verification not just about passing commands, but about returning to domain commitments.
5. Freshness / Autonomy
Documentation is not eternally trustworthy just because it was written. Whether a document is fresh affects whether the AI can act on it, how far it can go autonomously, and when it must stop and ask a human. Freshness/autonomy turns "can we trust this, can we do this automatically" into a visible state of the repository, rather than an ad-hoc judgment inside a single session.
6. Structure-Preserving Document Routing
AGENTS.md can provide the AI with a compact operational entry point, and docs/index.md can provide complete routing. The purpose of both is not to cram all knowledge into a single file, but to let the AI progressively open the right information according to the task’s needs. Information disclosure can be layered, but the domain structure must not be fragmented.
These concepts together form the semantic authority topology of AGE.
7. AGE Can Use Skills, But Cannot Become a Skill
AGE is not opposed to skills. Skills are excellent execution scaffolds.
But within AGE, skills can only be method nodes; they cannot be the source of truth, nor can they be AGE itself.
The correct order is:
First, find the route via AGENTS.md / docs/index.md
Then, read the domain or architectural owner doc
Then, read the active requirement / plan / audit evidence
Finally, select the appropriate skill as the execution method
Not:
First, select a skill, then let the skill decide fact ownership
For example, a bug diagnosis skill can tell the Agent how to reproduce and locate a problem. But which domain concept the root cause belongs to, which owner doc needs updating, which test proves the fix, and which category of regression the bug note will constrain in the future — all of these must be decided by returning to the semantic topology of AGE.
A good skill accelerates execution. Bad skill-ification replaces domain structure with execution methods.
8. Judgment Criteria
To judge whether a set of AI engineering practices is over-skill-ified, ask:
- Does it organize knowledge primarily by operational verbs, or by domain concepts and architectural ownership?
- Are its links mainly execution resource references, or owner / invariant / proof / precedence / freshness relationships?
- After information is transformed between skills, plans, code, tests, docs, and logs, can the domain structure still be recovered?
- If all skills are deleted, does the repository still know what is correct, who owns it, and how to prove it?
If the answers are negative, skills have already taken on attractor responsibilities they should not bear.
The ultimate distinction can be compressed into a single sentence:
Skill packages capabilities by invocation.
AGE preserves domain structure across transformations.
Skills make the Agent better at doing things. AGE ensures that after the Agent does things repeatedly, the repository still converges in a controlled manner along the domain structure.
AGE Application Development Template