kennykankush-skillpack

Portable agent workflows I actually use.

This repo is my working layer for Codex, Claude Code, and any future agent host that can load the same underlying methods. The point is not to collect prompts. The point is to package durable ways of working: study the system before changing it, verify claims against live evidence, preserve the user's intent, converge messy work into clean artifacts, and keep each workflow in a namespace that can be installed or removed cleanly.

Plugins are the organizing unit. A plugin should feel like a coherent vertical, not a folder of unrelated tricks.

Quickstart

Codex

From the repo root:

codex plugin marketplace add .

Restart Codex, open /plugins, install the plugin you want, then start a new thread.

Common invocations:

$workbench:devour
$workbench:research-report
$workbench:max-prompt
$hats:overseer
$hats:birdwatch
$hats:autoreview
$videos:storyboard
$extra:trail-scriber
$extra:cap-video-editor

After publishing, the marketplace can be added by repo instead:

codex plugin marketplace add kennykankush/skillpack

Claude Code

Add the marketplace once:

/plugin marketplace add github.com/kennykankush/skillpack

Install the bundles you want:

/plugin install workbench@kennykankush-skillpack
/plugin install agents@kennykankush-skillpack
/plugin install videos@kennykankush-skillpack
/plugin install extra@kennykankush-skillpack
/plugin install agent-announcer-when-agent-finishes@kennykankush-skillpack
/reload-plugins

Why this exists

I built this pack around the failure modes I keep seeing when agents become part of real work instead of one-off demos.

#1: The agent changes code before it understands the system

The failure mode is shallow context. The agent reads the nearest files, makes a plausible edit, and misses the route, lifecycle, schema, auth state, test seam, or live behavior that actually controls the bug.

The fix is workbench:devour: a codebase mastery mode that builds a grounded atlas before implementation. It maps entrypoints, runtime flows, temporal behavior, blast radius, safe extension points, verification commands, and unknowns. The goal is judgment, not file-count tourism.

#2: Research turns into tabs, notes, and abandoned scratch files

The failure mode is research sprawl. A topic starts with a useful question and ends with fragments spread across chat, browser history, Markdown scraps, and half-rendered drafts.

The fix is workbench:research-report: one research engine with two outputs. Scan mode answers inline when the question is lightweight. Official mode converges to exactly notes.md and report.html under research/<umbrella>/<title>/. The shape matters because the end state stays inspectable.

#3: Intent gets lost between intuition and execution

The failure mode is shallow prompt expansion. "This feels off" or "I want something like this" becomes generic polish, decorative detail, or a confident specification built on assumptions the user never made.

The fix is workbench:max-prompt: a domain-adaptive intent translator for software, architecture, operations, research, writing, product/UI, and creative work. It recovers the real outcome, classifies the situation, separates evidence from assumption, and turns the idea into a justified execution contract with boundaries and verification. The videos pack remains the specialist workflow for motion work, separating narrative, visual contract, storyboard generation, frame QA, batching, and motion handoff so taste does not collapse into a single generation prompt.

#4: Live product work needs evidence, not confidence

The failure mode is guessing from stale memory. A user tests an app, the agent summarizes vibes, and nobody checks the logs, API, DB rows, browser state, branch state, PR state, or issue state that would prove what happened.

The fix is hats:birdwatch: a live QA companion for product/dev sweeps, the live twin of workbench:gauntlet. The user drives, it verifies the UI against logs, API and DB, records discrepancies in the user's words, and avoids destructive actions unless explicitly asked. When the work is done by other agents rather than a person, hats:overseer is the control tower: it gets ready on the whole project, checks each agent's claims against evidence, relays the user's decisions without granting approvals, and keeps a watch log the next overseer inherits. For code closeout, hats:autoreview runs a structured review helper, verifies accepted findings against the real code path, applies narrow fixes only when appropriate, and reruns until no actionable findings remain.

#5: Agent skills become a scattered toolbox

The failure mode is flat skill sprawl. Useful workflows get installed through different mechanisms, names collide, related tools drift apart, and uninstalling leaves leftovers.

The fix is plugin-first packaging. Each vertical has its own namespace, metadata, README, skills, commands, scripts, and host adapters. workbench:skill-advisor helps choose from the installed toolkit. workbench:skill-distiller turns a successful workflow into a reusable skill. The Claude-side skill-manager agent handles lifecycle across plugins, npx skills, skillfish, and manual installs.

#6: Important handoffs should reach you when the agent is done

The failure mode is invisible completion. Multiple terminal tabs are running, one agent finishes or requests input, and the result sits unnoticed.

The fix is agent-announcer-when-agent-finishes: a hook plugin that speaks a one-line contextual handover with the Ghostty tab number. It can summarize through OpenAI-compatible chat endpoints and speak through local Qwen, ElevenLabs, OpenAI TTS, or macOS say.

Methodology

The shared posture across this repo:

• Portable first. The core workflow should outlive Codex, Claude Code, or any single model. Host-specific commands and manifests are adapters.
• Evidence before narration. If live state is cheap to inspect, inspect it before explaining it.
• Vertical bundles over grab bags. A plugin should represent one workflow domain with clear boundaries.
• Human-gated mutation. Watching, reviewing, researching, and reconstructing can be active without being destructive.
• Converged artifacts. Research, memory, trail reconstruction, storyboard batches, and review closeout should have clear final states.
• User voice matters. Some workflows preserve exact phrasing because wording carries intent that summaries often erase.
• Install only what earns its place. Experiments can live elsewhere. A plugin lands here after it has proven useful in day-to-day work.

Reference

Workbench

Everyday meta-work for coding agents.

• workbench:devour - Codebase mastery and refresh modes. Persists MAP.md with revision, scope, and verification provenance; refresh reconciles changes without relabeling inherited understanding as newly checked.
• workbench:bedrock - Foundation audit mode: adversarial inspection of load-bearing logic to bank-grade, limit-tested feature flows, runnable repros, and a persistent AUDIT.md ledger. Report or report-then-fix.
• workbench:gauntlet - Drives real user journeys and verifies the subsystems behind them. Retains useful findings and reproductions, separates observed behavior from inferred experience, and restores owned test state.
• workbench:potential - Reads the structure for opportunities, then assesses benefit, ongoing burden, opportunity cost, and smaller alternatives. Open or wish mode; structural distance and usefulness stay distinct.
• workbench:decide - Compares credible options against the user's criteria, recommends a direction, and records the accepted downside and conditions for revisiting the choice.
• workbench:probe - Resolves a consequential assumption through a bounded experiment with declared outcomes, evidence, limits, and cleanup; returns the result to the decision.
• workbench:vision - Keeps a project's VISION.md written and alive: birth (handoff from exploration), backfill (repos with no vision doc), refresh (drifted intent). The vision comes from the visionary - evidence drafts, the user's voice decides.
• workbench:research-report - Deep research with scan mode for inline answers and official mode for notes.md plus rendered report.html.
• workbench:memory-scriber - Captures the residue of a meaningful session into the active host's memory directory.
• workbench:max-prompt - Converts vague intent in any domain into a grounded, situationally correct, execution-ready prompt without inventing certainty.
• workbench:skill-advisor - Recommends from already-installed skills without installing anything.
• workbench:skill-distiller - Generalizes a successful workflow into a reusable SKILL.md.
• workbench:isomorph - Systemic-thinking mode that maps a system onto its mature twin in another domain to surface required invariants and blindspots.
• workbench:scour - Reality-check hotline: mid-conversation, go to the internet and ground a confident narrative against how the world actually does it (verify) or find the pattern when stuck (discover). Currency-aware, conversational, never answers from memory.
• workbench:totality - Exhaustive-surface cartographer: map the COMPLETE surface of any object with provable coverage - anchor against official taxonomies, rotate generators, expand every example recursively (the Orange Rule), stock the niche shelf, show the whole tree with an audit and residual. The pack's OMNI; scour and research-report carry pointers to it.
• skill-manager - Claude Code agent for discovering, installing, updating, and cleaning up skills across multiple mechanisms.

Full plugin docs: plugins/workbench/README.md. Modular chains and handoffs: plugins/workbench/WORKFLOWS.md.

Hats

Operating roles for the assistant you're already using.

• hats:overseer - Control tower for agent work: gets ready on the whole project, watches other coding agents, verifies their claims, relays the user's decisions, keeps a decision queue and a watch log.
• hats:birdwatch - Live QA companion, gauntlet's live twin: the user drives a flow while it verifies UI against API, DB and logs and records findings in the user's words.
• hats:autoreview - Structured code-review closeout for local changes, branch diffs, or commits, with verified findings and focused fixes.

Full plugin docs: plugins/hats/README.md

Videos

Product-launch and SaaS motion preproduction.

• videos:launch-narrative - Shapes the product film spine before visual generation.
• videos:style-contract - Captures visual rules from product screenshots, brand assets, and references.
• videos:storyboard - Generates cohesive storyboard frames with Codex imagegen and quality gates.
• videos:frame-qa - Reviews frames or contact sheets and gives keep/regenerate decisions.
• videos:batch-prep - Copies accepted frames into upload-ready AI-video batches with manifests and prompt placeholders.
• videos:motion-handoff - Writes keyframe prompts and node workflows for tools like Higgsfield Canvas, Gemini/Omni, Runway, and Krea.

Full plugin docs: plugins/videos/README.md

Extra

Personal workflows that are durable enough to package but do not belong in Workbench.

• extra:trail-scriber - Reconstructs day-by-day work trails from Codex and Claude conversation evidence into Obsidian-friendly day, agenda, domain, and conversation notes.
• extra:testament - The contribution sweep: reconstructs the evidence-backed totality of what someone did over an era (harvest, analysis, presentation; tiered attribution; adversarial critic gate) into one layered book with receipts.
• extra:cap-video-editor - Studies screen recordings and builds a synced narrated Cap demo: purpose-led scripts, local voice generation, skipped loading, fixed manual zooms, subtitles, and verified exports.

Full plugin docs: plugins/extra/README.md

Hooks

Small runtime utilities that make agent work easier to notice.

• agent-announcer-when-agent-finishes - Speaks a contextual one-line handover when Codex or Claude finishes a turn or needs input.

Full plugin docs: plugins/agent-announcer-when-agent-finishes/README.md

Repository shape

plugins/
  workbench/                         meta-work: devour, research, memory, prompting, skill tooling
  agents/                            reusable operating modes: birdwatch, autoreview
  videos/                            launch-film and AI-video preproduction
  extra/                             personal workflows outside Workbench
  agent-announcer-when-agent-finishes/ hook-based spoken completion handoffs

Each plugin carries its own host metadata:

.codex-plugin/plugin.json
.claude-plugin/plugin.json

The root marketplace files expose the bundle:

.agents/plugins/marketplace.json
.claude-plugin/marketplace.json

Why plugins, not flat skills

Flat skills are useful for quick experiments. This repo is for workflows I depend on.

Plugins give the pack a few properties that matter in daily use:

1. Namespacing. workbench, agents, videos, and extra stay distinct instead of competing in one global list.
2. Bundling. Related skills, commands, scripts, templates, hooks, and metadata travel together.
3. Clean lifecycle. Install, upgrade, pin, or remove a vertical as a unit.
4. Host adapters. Codex and Claude Code can expose different commands while sharing the same method.
5. A discoverable home. A plugin reads as a maintained workflow package, not a scattered set of files.

The cost is a bit of manifest scaffolding. The payoff is a toolkit with boundaries.

License

MIT.