claude-toolkit

Claude Code **subagents** that live in this plugin. Each is a single Markdown file with YAML frontmatter; Claude Code auto-discovers `agents/*.md`. When the plugin is installed, Claude can delegate to these agents automatically (matching a request against the `description`) or you can invoke one explicitly.

Designs and reviews Akka systems end to end — choosing modules, modeling the domain, and laying out actors, clustering, persistence, streams, and the HTTP/gRPC edge. Use when the user wants help architecting an Akka application, picking which Akka module fits a problem, designing event-sourced aggregates / bounded contexts / sharding / projections, or reviewing an existing Akka design for resilience and correctness — even if a specific module isn't named.

Designs and reviews Akka SDK (Java) services — choosing components, modeling the domain, and laying out agents, entities, views, workflows, endpoints, consumers, and timed actions in the api/application/domain structure. Use when the user is building or reviewing an Akka SDK application (the Kalix-evolution Java framework, akka.javasdk.*), deciding which SDK component fits a problem, designing event-sourced entities / views / workflows / agentic features, or structuring an SDK service for deployment — even if a specific component isn't named. This is the Akka SDK counterpart to the akka-architect agent (which covers the Core actor libraries).

Packages and ships SwiftPM-based macOS apps and prepares App Store release artifacts — scaffolding/building/bundling a .app without an Xcode project, code signing and notarization, and generating user-facing release notes / "What's New" from git history. Use when the user wants to package or release a macOS/iOS app, assemble a .app bundle from SwiftPM, sign/notarize a build, or produce App Store release notes/changelog. Active: it runs build/packaging commands; it does not invent signing identities or secrets.

A warm, practical guide for starting and registering a business in Canada (with a Quebec focus) — choosing a legal structure, registering with the Québec Registraire des entreprises (NEQ), federal vs provincial incorporation, the CRA business number and program accounts, and the Quebec GST/QST-via-Revenu-Québec specifics. Use when someone wants help planning their business setup, deciding sole-proprietor vs incorporation, or figuring out which registrations/numbers/accounts they need. Educates and lays out the steps and trade-offs; it is NOT legal, tax, or accounting advice and defers filings/decisions to the REQ/CRA/Revenu Québec or a professional. Advisory.

Writing and understanding 6502 assembly language, distilled from Nick Morgan's *Easy 6502* tutorial. Covers the MOS 6502 CPU model (the A/X/Y registers, SP stack pointer, PC program counter, and the processor status flags N V B D I Z C), hex/binary number notation (`$` hex, `#` immediate literal vs memory reference), the instruction set (load/store LDA/STA/LDX/LDY, transfers TAX/TXA/…, arithmetic ADC/SBC with the carry flag, increment/decrement INX/DEX, logic AND/ORA/EOR/BIT, shifts ASL/LSR/ROL/ROR, compares CMP/CPX/CPY, BRK/NOP), all addressing modes (immediate, zero page, zero-page/absolute indexed by X/Y, absolute, indirect, indexed-indirect (zp,X), indirect-indexed (zp),Y, relative, implicit), control flow (branches BNE/BEQ/BCC/BCS/BMI/BPL on flags, JMP, JSR/RTS subroutines), the stack ($0100–$01ff, PHA/PLA), labels and assembler constants/defines, and worked examples up to a full Snake game. Use whenever writing, reading, debugging, or explaining 6502 assembly, reasoning about registers/flags/addressing modes, retro/6502-family programming (NES, C64, Apple II, Atari, BBC Micro), or low-level/CPU-architecture learning. Pairs with operating-systems, osdev-kernel, and information-theory.

Standards for connecting AI agents to their tools and to each other — the Model Context Protocol (MCP) for agent↔tool/context, and the Agent2Agent (A2A) protocol for agent↔agent collaboration. Covers the clean split "MCP = vertical (model↔tools/data), A2A = horizontal (agent↔agent)"; MCP's JSON-RPC client–host–server architecture and primitives (Resources, Tools, Prompts exposed by servers; Sampling, Roots, Elicitation exposed by clients), transports (stdio, Streamable HTTP), and the 2025-11-25 revision; and A2A's Agent Card discovery (/.well-known/agent-card), Client/Server roles, the Task lifecycle, Message/Part/Artifact, contextId grouping, JSON-RPC/gRPC transports with SSE streaming and push notifications, and auth. Use when designing how agents expose or consume tools, integrating an MCP server/client, enabling cross-framework/multi-vendor agent collaboration, choosing MCP vs A2A, or reasoning about agent discovery, transports, and security. Specs evolve — figures are dated; re-verify. Pairs with agentic-workflows and sdlc-orchestration; security via secure-coding.

Designing and building agentic AI systems — when to use a single LLM call, a structured workflow, or an autonomous agent, and the proven composition patterns for each. Distilled from Anthropic's "Building Effective Agents," the Claude Agent SDK, and LangGraph. Covers the workflow-vs-agent distinction (predefined paths vs model-directed control), the building block (augmented LLM = model + tools + retrieval + memory), the five workflow patterns (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer), the autonomous agent loop (gather context → act via tools → verify work → repeat), the maker-checker / generator-critic pattern, and the engineering disciplines that matter (start simple, add complexity only when it pays, ground verification in real tool execution, manage context, design tools and guardrails carefully, human-in-the-loop). Use when architecting a multi-agent or agentic system, choosing an orchestration pattern, deciding workflow vs agent, wiring role agents together, or evaluating a framework (Claude Agent SDK, LangGraph, CrewAI, AutoGen). Provides the runtime mechanics for sdlc-orchestration's role agents.

Akka Typed actors (Akka Core 2.10.x, akka-actor-typed) in Scala and Java — the foundation of all Akka modules. Covers Behaviors (functional & object-oriented styles), the typed message protocol, ActorContext, actor lifecycle (spawn/stop/watch/SpawnProtocol), interaction patterns (tell, request-response, adapted response, ActorContext.ask vs AskPattern, pipeToSelf, StatusReply), supervision and fault tolerance ("let it crash"), actor discovery via the Receptionist, routers (pool & group), stash, behaviors-as-FSM, dispatchers, mailboxes, and testing (ActorTestKit, BehaviorTestKit, TestProbe, LoggingTestKit). Use whenever writing or reviewing Akka actor code, designing an actor message protocol, choosing an interaction pattern, setting up supervision, discovering or routing actors, tuning dispatchers/mailboxes, or testing actors — even if "Akka" isn't named but actors/Behaviors/ActorRef/typed messaging are involved. The base skill the akka (meta), akka-cluster, akka-persistence, and akka-streams skills build on.

Akka Cluster (Akka Core 2.10.x, Typed API) in Scala and Java — building elastic, resilient, distributed systems from multiple ActorSystems. Covers cluster membership (gossip, phi-accrual failure detector, leader, member lifecycle), forming a cluster (seed nodes, Cluster Bootstrap, roles), and the higher-level tools: Cluster Sharding (distributing stateful entities), Cluster Singleton, Distributed Data (CRDTs), Distributed Pub-Sub, Sharded Daemon Process, Reliable Delivery, Artery remoting + TLS, the Split Brain Resolver, and Coordination/Lease. Use whenever designing or operating an Akka cluster, distributing actors/entities across nodes, sharding aggregates, needing a cluster-wide singleton, replicating state with CRDTs, handling network partitions/split brain, configuring remoting/seed-nodes/downing, or doing cluster-aware pub-sub or routing — even if "cluster" isn't named but multi-node Akka, sharding, entities, or partition-tolerance are involved. Builds on the akka-actors skill.