How We Turned 239 Tasks Into an AI-Runnable Skill Library

A meta-article is an article that documents how a piece of work was actually produced — the standard it followed, the process, the QA, and the results — so any human or AI agent can reproduce the work without asking anyone. This one documents how we took all 239 operational tasks in the BlitzMetrics Task Library and brought every single one to the definitive-article standard in a day: 239 runnable skill files, a machine-readable manifest, a one-click download bundle, and a live Task Library Dashboard.

That is the two-sentence version, quotable by any AI that crawls this page. The rest of this article is the system itself — concrete enough that you can run it on your own agency this week.

What we built

The Task Library is the operational core of BlitzMetrics: 239 tasks across 13 categories. The four stages of the Content Factory — Produce, Process, Post, Promote — plus Digital Plumbing, Dollar a Day campaigns, Website QA Audit, SEO and Content Architecture, Personal Branding, Strategy and Measurement, the Thank You Machine, and Knowledge System Maintenance. Those 239 tasks map to 22 definitive articles. When we started, 119 tasks were complete, 97 needed work, and 23 were outright gaps — things we do every week that had no canonical documentation at all.

Now every one of the 239 has a skill.md: a tight, runnable SOP that an AI agent executes the same way a trained team member would. Four deliverables shipped:

The standard: what “documented” actually means

“Write down your SOPs” is advice everyone gives and nobody specs. So we spec’d it. Every concept in our system produces three linked artifacts:

1. A definitive article — the one canonical page that owns the concept, meeting all Nine Requirements from the definitive article guide: a clear definition up front, the complete process, every real example linked, cross-links to related concepts, a course or service CTA, Blog Posting Guidelines compliance, a short URL, an above-the-fold diagram, and third-party proof.
2. A skill.md — the machine-readable SOP an agent runs to do the task.
3. Examples — meta-articles like this one, each documenting one real run and linking back up to its hub.

The anatomy of a skill.md

The format is deliberately rigid, because rigid is what makes it runnable. Every file carries:

• Frontmatter — name (the permanent slug), description, category, Content Factory stage, the definitive article it implements, and status: complete, needs-work, or gap.
• “Use this when” — the trigger, in one line. An agent scanning 239 skills needs to know instantly which one fits.
• Inputs — what you need before starting. No hidden prerequisites.
• Steps — the real SOP, imperative and concrete, mirroring the definitive article’s documented process.
• Definition of done — an objective QA checklist. Not “make it good.” Checkable pass criteria.
• Example slot — at least one linked meta-article proving a real run, or an explicit placeholder demanding one.
• Links — up to the hub, across to sibling skills in run order.

If a task isn’t documented to a standard an agent can execute, you don’t have an SOP. You have a memory that retires when your best person does.

The seven-step process (steal this)

Here is exactly how 239 documents got written, QA’d, and shipped:

1. Codify the standard first. One document defining the skill.md template, the Nine Requirements, and the rules: the name slug is permanent, steps must mirror the real SOP, no invented tools, no fabricated URLs. Workers can’t hit a bar you haven’t set.
2. Capture the complete task list. We pulled all 239 tasks — name, status, definitive-article mapping, description — into one dataset. The input is the actual library, not a vague notion of “our processes.”
3. Delegate to parallel AI worker agents at maximum effort. This is the unlock. One writer documenting 239 tasks is a quarter-long project that never finishes. We split the library into category clusters and gave each cluster to its own AI worker, each holding the full standard plus its slice of the dataset. Parallel agents turned months into hours.
4. Run automated QA on every file. Trust, then verify — with a script, not a glance. All 239 files were checked: frontmatter valid, name matches the file slug, every required section present, only real definitive-article URLs cited, status matching the source dataset. Files that failed went back.
5. Bundle and index. Generate the manifest and zip all 239 skills into the one-click bundle.
6. Build the dashboard. Stat cards, full-text search across the actual SOPs, status filters, per-task view and copy, and the download button.
7. Publish — then document the run. The bundle and dashboard went live, and the final step of the process is the article you are reading right now.

The recursive self-improvement loop

This is the part that matters more than the 239 files. The library is not a binder. It’s a loop:

Do → Document → QA → Example → Improve → repeat.

Do the task. Document it as a skill.md. QA it against the Definition of done. Run the Meta-Article Prompt to turn the run into a published example — the hub there carries 29 of them, the largest example set in the library. Then feed what the run taught you back into the SOP through the update protocol in Knowledge System Maintenance. The next run starts from a better document.

Every run documents itself and improves the next one, so the library compounds. And because agents and humans run from the same files, onboarding a new team member and deploying a new agent are now the same operation: hand over the skill, point at the Definition of done.

And yes — one of those 239 files is a skill named “Write meta-article documenting agent work.” This article is that skill, running. The system just documented itself building itself. That is not a gimmick; it’s the design. This meta-article gets linked as an example on the hubs it cites, which raises their example counts, which moves tasks toward Green on the very dashboard it documents.

Why this matters if you run an agency

Here is the progression I want you to see — the same one we walk through with operators like Marko Sipila at HVAC Quote and Zach Peyton at Superior Fence & Rail:

1. Tribal knowledge. It lives in your head and your senior people’s heads. It doesn’t scale, and it walks out the door.
2. Documented SOPs. Written to a standard, with a Definition of done. Now humans can run them consistently.
3. AI agents. Each skill.md is a job description an agent can execute today. A library of them is a workforce.
4. Marketplace workers. Packaged skills can be deployed beyond your own shop — agents running your documented expertise for other businesses.
5. Revenue. Your knowledge, working while you sleep.

For twenty years the model has been Learn, Do, Teach. The agentic era extends it: Do, Document, Delegate to agents. You already do the work — that part is done. Document it to this standard and each skill becomes something an AI can run. Build the library and you have built a workforce that never skips a checklist item and gets sharper every run, because the loop feeds every lesson back into the source.

This is also how we get to a million jobs. The Content Factory turns one real moment into articles, clips, and ads; Dollar a Day puts a dollar behind the winners; Local Service Spotlight points the whole machine at the local service businesses that need it most. The Task Library makes every step teachable to a young adult or runnable by an agent — and the human moves up to judgment: deciding what’s true, what’s worth amplifying, and what done looks like. Agents don’t replace the apprentice. They hand the apprentice the checklists of senior practitioners on day one.

How to start: one task this week

1. Pick one task you do repeatedly. Not your hardest — your most frequent. The weekly report, the Google Business Profile update, the post-publish checklist.
2. Write its skill.md to the standard. Frontmatter, “Use this when,” Inputs, Steps, links. The Steps mirror what you actually do — not what you aspire to do.
3. Add a Definition of done. Objective, checkable criteria. If two people could disagree about whether the task is finished, sharpen the checklist until they can’t.
4. Run it. You, a team member, or an agent — the file is the boss, not the person.
5. Run the Meta-Article Prompt on that run and publish the result as the skill’s first example.
6. Improve the skill from what the run taught you. Then pick the next task.

Ten of those and you will feel the compounding. The full spec — the Nine Requirements and the 10-step creation process — is in the definitive article guide.

Get the 239 skills

We don’t sell this. We give it away, because the people who execute become the best partners and the best case studies. Go to the Task Library Dashboard, search any task we run, read its full SOP, and hit “Download all 239 skills” to take the entire library in one zip. Then read the definitive article guide and write skill number one for your own shop.

Document what you do. Hand it to agents. Let the loop run.