software-development

Plugin software-development from marketplace agent-tooling in DevGuyRash/agent-tooling. Commands read from the repo's manifest — 3 days ago.

Skills (27)

• async-rust

  Use for async Rust: runtimes, task ownership, overlapping awaits, cancellation at suspension points, backpressure, Send and 'static bounds, pinning, and blocking in executors. Composes with rust-development; excludes synchronous-only Rust.

• behavior-preserving-migration

  Use when an API, schema, data store, dependency, runtime, implementation language, service, or architecture moves to a new form while its consumers keep working: compatibility windows, backfills, cutover, and rollback. Excludes local refactors.

• c-development

  Use for C source, build-classified headers, or tooling: ownership, bounds, undefined behavior, threads, ABI, and errors. Excludes C++-only work.

• concurrency-engineering

  Use when code in any language starts, bounds, cancels, or joins concurrent work, new or existing: tasks, threads, goroutines, coroutines, workers, callbacks, subprocesses, queues, locks, and shutdown. Excludes one-at-a-time async calls.

• cpp-development

  Use for C++ source, build-classified headers, or tooling: RAII and lifetimes, templates, undefined behavior, threads and futures, ABI, and errors. Excludes C-only work.

• csharp-development

  Use for C# source, projects, or .NET tooling: nullable references, records and equality, exceptions, disposal, async/await, cancellation, channels, multi-targeting, and NuGet. Excludes ASP.NET- or EF-only work.

• go-development

  Use for Go source, modules, or tooling: APIs, errors, context, goroutines and channels, synchronization, resources, and tests. Excludes framework-only and workflow-only work.

• java-development

  Use for Java source, builds, or tooling: JDK and --release compatibility, collections and equality, exceptions, interruption, executors and virtual threads, and binary compatibility. Excludes framework-only work.

• javascript-development

  Use for JavaScript, JSX, or JSDoc-checked code: modules, promises and async flow, collections, mutability, prototypes, and errors. Excludes TypeScript-only and Node-runtime-only work.

• kotlin-development

  Use for Kotlin source, builds, or tooling: null safety, data classes and collections, coroutines, Flow, cancellation, Java interop and binary compatibility, and Multiplatform source sets. Excludes Android-only work with no Kotlin changes.

• nodejs-development

  Use for Node.js runtime or package code: ESM/CJS resolution, exports, streams, buffers, the event loop, worker threads, child processes, and shutdown. Composes with JavaScript or TypeScript; excludes browser-only work.

• performance-engineering

  Use when new or existing code must reach, verify, or review a performance target or claim: latency, throughput, CPU, memory, I/O, or cost, with baselines, profiles, and benchmarks. Excludes slowdowns whose cause is unknown.

• php-development

  Use for PHP source, Composer setup, or PHP tooling: types and coercion, public APIs, errors, resources, workers, processes, and security-sensitive input. Excludes framework-only work.

• python-development

  Use for Python source, stubs, or pyproject tooling: typing, imports, exceptions, resources, asyncio, threads, processes, and subprocesses. Excludes conceptual Q&A, throwaway one-liners, and publication-only work.

• refactoring

  Use when restructuring code without changing its behavior, or when reviewing such a change: splitting modules, giving duplicated rules one home, untangling dependencies, renames and moves. Excludes features, fixes, migrations, and tuning.

• ruby-development

  Use for Ruby source, gems, Bundler setup, or Ruby tooling: dynamic dispatch, keyword and block APIs, errors, resources, threads, fibers, and subprocesses. Excludes Rails-only work.

• rust-development

  Use for Rust source, Cargo, or tooling: ownership and borrowing, APIs and errors, features, workspaces, MSRV, threads, and verification. Composes with async-rust, unsafe-rust, and rust-panic-audit; excludes workflow-only work.

• rust-panic-audit

  Use to audit direct panic surfaces (unwrap, expect, panic macros, indexing, arithmetic) in a Rust scope that a request or policy names, such as hostile-input, embedded, FFI, or high-availability boundaries. Compose with rust-development; exclude routine review.

• shell-development

  Use for shell scripts, shell modules, or shell-based automation in POSIX sh, Bash, PowerShell, or another shell: quoting, exit status, traps, background jobs, and subprocesses. Excludes incidental one-liners.

• software-foundation

  Use when writing, changing, reviewing, or revising code in any language: the design principles all code meets and existing code is brought to. Excludes questions, prose, and Git operations that touch no code.

• sql-development

  Use for relational SQL: queries, schemas, constraints, indexes, transactions, isolation, migrations, or SQL embedded in host-language code. Excludes NoSQL and database administration without SQL effects.

• swift-development

  Use for Swift source, SwiftPM packages, or tooling: optionals, errors, value and reference semantics, ARC, async/await, actors, Sendable, and API or ABI compatibility. Excludes Apple-UI-only, signing, and Xcode-project work.

• systematic-debugging

  Use when a bug, failure, crash, hang, flaky test, unexpected output, or regression has an unknown cause: reproduction, falsifiable hypotheses, discriminating probes, and a fix of the cause. Excludes known-cause fixes.

• test-driven-development

  Use when adding or changing executable behavior or fixing a known bug: a failing test that shows the gap, the smallest change that passes it, then cleanup. Excludes unknown-cause diagnosis and behavior-neutral refactors.

• trunk-based-development

  Use when integration strategy needs mergeable slices, short branches, safe incomplete work, or divergence recovery. Excludes routine Git/PR operations, CI, releases, and governance.

• typescript-development

  Use for TypeScript, TSX, declaration files, tsconfig settings, or typed APIs: type modeling, narrowing, generics, runtime validation, promises and async flow, and emitted output. Excludes JavaScript-only and Node-runtime-only work.

• unsafe-rust

  Use for unsafe Rust: unsafe blocks, fns, traits, impls, and attributes, `static mut`, extern blocks, raw pointers, MaybeUninit, FFI and layout, assembly and intrinsics, provenance and aliasing, pin projection, unsafe Send or Sync, lock-free code, and thread-affine handles. Compose with rust-developm

Hooks (1)

• Stop

  sh -c 'p="${PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-}}"; [ -n "$p" ] && [ -f "$p/hooks/review-turn-stop.py" ] && exec python3 "$p/hooks/review-turn-stop.py"; exit 0'

Similar plugins