coding

Plugin coding from marketplace greenblacked-ai in greenblacked/AI. Commands read from the repo's manifest — 2 days ago.

Skills (29)

• agent-delegation

  Brief one coding agent on one bounded task so the result can be judged without re-deriving context: set the done-check first as a runnable command whose exit code decides finished, supply a failing test or reproduction when one exists, name the paths the agent may not touch — tests, CI config, lint

• agent-evaluation

  Evaluate whether an AI agent completes real tasks correctly and safely: turn production failures and representative work into versioned datasets with a sealed holdout, run each case in an isolated reproducible environment, score final state and tool effects with deterministic graders before using ru

• agent-failure-diagnosis

  Find which layer of a coding agent's environment makes it repeat a mistake, and fix that layer instead of adding prompt text: capture failing runs with transcript and diff, rule out an ambiguous request, a repository defect or a wrong model, attribute each failure to one layer (instructions, tools a

• agent-guardrails

  Turn a rule, or a mistake an agent keeps repeating, into the cheapest mechanism that enforces it: state the violation as a checkable input, climb from the compiler and linter through tests, CI and git hooks to agent hooks and permissions, show it fail on a real violation first, write a message the a

• agent-handoff

  Preserve and safely resume one unfinished coding work item when an agent runs out of context, is interrupted, or transfers the task to a successor. Use when someone asks for a checkpoint, continuation packet, session handoff, or recovery of partially completed repository work. Capture authority, rep

• agent-instructions

  Write or repair a repository's agent instruction file: AGENTS.md and, where Claude Code is used, a CLAUDE.md that imports it, so a cold agent session can work in the repo. Run the real build, test and lint commands first and keep only what was executed, keep the entry file short, pointing to topic f

• agent-orchestration

  Coordinate multiple coding agents through a live repository task: decompose work into a dependency graph, delegate independent research, implementation and review with explicit contracts, assign exclusive file and shared-resource ownership, monitor runtime state, recover safely from stalls or failed

• api-design

  Design or review an HTTP or RPC interface that other people will depend on — resources modelled on the consumer's task rather than the storage schema, a machine-readable OpenAPI or protobuf contract verified against the implementation, errors with a machine-readable code, cursor pagination with a st

• application-caching

  Design or review runtime application-data caching where correctness, isolation, or origin protection matters. Use when adding cache-aside or read-through caching, choosing cache keys and freshness rules, fixing stale reads or a late stale-fill race, preventing tenant or authorization leaks, handling

• architecture-diagrams

  Draw architecture, sequence and flow diagrams as code that renders where it will be read: choose the tool by the target surface (Mermaid where GitHub or GitLab render it natively, D2 or Graphviz committed as SVG for large graphs, Structurizr for a C4 model), give each C4 level its own diagram under

• change-discipline

  Make any code change in an order that keeps it small and proven: size it first so the ceremony fits the change, make it work with a failing test and the smallest edit, then make it right with measurable gates on the changed functions only — CRAP score, new structural duplication and diff-scoped muta

• code-review

  Review a change — a diff, pull request or branch — in a fixed severity order: correctness first (claim, error path, concurrency and hostile input), then tests, then maintainability, with a severity on every finding and nits named as nits. Covers a diff you cannot run, honest sampling and comments th

• code-scaffold

  Scaffold new production-ready code — Bash scripts, Python tools, Terraform modules, CI jobs, and mixed-language projects — with strict error handling and exit codes, structured logging, input validation and secure defaults, idempotent re-runnable behaviour, a validation pass, and a handoff review ch

• codebase-orientation

  Get oriented in a codebase you did not write, in a fixed order: what it does and for whom before how it is built, the entry points, one real request traced end to end, a named behaviour located in the code, the tests read as the specification, the history read as evidence of what churns and what has

• debugging

  Drive a failure down to a proven cause before changing any code: capture the exact failure and its conditions, reproduce it reliably, reduce it to the smallest case that still fails, form one falsifiable hypothesis at a time, bisect through history and through the input, instrument instead of guessi

• dependency-upgrade

  Move a codebase onto a new major version of a dependency, runtime or framework without a six-month branch that never lands: state why you are upgrading before how, read the changelog and grep for every breaking change that applies to code you actually have, escalate deprecation warnings and land tho

• e2e-testing

  Keep a browser end-to-end suite trustworthy, not rerun until green: measure each test's flake rate from CI history before fixing any one, locate elements by role and accessible name not CSS or XPath, wait on state instead of a fixed sleep or network idle, give every test its own data, authenticate o

• feature-recreation

  Build your own version of a feature you saw in another app, without copying its code, text, icons or exact visual design: write what the feature does for the user as your own spec before opening any reference material, keep reading the reference and writing your implementation as separate sessions s

• feature-spec

  Turn a loose feature request into a written spec and a checkpointed task plan before any code exists: interview one question at a time, only about what the code and docs cannot answer; write the spec as problem, users, constraints, explicit non-goals and acceptance criteria phrased as checks; compar

• new-skill

  Author a Claude Code skill from scratch — decide whether the procedure deserves a skill at all, name and place it, write the body as scope, workflow and anti-patterns, write the description last because it is the only text that decides whether the skill ever fires, push depth into reference files, a

• profiling

  Make slow application code fast, or prove it cannot be: fix the workload and the target number, subtract database, downstream and I/O time to prove the cost is yours, sample the real process under load, read self time and call paths, not the function that feels slow, and change one thing at a time a

• refactoring

  Restructure code without changing behaviour, in steps small enough that each one is provably safe: pin behaviour with a characterisation test before touching code you do not understand, find a seam when there are no tests at all, then apply one operation at a time — rename, extract, inline, move, sp

• regex-safety-review

  Review a regular expression that runs on untrusted input for catastrophic backtracking and other denial-of-service shapes. Identify the engine and whether it backtracks, spot nested quantifiers, overlapping alternations and unbounded repetition, measure the worst case with a long non-matching input

• retrieval-evaluation

  Evaluate a retriever or search ranking change against a reproducible, access-safe benchmark rather than a few impressive answers. Use for a frozen retrieval benchmark, a paired baseline-versus-candidate comparison, scoring a chunking or reranker change, recall regressions, relevance-label design, a

• schema-design

  Design the tables for a new feature before any migration exists: write the queries the schema must serve first, with expected cardinalities, then choose keys, constraints and types that are expensive to reverse later — tenancy in every unique key, a foreign-key index on every referencing column, tim

• sql-performance

  Make a slow SQL query fast, or prove it cannot be: start from the statement with the most total time in pg_stat_statements or MySQL's performance_schema, not the one someone complained about, read EXPLAIN (ANALYZE, BUFFERS) from the deepest node out to the first place estimated and actual rows diver

• technical-docs

  Write and prune internal documentation: a README for a newcomer's first hour, an onboarding or handover guide, an architecture overview, an API guide beside the generated spec. Name the reader, pick one Diátaxis mode — tutorial, how-to, reference, explanation — not two, execute every command, stamp

• test-design

  Choose what to test before writing a test: partition the input space into equivalence classes and take the boundary of each, enumerate the error paths nobody writes, cut a combinatorial explosion with pairwise selection, place every case at the unit, integration or no level at all, pin time, randomn

• website-builder

  Design and build a complete website scaled to the brief — from a single landing page to a full web app — or audit an existing one and deliver prioritized improvements. Building runs an intake, picks the build tier, presents 2-3 design directions before any code is written, meets a quality floor, and

Slash commands (1)

• /coding:agent-diff-audit

  Run mechanical detectors — shrunk test counts, newly silenced checks including bulk lint suppressions, and dependencies that do not exist on their registry — over an agent-written diff against a base ref, then hand the flagged list to code-review for judgement.

Subagents (5)

• agent-run-trace-reader

  Read supplied coding-agent run artifacts—worker events, tool transcripts, task exports, and coordinator logs—and return a bounded evidence ledger by task and attempt or generation. Use when a bulky historical run must be reconstructed: progress, errors, calls with or without returns, claims versus e

• change-impact-reader

  Read a supplied diff plus matching repository source and configuration, then return a bounded inventory of what the change can affect: changed symbols, direct callers, entry points, config, schema and contract dependencies, and related tests, with file and line evidence. Use when a large or cross-cu

• review-comment-miner

  Read a pile of exported pull-request review comments or postmortem action items and return recurring findings as clusters, each with an independent-instance count, one quoted example, and candidate destinations once seen three times across authors — a code-review severity entry, a lint rule, an agen

• skill-reviewer

  Review a candidate SKILL.md against this repository's rules and against what actually makes a skill trigger and work. Use when a new skill has been drafted, when an existing one is being edited, or when a skill exists but never seems to fire.

• test-history-reader

  Read hundreds of JUnit, pytest or go test reports across many CI runs and return a flake-rate ledger for non-browser suites: each test's rate with its run denominator, split into retried-then-passed, failed-on-default-branch and failed-only-on-PR; clusters that share a runner, shard, time of day or

Similar plugins