When Every Lane Started at Zero

The first certification lane I built this way was AIF-C01. The process worked, but the conversation was fragmented. I would first settle on the exam and certification code, then come back with another prompt for the study topics, another for the question bank, and still more prompts when review and QA exposed gaps or bugs.

None of those steps was surprising on its own. The tedious part was having to reconstruct the full method every time: capture the official blueprint, write the curriculum, author the questions, review them, validate the lane, and prepare a release. Because the method lived in the prompt history rather than in the project, each new lane meant explaining the same intent again and rediscovering the same sequence in a slightly different order.

That was manageable for one lane. As the catalog grew, it became a source of variation. A check that was prominent in one conversation could easily become an afterthought in the next.

The Workflow Was the Reusable Part

Eventually the repeated prompts stopped looking like separate requests and started looking like one procedure. The certification changed, but the shape of the work did not. That was the signal to move the method out of my memory and into the project itself.

I encoded it as the add-cert-lane skill in the exam-prep project. Now I can say "add a new lane", provide the certification name or code and its official exam page, and add special instructions only when the lane genuinely needs them. The agent loads the rest of the operating method for itself.

A Skill Is a Small File with a Large Contract

The implementation is deliberately plain. The project contains .claude/skills/add-cert-lane/SKILL.md, a Markdown file with YAML frontmatter for its name and description. The description is not just a summary. I wrote it as a trigger condition: invoke the skill whenever a request asks to add, build, or create a certification or exam lane and includes a certification name, code, or official page.

That detail makes the workflow self-selecting. I do not have to remember a slash command or remind the agent that the skill exists. The ordinary request contains enough context for Claude Code to recognize the match and load the instructions automatically.

The body of the file carries the real weight. It turns the accumulated prompt sequence into a numbered method, from Phase 0 through Phase 7, and gives every phase a concrete definition of done. The process no longer advances because the work merely looks plausible; it advances when the stated bar for that phase has been met.

From Discovery to Release, in Order

The phases begin by discovering the provider conventions already present in the repository. Before any content is written, a hard currency and retirement gate confirms that the certification is still viable. Only then does the workflow capture the official blueprint into governance artifacts such as BLUEPRINT.md, SOURCE_MAP.md, LEVEL_CALIBRATION.md, and FRESHNESS_MAP.md.

Next comes question planning before authoring, followed by curriculum and question-bank generation. The author and reviewer are kept separate, and the reviewer derives answers independently before seeing the author's key. After that, the lane is wired into the shared registry, validated, and held behind a final release gate.

The skill also owns its worker routing. Repository discovery goes to a discovery worker, implementation to an implementer, prose and learning material to a content editor, correctness to an independent cross-provider reviewer, and the final decision to a release reviewer. That assignment is part of the method instead of an ad hoc choice made halfway through a run.

The Stops Matter as Much as the Steps

A reusable process needs to say when it must not continue. The skill halts if the certification is retired or superseded, if authoritative sources cannot be reconciled, if the reviewer's independently derived answer disagrees with the author's key, or if the release gate fails.

Those conditions turn quality concerns into control flow. A disagreement is no longer something that can disappear inside a long conversation or be deferred until after publishing. It surfaces at the phase where it can still prevent a bad release.

What Became Automatic

The important gain is not merely fewer prompts. It is that the short prompt now expands into a complete, repeatable build with the same controls each time.

The General Lesson

When I notice myself issuing the same chain of prompts, I now treat that repetition as design input. Turning the chain into a self-invoking skill removes the tax of explaining the method again, but it also removes something more dangerous: the chance that a familiar step is skipped because nobody remembered to ask for it this time.