Cole's AI Skills: 34 Claude Code Skills for the PIV Development Loop

Who This Collection Is For and What It Replaces

A `CLAUDE.md` that grows past 2,000 lines works against you: the agent loads all of it on every task, whether the content is relevant or not. A skill is a folder with a `SKILL.md` that has a name, a description of when to use it, and the procedure the agent should follow. The agent loads the description at startup and pulls in the full skill only when the work matches. This keeps context focused.

The 34 skills in this collection are the author's production workflow, described in the README as coming directly from his `.claude/skills/` folder. They are built around one loop: prime the codebase, plan, implement, validate, review, commit, and open a pull request. The collection is part of the AI Layer from an Agentic Coding course at dynamous.ai.

The target user is a developer who already uses Claude Code, finds a long system prompt clumsy, and wants a set of reusable, version-controlled procedures rather than inline instructions. The skills are written to be disagreed with: the README says explicitly that the point is to read them, take the ones that fit, and rewrite the rest.

How to Install Claude Code Skills from GitHub

Three install paths are available. The easiest keeps skills managed and read-only:

/plugin marketplace add coleam00/skills
/plugin install skills@cole-medin

These two commands run inside Claude Code. Plugin skills are namespaced, so they invoke as `/skills:piv-implement` rather than `/piv-implement`. The `/plugin marketplace update` command pulls new skills as they are added. If the first command fails with a publickey error, pass the HTTPS URL directly:

/plugin marketplace add https://github.com/coleam00/skills.git

Setting `CLAUDE_CODE_PLUGIN_PREFER_HTTPS=1` in the environment makes the shorthand use HTTPS permanently.

The second path uses npx and writes real files you can edit:

npx skills add coleam00/skills

Add `--list` to see available skills before installing, and `--skill piv-plan-implementation piv-implement piv-validate` to install only specific ones. The `-g` flag installs globally into `~/.claude/skills/` rather than the current project.

The third path is a manual clone and copy:

git clone https://github.com/coleam00/skills.git
cp -r skills/.claude/skills/piv-implement your-project/.claude/skills/

After either of the file-based paths, restart the session or run `/skills` to see the new skills.

The PIV Loop: Prime, Plan, Implement, Validate

The core of the collection is the PIV loop. It runs in sequence: prime the codebase context, plan the implementation in detail, implement task by task, validate with the project's full test suite, review the changes, commit, and open a pull request.

The prime skills orient the agent before any planning or implementation. `prime-codebase` loads the general codebase context. `prime-backend` scopes to API routes, services, and the data layer. `prime-frontend` scopes to components, routing, state, and styling.

The planning skills are distinct from implementation. `plan-create-prd` interviews the user into a problem-first PRD that names intent without prescribing engineering decisions. `plan-architecture` is a working session on the stack, data shape, trade-offs, and risks. `piv-slice-epic` then slices an epic plus its architecture into PIV-sized tickets with a dependency graph.

The implementation and validation skills `piv-implement` and `piv-validate` work together: `piv-implement` executes the plan task by task with validation at every step, and `piv-validate` runs the project's full suite and returns a single PASS/FAIL verdict. `piv-run-full-loop` chains the entire core loop end-to-end from a single feature description.

Parallel Work with Worktrees and Issue Investigation

Two skills handle parallel work. `worktree-create` spins up N git worktrees, each configured, installed, and health-checked. `worktree-merge` integrates those branches through a safe integration branch. These skills allow multiple independent tasks to run simultaneously on the same repository without interfering with each other.

Issue handling has its own pair. `piv-investigate-issue` runs a parallel investigation of a GitHub issue and returns an evidence-backed root cause analysis. `piv-implement-issue` implements the fix from that analysis with regression tests. The separation is deliberate: diagnosing and fixing are different tasks, and combining them in one step tends to skip the diagnosis.

The `piv-review-pr` skill acts as an agentic gate on an open pull request: it reviews with fresh eyes, ranks findings by severity, and posts them to GitHub. `piv-review-changes` runs the pre-commit technical review of what changed, and `piv-fix-review-findings` triages findings with the developer deciding what gets fixed now versus deferred.

Meta-Skills for Building Your Own AI Layer

Eight skills exist specifically for maintaining the AI workflow itself. `rules-create-global` derives a lean root `CLAUDE.md` from the codebase or from user specs. The README describes it as a customizable version of `/init`. `rules-check-drift` checks whether the rules file is still accurate after recent code changes.

`ablate-ai-layer` is the most unusual skill in the collection. It strips the rules layer, reruns the same task without it, and diffs the two outputs to test whether the rules actually earn their place. This is a concrete way to verify that a rules file is doing useful work rather than adding noise.

`skills-create` authors new skills or refactors an existing one into a `SKILL.md` plus a `references/` folder. `hooks-create` turns a constraint like a migration file boundary into a working hook wired into settings. `opportunity-scan` reads how the developer actually works and recommends what to encode next.

`build-dark-factory` is the most autonomous skill: it takes a PRD and builds a repository around it that ships validated code with nobody at the keyboard. The README states that it requires an existing PRD and deliberately does not write one; `plan-create-prd` handles that step separately.

Context Cost and the Plugin Overhead Trade-off

The full set of 34 skills costs approximately 4,400 tokens of always-on context when installed as a Claude Code plugin. That number covers only the skill descriptions; the full skill bodies load only when a skill fires. The README recommends running `claude plugin details skills` to see the per-skill token breakdown and to disable individual skills that are not relevant to the current project.

This overhead matters on long tasks where context window pressure is real. The editable-file install paths (npx or manual clone) avoid this constraint entirely, because you can delete any skill you do not use. The plugin path is convenient but loads all 34 descriptions unconditionally.

The skills directory sits at `.claude/skills/` within the repository. Each subdirectory is one skill: a `SKILL.md` file with the name, trigger description, and procedure, and optionally a `references/` folder for supporting material. The structure is shallow and readable in any text editor, which is important for the meta-skill workflow: `ablate-ai-layer` strips skills and reruns tasks, so knowing exactly what each skill contains is necessary for interpreting the comparison.

The collection has no GitHub releases. The last push was on 2026-09-17. The project is MIT-licensed.

How These Skills Differ from a Framework Like Cursor Rules

Cursor Rules is a system of markdown rule files that tell Cursor how to behave in a project. It operates at the level of persistent instructions loaded into every request. The coleam00/skills collection is different in structure: each skill is invoked explicitly for a specific task rather than loaded as a background instruction. A skill fires when the work matches its description, not on every message.

The practical difference is that skills are procedural where rules are declarative. A skill like `piv-plan-implementation` includes a step-by-step procedure for deep codebase analysis and planning. A rule file would state a preference or constraint. For teams that want to encode repeatable procedures, not just preferences, the skills approach is more direct. For teams that want simple behavioral guardrails, a rules file is lighter and does not require the skills install infrastructure.

Editorial conclusion

This collection is useful for engineers who already work with Claude Code and want a structured, editable workflow rather than a monolithic CLAUDE.md. The skills are plain markdown files, so every skill can be read, disagreed with, and rewritten. The collection is not a framework and will not enforce any process on its own. Before installing, check the per-skill token breakdown with `claude plugin details skills` to decide which skills to disable, since the always-on context cost of 4,400 tokens applies even to skills you never invoke.

Frequently asked questions

Official sources

1. coleam00/skills on GitHub
2. Issues
3. License: MIT
4. README