cc-thingz v6: portable skills and hooks for AI coding agents

I released v6 of cc-thingz.

Short version: battle-tested skills and hooks for AI coding agents.

Longer version: I wanted the same developer workflow available in whichever coding agent and LLM model I use today.

• Claude Code for some tasks
• Codex CLI for others
• Gemini CLI sometimes
• Pi when I want the harness and subagents

The annoying part: skills are almost portable but work better when written as agent-specific and model-specific.

Each tool has its own plugin format, lifecycle events, hook model, permissions, and model behavior. Copy-pasting prompts between tools works for a few minutes, then turns into balagan.

So cc-thingz keeps one source of truth and compiles it into each agent's native setup.

What it is

cc-thingz is not a coding agent.

It is a portable workflow layer for coding agents:

• skills
• hooks
• small role agents
• guardrails
• language references
• generated per-agent exports

The repo source lives under src/. The build emits target-specific output for:

• Claude Code plugins
• Codex CLI skill exports
• Gemini CLI extensions
• Pi skills, agents, and hooks

Same workflow ideas. Native shape per agent.

What developers get

The project covers the boring, useful parts around coding with agents:

• code review with severity/confidence rubrics
• bug fixing with reproduce-first loops
• refactoring with behavior-preserving checks
• tests based on behavior seams
• documentation updates grounded in code facts
• git hygiene and worktrees
• infra ops
• browser automation
• docs lookup and web research
• lightweight spec-driven work

This is the stuff that keeps an AI coding session from becoming one giant chat window with vibes.

Why hooks matter

Prompts can ask the agent to behave.

Hooks can put friction in the right place.

cc-thingz includes hooks for things like:

• suggesting relevant skills from the user's prompt
• blocking protected paths and secrets
• formatting and linting after edits
• running focused tests after code changes
• printing repo/session context on start
• git guardrails

That is the practical difference between a prompt pack and a workflow.

A prompt says: "please run tests".

A hook runs the focused tests when the edit is done.

What is new in v6

v6 adds first-class workflows for:

• Rust
• C#/.NET
• Java/Kotlin

That brings the language set to:

• C#/.NET
• Go
• Java/Kotlin
• Python
• Rust
• TypeScript
• shell
• web

The language work is not just writing-rust or writing-java-kotlin prompts.

The hooks understand the stacks too:

• focused lint/format on changed files
• nearest test target per build system
• project detection on session start
• skill routing by file extension, toolchain, and framework terms

So if the agent edits a Rust file, a .csproj, or a Gradle module, the workflow can choose a scoped feedback loop instead of running the universe.

Why these skills are better than random prompts

Not magic. Just boring engineering hygiene.

1. They come from daily use

The skills were written and refined while using agents on real code, not generated as a weekend prompt dump.

2. They are agent-native

Each target gets its own native format. Claude Code gets plugins. Gemini gets extensions. Pi gets skills, agents, and extensions. Codex gets skill exports.

3. They include hooks

The workflow is not only instructions. It also includes runnable checks and guardrails.

4. They compose

The agent model was simplified from 39 agents to 3 roles:

• engineer — can edit and verify code
• reviewer — read-only, adversarial, finds bugs
• advisor — verdict, risks, next actions

Languages live in references. One reviewer can work across 8 languages instead of maintaining one reviewer per language.

5. The source of truth is shared

The same workflow logic is authored once, then compiled into the target output. Less drift. Less "why is this broken only in tool X?"

Should you try it?

Try it if:

• you use Claude Code, Codex CLI, Gemini CLI, or Pi
• you switch between more than one agent or model
• you work in polyglot repos
• you want focused lint/test hooks around agent edits
• you want review/fix/test/refactor workflows that are more specific than "be careful"

Maybe skip it if:

• you only use one tool and already have a setup you love
• you want a fully generic, unopinionated prompt pack
• you do not want hooks touching your workflow

cc-thingz is opinionated on purpose. Neutral agent workflows become mush.

Install

Claude Code:

/plugin marketplace add alexei-led/cc-thingz
/plugin install dev-flow@cc-thingz
/plugin install programming@cc-thingz

Gemini CLI:

gemini extensions install https://github.com/alexei-led/cc-thingz

Pi:

pi install npm:pi-subagents
pi install git:github.com/alexei-led/cc-thingz

Codex CLI:

git clone https://github.com/alexei-led/cc-thingz.git ~/src/cc-thingz
cd ~/src/cc-thingz
make build
codex
# inside Codex: /plugins

Repo: https://github.com/alexei-led/cc-thingz

Built from daily use. Practical, opinionated, and hopefully less balagan.