Credential · Builders · 8 clock hours

Advanced AI AutomationSet it up. Check it. Let it run.

You already built one automation. This is how you make it something you can trust and leave alone. We build every piece together first, on a practice project left messy on purpose, so the checking agents find real problems. Then you do the same piece on yours: set it up so any agent can pick it up cold, give it a team of agents that check its work, and let it run on its own, with an off switch and $0 of cost when nothing's happening.

Hands-on training using Claude Code

Requires the AI Automation Builder Certificate

Plan training How it's earned

The credential at a glance

Credential: Advanced AI Automation Certificate
Type: Certificate
Clock hours: 8
Format: Four 2-hour build sessions, in person
Schedule: One 2-hour session a week, or two 4-hour half-days a week apart
Price: $1,000 a seat, invoiced after the last session
Class size: 8 to 15 people
How it's checked: Six checks on the work itself, a live demo and a 20-question quiz
TechCred: Listing in progress. Reimbursement isn't guaranteed until the state lists it.
Issued by: Paglow Automations (Ohio AI Solutions LLC), Lima, Ohio
Before the first session: The AI Automation Builder Certificate (or Jayson's OK after a 15-minute call showing a working automation).
A Windows or Mac computer with Claude Code installed in the terminal, and git installed.
A paid Claude plan that includes Claude Code, opened by the employer before session 1.
The automation you built in the AI Automation Builder (or a new bottleneck picked with a manager).

For TechCred

What a holder can do

This is the list the state reads. TechCred pays for hands-on skills in developing, building, configuring or operating technology, so every skill below ends in something you built, set up or ran, and I check the evidence myself.

Build

Make the thing that does the work.

Build an agent wiki: playbooks and lessons-learned pages, with at least one rule written from a real mistake.
Evidence: Wiki pages and the rule traced to its mistake
Package repeatable jobs as skills and specialist agents with only the tools they need.
Evidence: Two skills and two custom agents, each run by a classmate
Write tests first from known answers, watch them fail, protect them from edits, and build until they pass.
Evidence: The failing-then-passing test history and the deny rule or hook

Configure

Set the rules it runs under.

Organize an automation project so a fresh AI agent can pick it up cold: CLAUDE.md under 200 lines, one topic per document, a "where truth lives" table.
Evidence: The project folder and a cold-start test (a fresh agent answers five questions correctly from the docs)
Choose, review and install a plugin or MCP connector safely.
Evidence: The written trust check and the installed component list
Set effort levels and a goal or loop with a stop condition so the checking team runs until clean.
Evidence: The goal or loop and a transcript showing it stop

Operate

Run it, test it, keep it running.

Run security review agents, verify each finding, fix the real ones and record the rest.
Evidence: The findings log
Run optimizer and critic agents (simplicity, speed, cost, idle cost) and act on verified findings.
Evidence: Before-and-after diff and a cost note
Run the automation on its own (desktop scheduled task or headless run) with an off switch, a run log, $0 idle cost and a runbook.
Evidence: A scheduled run, the log, the runbook and the idle-cost math

The four sessions

Two hours each. Something built every time.

In person, on the schedule that suits your team. Every session starts with me building one on the big screen while you call out the next step. Then everyone builds their own. You leave each session with something you keep, and I check it.

Session 1 · 2 hours

Set the project up for agents

A project a brand-new agent can pick up cold.

Together on the big screen: we turn the practice project's giant instructions file into a CLAUDE.md under 200 lines, topic documents and a first wiki page, and you call out the next step
The before test: a fresh agent answers five questions about your automation from the files alone
Your CLAUDE.md cut under 200 lines: the rules stay, the manual moves out
One topic per document, and a "where truth lives" table that says which document holds which fact
A lessons-learned wiki page with one rule written from a real mistake
The after test: a classmate asks a fresh agent the five questions, and all five come back right

What I check: The cold-start test

Session 2 · 2 hours

Skills, agents and mods

Your repeatable jobs packaged, and specialists you can call on.

Together: we build a /quote-check skill, a read-only security reviewer agent and a tester agent, then write a trust check before installing a plugin
Two skills for jobs you explain over and over, each run with one command
Two specialist agents, each with only the tools it needs
A written trust check before any plugin or connector goes in: who made it, what it can touch, what it runs
A classmate runs each skill and each agent without your help

What I check: Two skills, two agents, the trust check

Session 3 · 2 hours

The checking team

A change built tests-first, and a team of agents that checked it.

Together: we write the practice project's tests first, then let the checking team find the planted secret, the slow step and the idle loop
Tests first: answers you already know become tests. You watch them fail, protect them from edits, then build until they pass
A security review of the change, and of the whole project
Optimizers for simplicity, speed, cost and idle cost, and a fresh critic that sees only the result
A verifier checks every finding before anyone fixes it. Real ones get fixed; the rest go in the findings log with a reason
Effort turned up for the hard checks, back down after

What I check: Test history, findings log, verified fixes

Session 4 · 2 hours

Let it run

An automation that runs without anyone starting it, and stops when it should.

Together: we set a goal that reruns the checking team until it comes back clean, then put the practice project on a schedule
A goal with a turn limit, and a transcript showing it stop
Your automation running on its own, from a desktop scheduled task or a headless run, at the slowest pace the job allows
An off switch, a run log and a runbook a coworker can follow, starting with how to turn it off
The idle-cost math: $0 when nothing's happening
Your before-and-after hours, a five-minute demo and the quiz

What I check: Scheduled run, log, runbook, demo, quiz

Two ways to schedule it

Weekly, or two half-days.

Same four sessions, same 8 clock hours, same credential either way. I don't run it as one long day: the week between visits is when people put what they built to work on real tasks.

Weekly

4 visits

One 2-hour session a week for four weeks.

Between sessions, people use what they just built on real work, and the next session picks it up.

Two half-days

2 visits

Two 4-hour half-days a week apart: sessions 1 and 2 on the first, 3 and 4 on the second, with a short break in each.

Between the half-days

Each person runs their checking team on their own automation every working day, keeps the findings log, and brings the three findings they disagreed with. Day two turns that into tests and a schedule.

What I check

How it's earned

You earn it with the work, not just by showing up. I check what you built against the same six things for everyone.

Pass all six things I check (the six rubric criteria) at Proficient or better, score 80% or more on the 20-question quiz (16 of 20), and be there for all 8 hours.

Check 1