core

Run comprehensive agent-native architecture review with scored principles

Create engaging changelogs for recent merges to main branch

Create or edit Claude Code skills with expert guidance on structure and best practices

Enhance a plan with parallel research agents for each section to add depth, best practices, and implementation details

Remove AI-generated code slop from a branch. Use when cleaning up AI-generated code, removing unnecessary comments, defensive checks, or type casts. Checks diff against main and fixes style inconsistencies.

Use this agent when you need to explore API design decisions before implementation. This includes choosing between REST/GraphQL/gRPC, designing endpoint structures, versioning strategies, pagination approaches, error handling patterns, and authentication integration. Best used early in feature design when API surface area is being defined. <example>Context: The user is designing a new API for their service. user: "I need to build an API for our order management system" assistant: "I'll use the api-design-brainstormer agent to explore the design options" <commentary>Since the user is designing a new API, use this agent to explore trade-offs before committing to an approach.</commentary></example><example>Context: The user is considering changing their API approach. user: "Should we migrate from REST to GraphQL for our mobile app?" assistant: "Let me analyze this with the api-design-brainstormer agent to weigh the trade-offs" <commentary>API paradigm changes have significant implications that warrant structured exploration.</commentary></example>

Use this agent when you need to explore data modeling decisions before implementation. This includes schema design approaches, relationship modeling, primary key strategies, indexing considerations, soft delete patterns, audit trails, multi-tenancy, and migration strategies. Best used when designing new tables/collections or restructuring existing data. <example>Context: The user is designing a new feature that requires data modeling. user: "I need to add a comments system to our blog" assistant: "I'll use the data-model-brainstormer agent to explore the data model options" <commentary>Since the user needs to model new data, use this agent to explore trade-offs in schema design.</commentary></example><example>Context: The user is considering a data model change. user: "Should we normalize our user preferences or keep them as JSON?" assistant: "Let me analyze this with the data-model-brainstormer agent to weigh the trade-offs" <commentary>Normalization decisions have significant implications that warrant structured exploration.</commentary></example>

Challenge emerging approaches by actively seeking flaws, risks, and overlooked alternatives. Use during brainstorming to stress-test ideas before committing. Invoked with the current proposed direction to find weaknesses.

Get alternative perspectives on architectural decisions and feature planning from Google Gemini. Use when you want a second opinion from a different LLM on design approaches, trade-offs, or implementation strategies.

Use this agent when you need to explore security design decisions before implementation. This includes authentication methods, authorization patterns, data protection approaches, input validation, rate limiting, secret management, audit logging, and threat modeling. Best used when designing security architecture or evaluating security trade-offs. <example>Context: The user is designing authentication for a new service. user: "I need to add authentication to our API" assistant: "I'll use the security-brainstormer agent to explore the authentication options" <commentary>Since the user is designing authentication, use this agent to explore security trade-offs before committing.</commentary></example><example>Context: The user is evaluating authorization approaches. user: "Should we use RBAC or ABAC for our permissions system?" assistant: "Let me analyze this with the security-brainstormer agent to weigh the trade-offs" <commentary>Authorization pattern changes have significant security implications that warrant structured exploration.</commentary></example>

This skill should be used when building AI agents using prompt-native architecture where features are defined in prompts, not code. It covers creating autonomous agents, designing MCP servers, implementing self-modifying systems, and adopting the "trust the agent's intelligence" philosophy.

This skill should be used before implementing features, building components, or making changes when requirements need clarification. It guides exploring user intent, approaches, and design decisions before planning. Triggers on "let's brainstorm", "help me think through", "what should we build", "explore approaches", ambiguous feature requests, or when multiple valid interpretations exist.

Designs or reviews CLIs so coding agents can run them reliably: non-interactive flags, layered --help with examples, stdin/pipelines, fast actionable errors, idempotency, dry-run, and predictable structure. Use when building a CLI, adding commands, writing --help, or when the user mentions agents, terminals, or automation-friendly CLIs.

This skill should be used when a problem has been solved and needs to be captured as categorized documentation with YAML frontmatter for searchable institutional knowledge.

This skill should be used when working with SKILL.md files, authoring new skills, improving existing skills, or understanding skill structure and best practices. It provides expert guidance for creating, writing, building, and refining Claude Code skills.

1 hook across 1 event