Workflow Skills

aj-skills

A shared AJ agent-workflow repository.

It currently provides:

• a Claude Code plugin marketplace with the workflow-skills plugin; and
• a Codex plugin marketplace with the codex-workflow-skills plugin.

codex-workflow-skills

Bundled Codex skills:

Skill	Purpose
codex-get-context	Load and verify a repo's global canonical context plus matching milestone context when selected
codex-feature-create	Create proposal.md, design.md, and tasks.md for a new feature
codex-feature-review	Review AJ feature plans before implementation
codex-feature-elaborate	Author design.md and tasks.md from a proposal-only feature
codex-feature-implement	Implement reviewed AJ feature plans end to end
codex-pr-review-loop	Drive existing PRs through review/fix rounds
codex-epic-review	Review AJ epics for coherence, sequencing, completeness, and completion evidence
codex-batch-gate	Gate feature batches before implementation handoff
codex-backlog-lint	Run deterministic backlog lifecycle checks from Codex

The Codex plugin is intentionally starting small. It will grow as Claude workflow skills are ported and tested in real Codex work across CAP, KK, Pinky, and sandbox repos.

Repo marketplace:

• .agents/plugins/marketplace.json
• plugin source: plugins/codex-workflow-skills

Use this marketplace from Codex when these skills should be available across repos instead of copied into a single product repo.

workflow-skills

Bundled skills (invoked namespaced as workflow-skills:<name>):

Skill	Purpose
feature-create	Scaffold a feature plan (proposal + design + tasks)
feature-elaborate	Author design + tasks for an existing proposal
feature-implement	Implement a feature end-to-end
feature-review	Review a feature plan for completeness and alignment
feature-workflow	Meta-orchestrate a feature sub-skill: ground in canon, run it, open a PR, drive review to approval
pr-review-loop	Drive an existing PR to merge-ready via an independent review/fix loop (reviewer ≠ implementer)
get-context	Load and enforce the repo's global canonical context plus matching milestone context when selected
epic-create	Scaffold an epic folder
epic-review	Review an epic for coherence and completeness
codebase-review	Comprehensive codebase review — floor + derived lenses, adversarial verification, findings ledger, trend analysis
code-review	Post-implementation review of changed files
deslop	Scan code for AI-generated slop patterns
backlog-lint	Deterministic lifecycle checks over backlog/ (frontmatter, depends-on, README↔status, done⇒verification.md)
canon-audit	Phase-gate audit of the canon artifacts themselves — completeness, correctness, security sufficiency, manifest hygiene
batch-gate	Pre-handoff gate over a batch of ready features — cross-feature conflicts, batch architecture fit, composed security surface, requirement coverage; GO / GO-WITH-CONDITIONS / NO-GO

The skills are repo-agnostic: they read .claude/repo-conventions.yaml (if present) to parameterise paths, patterns, and conventions to the active repo.

How they fit together

The table above is what each skill is; this is when to reach for which and how they compose. (One-line purposes live in each skill's frontmatter — the source of truth — and in the table above; this section adds only the relationships, which the descriptions don't carry.)

By cadence — when each runs

Cadence	Skills	Reaches for it when…
Per change / per PR	code-review, deslop, pr-review-loop	a diff exists — review/clean changed files, or drive a PR to merge-ready
Per planning step	feature-create, feature-elaborate, feature-implement, feature-review	a single feature moves through its lifecycle (scaffold → elaborate → review → implement)
Per feature, orchestrated	feature-workflow	you want one feature taken end-to-end: ground → run a sub-skill → open a PR → drive review to approval
Per epic	epic-create, epic-review	an epic is scaffolded, or has grown enough that coherence/sequencing needs a look
Session start / before canon-dependent work	get-context	grounding the session in the repo's canonical docs, with optional milestone-scoped context, before touching architecture/product/design
Periodic (≈6-weekly)	codebase-review	a whole-repo health sweep with scored findings, a trend ledger, and proposal stubs
Phase gate / before a planning push	canon-audit	auditing the canon itself for gaps, wrong decisions, or insufficient controls
Per handoff batch	batch-gate	5-10 elaborated features are about to go to implementation together — last look for what no per-feature or per-epic review can see
On demand (mechanical)	backlog-lint	a fast, deterministic lint of the backlog's lifecycle invariants — no agent, no drift

How they compose

feature-workflow ─┬─ get-context            (Step 0a: ground the session)
                  ├─ feature-{create|elaborate|implement|review}   (the sub-skill it runs)
                  └─ pr-review-loop ── code-review   (drive the resulting PR to approval)

feature-implement ── deslop + code-review-style checks   (self-gate before handing off)
pr-review-loop ──── get-context (Step 0, if not already grounded)
batch-gate ──────── get-context-style canon load (Step 2), one pass, then hand the batch to implementation

get-context, code-review, deslop, epic-review, backlog-lint, canon-audit and batch-gate also run standalone; the graph shows the orchestrated paths, not the only ones.

Boundaries & ownership (which one, not the other)

• code-review vs codebase-review — changed files, per-PR, fixes inline vs the whole repo, periodic, reports + plans only. code-review is the lightweight one; reach for codebase-review for systemic health, not a diff.
• canon-audit vs codebase-review --lens canon-drift (the lens is added by the codebase-review rewrite, #25) — audit the canon itself for gaps/correctness vs audit reality against the canon. Run canon-audit first at a phase gate: aligning code to a flawed canon bakes in the flaw.
• get-context vs canon-audit — load + enforce the canon (hard-stop on misalignment) vs stress-test the canon (enumerate its gaps). Same manifest, opposite stance.
• feature-review vs epic-review — feature-review enforces per-feature detail exhaustively; epic-review checks epic-only properties (coherence, split, sequencing) and only samples feature properties as drift sentinels.
• batch-gate vs both of the above — different unit: the handoff batch (possibly cross-epic, possibly an epic subset). It assumes feature-review already passed and never re-litigates it; it only re-enters epic-review ground when a batch-level interaction makes an epic finding urgent now. Its findings must be invisible at single-feature level — cross-feature conflicts, batch-composed security surface, requirement coverage. Advisory, one pass, no fix loop.
• Single owners (cited by reference, defined once): deslop owns the AI-slop pattern catalog (code-review and codebase-review cite its IDs); get-context owns the canon-check definition (contradiction-vs-staleness, fail-closed threshold, 3-part report) that feature-workflow, pr-review-loop and codebase-review's canon-drift lens apply at their own scopes.

Use it

In a consuming repo, commit .claude/settings.json:

{
  "extraKnownMarketplaces": {
    "aj-skills": { "source": { "source": "github", "repo": "ajmaher2-dev/claude-skills" } }
  },
  "enabledPlugins": { "workflow-skills@aj-skills": true }
}

Or add it ad hoc:

claude plugin marketplace add ajmaher2-dev/claude-skills
claude plugin install workflow-skills@aj-skills

Cloud sessions

In hosted Claude Code cloud sessions the plugin auto-installs from committed settings, reconciling on the first turn boundary after a cold start (so the very first turn of a fresh session may not have it yet). A single-turn / non-interactive run that never gets a second turn should install via a pre-session setup script (claude plugin install workflow-skills@aj-skills) in the cloud environment settings.