In the previous post I said that the defenses we bought with real incidents eventually turned into eight concrete SKILLs. This post explains how to use those eight.
Before I unpack them, one premise has to be settled: the tools serve the project specification document (ProjectSpec), because that document is the first-class citizen of the whole system. It is not only a document asset for people to read; it is a machine contract for AI to read. Its three layers, project, module, and feature, are kept strictly apart, and every hard constraint carries a number, so each one can be located and checked precisely.
Why did this end up as eight SKILLs and not some other shape? Because those eight cover every stage from design to development to review. When I reach for one, I want to choose with a clear purpose in mind, not scan a long list.
Why do these eight actions have the shape they do? The reasoning behind them is all here.
1. The issue chain: holding the line between conversation and the record
The most natural way to drive an AI is conversation, but conversation drifts badly. If the first step is to let the AI edit documents directly, the code and the docs will soon be unrecognizable. The four SKILLs in the issue chain exist to contain the loss of control between a discussion and a written record.
spec-start: fixes the problem of AI conversations that drift aimlessly. The judgment behind it: the agenda is the anchor. Without a list of open decisions that can be closed one by one, there is no way to tell whether the discussion is really over, and nothing to track afterwards.
spec-pause: handles running out of context, or picking the discussion up again later. The judgment behind it: saving progress is not the same as changing the design. It keeps a detailed session log along the way, and does not touch a single project document until a decision is formally settled. One caveat: this one is rarely used, and only when a discussion has to span more than one AI session.
spec-close: gets a discussion out of the meeting and into a document. The judgment behind it: a meeting is not over when the talking stops; it is over when each decision has been put into the right place in
ProjectSpec. A decision written at the wrong layer is worse than one never written, because it looks authoritative.spec-archive: clears up the aftermath of an abnormal interruption that left dirty state behind. The judgment behind it: a fallback tool must have narrower permissions than the normal path. It only moves state around; it never goes beyond that to delete or modify a file.
What these four SKILLs protect is the core methodology from the second post: settle where the contract lives, layer by layer. They make sure every action knows which things it should write and which things it must never write. In practice, though, only spec-start and spec-close see regular use.
2. The delivery chain: keeping design and implementation from forking apart
A design is never perfect, and mid-development you will always hit places that need adjusting. Insist on building exactly to the design and the mistakes get baked in; let the AI change whatever it likes and the code and the docs will fork. The four SKILLs in the delivery chain are there to open one controlled gap between those two extremes.
spec-dev-loop: fixes the problem of an AI that takes a requirement and starts writing at once, then declares its own work correct. The judgment behind it: freeze the code skeleton first, then hand out the actual implementation. The main Agent holds the whole picture and does the acceptance check; it does not take a subagent's word that the work is finished. This is probably the most complex of all eight. It starts a design review first: if it sees a conflict in the design, or a description it finds unclear, it asks the user and records the questions in the development log. Once development really begins, it checks the branch state of the local repository, opens a new branch prefixed
dev-loop/, and makes every change on that branch. When the main Agent has finished acceptance and committed the changes, it notifies the user to review and asks them to merge the branch by hand.spec-code-review: fixes the case where the design is changed during development and the docs go stale. The judgment behind it: a code review is not a score for the code; it puts the evidence of a mismatch in front of a person. That is where the decision belongs: change the code, or change the document. It is also the only route by which documents get synced back from code.
spec-code-smell: deals with code quality. The judgment behind it: a code review only settles whether the implementation matches the design, while bad smells are the natural enemy of code quality itself.
spec-smart-git: fixes the everything-in-one commit that cannot be rolled back on its own. The judgment behind it: commit granularity now is rollback granularity later. Split by logical intent, never by how much work this session happened to cover.
What these four protect is the other half of the core idea from the second post: constraints have to be executable. They turn "the AI says it got it right" into "here is evidence a machine can check".
3. The honest limits
These eight SKILLs are not a full-lifecycle bundle assembled for completeness; each one is a defense built for a particular stage. It is worth knowing what they can do, and knowing even more clearly what they do not solve:
They do not replace human judgment: deciding which conventions count as hard constraints, or which of two architectures to pick, is still on you. A SKILL only guarantees that what has already been decided is not worked around; it does not guarantee that you thought it through. That is why we refuse to add one-click execution to them.
They do not guarantee the design is correct: they can only surface drift and mistakes earlier. Fixing them still needs a person to make the call (which is also why code review has to be a human decision).
They do not interfere with the release process more than they have to: different engineering teams have their own CI/CD rules, and a package should stay out of those internal flows as far as possible. Being able to run independently matters.
4. Running the first Loop in 30 minutes
Having read this far, I still would not send you straight into the long documentation. The fastest way in is to spend 30 minutes getting one minimal Loop to run.
Initialize the project and load the SKILLs, then open an issue, talk through one small decision, save once, and close once. In that minimal pass you will see for yourself how the agenda gets confirmed, how the discussion gets sealed away, and how the decision finally lands in exactly the right layer of the document. The point of the Loop is not to exhaust every feature; it is to find out whether this way of thinking meshes with your real project.
The full eight-SKILL package and its GitHub address are now officially open source: https://github.com/13813385093/dockit.git
The readme at the repository root is the full, working implementation of the methodology from the second post.
That is the end of the introduction to this software development package. It is only about how one single feature gets implemented faithfully. But zoom out: the package makes one Agent run as expected. Getting 10 Agents to work in parallel moves the question to another level. Who is allowed to talk to whom? How is context managed? How do you define the job of each different Agent? Can Agent A and Agent B work on the same task together? And how do you keep the costs from spiraling?
Next time I want to talk about what lies outside the package.
Top comments (0)