Commits
A registry that doesn't depend on anyone remembering it
The registry is split into two layers: capture and publication
A registry that doesn't depend on anyone remembering it
The registry is split into two layers: capture and publication
decision
For a long time, I had one skill that published to the web and another that wrote down notes by hand. Their names were almost identical—one with a hyphen and the other without—and that is a time bomb: two entries in the index that are immediately mistaken for each other. Now there are two names that say what they do. One captures the work in a journal within the same project; the other turns that journal into the day's article on the website. The second layer accepts the journal directly, so the work is not written twice: it is written once and published.
Copies of a shared skill diverge on their own
bug
Copying a skill to three profiles is a one-time action, not a rule. As soon as one profile edits its copy, they diverge: the index shows two entries, and which one loads depends on who is using the machine. The warning already existed and was good—it showed the diff, not a hash—but the step that actually fixes the problem was missing. Now the source of truth is a file in the repository, there is an installer that distributes it, and there is a check that reports, without writing anything, which copies have fallen behind. I verified this by deliberately breaking one copy: the mechanism flags it with the diff, and after installation, it matches the canonical copy again.
The journal fills itself with every commit
milestone
Until now, the journal was written by hand, which is exactly how a registry ends up abandoned by the second week. Now every commit leaves its own entry automatically, with a Git hook that works the same way from any tool. It relies on two details that only become apparent through testing: the first commit in a repository does not list its files unless you ask it in a different way, and an empty commit has no files but is still a commit. And it has a brake: if the commit touches only the journal, it does not generate a new entry, because otherwise the registry would never stop getting cluttered.
The commit is aborted if the journal contains private data
milestone
The journal lives in the project's repository, and a repository may end up being public. The hook that writes the journal writes to the working tree, which is precisely where private data can slip out unnoticed. Detecting it afterward is of little use if it is already inside the repository. So now, before each commit, the journal is reviewed and, if it contains an email address with a real domain or a network IP address, the commit is aborted. If the project already has its own auditor, that auditor is used; otherwise, a minimal shape-based filter is applied. Example addresses that appear while documenting an attack the application blocks are not treated as sensitive data: documenting the bug being fixed is not leaking it.