sumik

このコマンドは、前回のgitタグから現在までの変更履歴を分析し、Keep a Changelog形式でCHANGELOG.mdエントリーを自動生成します。

会話履歴とステージ済み変更からConventional Commits準拠のコミットメッセージを生成・表示

docs/e2e-testing/RUNBOOK.md を読み込んでその中身を実行する

Webアプリケーションのコードを分析し、ユーザーストーリードキュメント（`docs/user-story.md`）とE2Eテストケースドキュメント（`docs/e2e.md`）を作成または更新します。

このコマンドは、CHANGELOG.mdから該当バージョンのエントリーを抽出し、annotated tagを自動作成します。

このコマンドは、現在のブランチの変更点とコミットメッセージを分析し、GitHubプルリクエスト用の文章を自動生成します。

Run react-doctor to diagnose React code for security, performance, correctness, and architecture issues. Outputs a 0-100 health score with actionable diagnostics.

CLAUDE.mdを再読み込みしてcompaction後のコンテキストを復元

現在のプロジェクトのserenaデータを最新化

Token-efficient Serena MCP command for structured app development and problem-solving

Elite app development agent that uses /serena command for token-efficient, structured problem-solving. Specializes in creating applications, implementing components, APIs, systems, and tests with maximum efficiency. Examples: <example>Context: User needs to create a new React component. user: 'I need to implement a data table with sorting and filtering' assistant: 'I'll use /serena to efficiently design and implement this component with all features' <commentary>Component creation benefits from /serena's structured approach for clean, maintainable code.</commentary></example> <example>Context: User is building a new API endpoint. user: 'Help me create a REST API for user management' assistant: 'Let me use /serena to architect this API with proper patterns and security' <commentary>API development requires systematic design that /serena provides efficiently.</commentary></example>

AI/ML development specialized Tachikoma execution agent. Handles Vercel AI SDK integration, LangChain.js, RAG system building, MCP server/client development, LLMOps operations, and AI-assisted development patterns. Use proactively when building AI-powered web features, RAG pipelines, MCP integrations, or LLM application deployment. Detects: ai/@vercel/ai/@langchain in package.json, google-adk in Python deps, or @modelcontextprotocol/sdk.

Architecture design specialized Tachikoma (READ-ONLY). Analyzes systems using DDD strategic/tactical patterns, microservices architecture (CQRS, Saga, Event Sourcing), trade-off analysis methodology, data architecture patterns, and Clean Architecture (dependency rules, concentric layer model, component principles). Use proactively for architecture reviews, system design, domain boundary analysis, modernization planning, or multi-tenant SaaS design. Does NOT write implementation code - produces design documents and recommendations only.

AWS cloud specialized Tachikoma execution agent. Handles Lambda, API Gateway, DynamoDB, CDK, EKS, S3, Bedrock, and all AWS services including security (IAM, KMS, GuardDuty), cost optimization, and SRE operations. Use proactively when working with AWS services, CDK infrastructure, serverless applications, or AWS-related code. Detects: cdk.json, samconfig.toml, serverless.yml, @aws-sdk in package.json, or boto3 in Python deps.

Bash shell scripting specialized Tachikoma execution agent. Handles shell script automation, I/O pipelines, process control, system administration, and script testing/debugging. Use proactively when writing or maintaining shell scripts, automating system tasks, or building CLI tools. Detects: .sh files.

Database specialized Tachikoma execution agent. Handles relational database design, normalization, SQL optimization, schema migrations, and database internals understanding. Use proactively when designing database schemas, writing complex SQL, optimizing queries, planning migrations, or troubleshooting database performance. Detects: .sql files, schema.prisma, or DB-related packages.

Design specialized Tachikoma execution agent. Handles Figma MCP integration (all 13 tools), Figma Make context, Code Connect mappings, Design System Rules generation, design token synchronization, visual validation, design system construction/governance, Tailwind CSS styling methodology, and UI/UX design principles. Use proactively when converting Figma designs to code, managing design systems, building/evolving design systems, implementing design tokens with Tailwind CSS, or making UI/UX design decisions. Detects: Figma URLs in user prompts, .figma/ directory, design-system-rules files, or design system architecture tasks. Also covers design thinking process methodology (empathize, define, ideate, prototype, test) for user research and ideation workshops.

Documentation and technical writing specialized Tachikoma execution agent. Handles technical documentation (7Cs principle), LaTeX academic reports, Zenn tech articles, and AI-assisted copywriting. Use proactively when creating documentation, writing tech blog posts, preparing academic reports, or crafting marketing copy. Does NOT write application code.

E2E testing and browser automation specialized Tachikoma execution agent. Handles Playwright test design, browser automation via agent-browser CLI, visual testing, accessibility testing, and CI/CD integration. Use proactively when writing E2E tests with Playwright, automating browser interactions, or setting up browser-based test infrastructure. Detects: playwright.config.* files.

Frontend component implementation specialized Tachikoma execution agent. Handles component implementation with shadcn/ui, Storybook story creation and interaction testing, and data visualization (charts/dashboards). Use proactively when creating UI components with shadcn/ui, writing Storybook stories, building interactive interfaces, or creating data charts/dashboards. For design principles, Figma integration, design systems, or Tailwind CSS architecture, use タチコマ（デザイン） instead. Detects: components.json, .stories.tsx/.ts files.

Full-stack JavaScript specialized Tachikoma execution agent. Handles NestJS/Express backend development, RESTful API design, structured logging, and full-stack integration. Use proactively when building backend APIs with NestJS or Express, implementing API endpoints, designing request/response patterns, or configuring application logging. Detects: package.json with express, nestjs, fastify, koa, or hapi dependency.

Go specialized Tachikoma execution agent. Handles Go development including clean code practices, GoF/concurrency/DDD design patterns, and Go internals (type system, memory, reflection). Use proactively when working on Go projects or writing Go code. Detects: go.mod.

Google Cloud specialized Tachikoma execution agent. Handles Cloud Run, BigQuery, VPC networking, Memorystore, GCP security, and data engineering. Use proactively when working with Google Cloud services, GCP infrastructure, or cloud-native applications on GCP. Detects: cloudbuild.yaml, .gcloudignore, or @google-cloud packages.

Infrastructure/DevOps specialized Tachikoma execution agent. Handles Docker containers, Compose orchestration, CI/CD pipeline configuration, and DevOps methodology. Use proactively when working with Dockerfiles, docker-compose.yml, CI/CD configs, or implementing DevOps practices. Detects: Dockerfile or docker-compose.* files.

Next.js/React specialized Tachikoma execution agent. Handles Next.js 16 App Router, Server Components, React 19 features, Turbopack, Cache Components, and next-devtools MCP integration. Use proactively when implementing Next.js pages, components, API routes, middleware, or React features in Next.js projects. Detects: package.json with 'next' dependency.

Observability specialized Tachikoma execution agent. Handles monitoring system design, OpenTelemetry instrumentation (traces, metrics, logs), structured logging architecture, SLO/SLI design, and alerting strategies. Use proactively when implementing observability, distributed tracing, metrics collection, log pipelines, or monitoring dashboards. Detects: @opentelemetry/* packages or prometheus.yml.

Python specialized Tachikoma execution agent. Handles modern Python development with uv/ruff/mypy tooling, FastAPI, Google ADK agent building, and Pythonic patterns. Use proactively when working on Python projects, building FastAPI services, or creating Google ADK AI agents. Detects: pyproject.toml or requirements.txt.

Security review specialized Tachikoma (READ-ONLY). Reviews code for OWASP Top 10 vulnerabilities, serverless security threats, IAM patterns, dynamic authorization (ABAC/ReBAC/Cedar), Keycloak IAM, and AI development security. Use proactively after code implementation for security audits, penetration test planning, or access control design. Does NOT modify code - produces security reports and recommendations only.

Terraform IaC specialized Tachikoma execution agent. Handles HCL configuration, module design, state management, Terragrunt wrapper patterns, and cloud provider resources. Use proactively when working with .tf files, terragrunt.hcl, or infrastructure as code definitions. Detects: .tf files or terragrunt.hcl.

Unit/Integration testing specialized Tachikoma execution agent. Handles TDD methodology, test design across all languages (Vitest/Jest, Go testing, pytest, etc.), React Testing Library, mock strategies, coverage optimization, and test refactoring. Use proactively when writing unit tests, integration tests, improving test coverage, or setting up test infrastructure. Detects: files containing 'test' or 'spec' in name (*test*, *spec*, *_test.go, test_*.py), vitest.config.*, jest.config.*, or pytest.ini.

Training program design and presentation improvement specialized agent. Handles training needs analysis (KSA, ADDIE, participant analysis), curriculum design (90/20/8 rule, EAT framework), behavior change design (CREATE Action Funnel, cheat/habit/conscious strategies), presentation content improvement (storytelling, 3-act structure, AIDMA, PUNCH principle, delivery techniques), and effective prose writing (7Cs, AI smell detection). Self-improving: updates own definition based on user feedback. Use proactively when designing training programs, reviewing presentation materials, improving workshop content, or creating training curricula.

TypeScript specialized Tachikoma execution agent. Handles advanced type system patterns, generics, conditional types, GoF design patterns in TypeScript, and type-safe architecture. Use proactively when deep TypeScript expertise is needed: complex type definitions, type refactoring, generic utility creation, or migrating JavaScript to TypeScript. Detects: tsconfig.json.

General-purpose Tachikoma execution agent for tasks not covered by specialized Tachikomas. Handles development, testing, documentation, and other technical tasks. Uses /serena for efficient development. When a task matches a specialized domain (Next.js, Python, AWS, etc.), prefer the domain-specific Tachikoma instead. PARALLEL EXECUTION: Claude Code can launch multiple Tachikoma instances for independent tasks.

Behavioral design methodology for products that change user behavior using CREATE Action Funnel (Cue, Reaction, Evaluation, Ability, Timing) and three strategies (cheat, habit, conscious action). Use when designing product features that aim to change user habits, increase engagement, or guide users toward beneficial actions. For visual UI/UX design principles, use applying-design-guidelines instead. For training program design and facilitation methodology, use designing-training instead. For human-centered design thinking process (user research, ideation, prototyping), use practicing-design-thinking instead.

Clean Architecture principles covering the Dependency Rule, concentric layer model (Entities, Use Cases, Interface Adapters, Frameworks & Drivers), component principles (cohesion: REP/CCP/CRP, coupling: ADP/SDP/SAP, stability metrics), Screaming Architecture, Humble Objects, boundary design, Partial Boundaries, and architecture anti-patterns. Use when designing application layer structure, enforcing dependency rules, separating business logic from frameworks/UI/databases, or evaluating architecture decisions against Clean Architecture. For code-level clean practices (SOLID details, code smells, refactoring), use writing-clean-code. For domain modeling and bounded contexts, use applying-domain-driven-design. For microservices distributed patterns, use architecting-microservices. For language-specific Clean Architecture implementations, see developing-react or developing-python.

UI/UX design principles covering visual design, user experience fundamentals, practical interface design rules, and design theory fundamentals. Use when making design decisions, evaluating existing interfaces, or implementing UI components. Covers typography, color, motion, cognitive psychology, interaction patterns, and 101 practical Do/Don't rules. Also covers design theory foundations for engineers (concept building, typography theory, CRAP/Gestalt, layout theory, color theory). NOT for frontend codegen (designing-frontend), behavior design (applying-behavior-design), data charts (designing-data-visualizations), Tailwind (styling-with-tailwind), design systems (building-design-systems), or design thinking (practicing-design-thinking).

Domain-Driven Design methodology covering strategic design (Bounded Context, Ubiquitous Language, Context Mapping), tactical patterns (Domain Model, Event Sourcing, CQRS), practical adoption (heuristics, EventStorming), and operational data decomposition with polyglot database selection. Use when designing domain boundaries, choosing business logic implementation patterns, decomposing monolithic data, or aligning software architecture with business strategy. For socio-technical architecture modernization and trade-off analysis, use modernizing-architecture instead. For microservices distributed patterns (Saga, messaging, granularity), use architecting-microservices instead. For data architecture read-side patterns and caching strategies, use architecting-data instead. For Clean Architecture layer design, dependency rule enforcement, and concentric model application, use applying-clean-architecture instead.

Semantic Versioning 2.0.0仕様に基づくバージョン判断ガイド。MAJOR/MINOR/PATCH判定、プレリリース・ビルドメタデータ、範囲指定を提供。 REQUIRED for all version-related decisions. Use when determining version bumps, creating releases, or managing dependencies.

Data architecture patterns covering read-side optimization (replicas, materialized views, CQRS, CDC, event sourcing), domain-based decomposition, polyglot persistence, and caching strategies (cache-aside, read-through, write-through, write-around). Use when designing data flow architecture, choosing read scalability strategies, or implementing caching for enterprise systems. For microservices patterns (Saga, granularity), use architecting-microservices instead. For DDD domain modeling, use applying-domain-driven-design instead. For database engine internals, use understanding-database-internals instead. For relational DB schema design, use designing-relational-databases instead. For GCP-specific data services (BigQuery, Dataflow, Dataproc), use developing-google-cloud instead.

Comprehensive software design trade-off analysis covering code-level decisions (duplication, error handling, flexibility, optimization), API design (usability, versioning), distributed systems (consistency, delivery semantics), and meta-decisions (library selection, trend evaluation, date-time handling). Use when evaluating design alternatives, making architectural decisions, or reviewing trade-offs in existing systems. For specific clean code rules, use writing-clean-code; for microservices patterns, use architecting-microservices; for API endpoint design, use designing-web-apis. For Clean Architecture-specific design decisions and layer boundary trade-offs, use applying-clean-architecture.

Micro-frontend architecture patterns covering vertical/horizontal split, composition strategies (Module Federation, iframe, Web Components, SSR, ESI), decision framework, and organizational adoption. Use when decomposing frontend monoliths, choosing micro-frontend composition patterns, or designing multi-team frontend architecture. For backend microservices patterns (Saga, granularity), use architecting-microservices instead. For socio-technical modernization strategy, use modernizing-architecture instead.

Microservices architectural patterns covering CQRS, Event Sourcing, 8 Saga pattern variants, distributed transactions, service granularity decisions, data ownership, workflow orchestration, and contract design. Use when designing microservices architecture, choosing transaction strategies, or deciding service granularity. Covers messaging, resilience, security, reuse, and data access patterns. For migration strategy and trade-off analysis methodology, use modernizing-architecture instead. For DDD domain modeling, use applying-domain-driven-design instead. For frontend decomposition patterns (micro-frontends), use architecting-micro-frontends instead. For green/sustainable microservices trade-offs and carbon-efficient architecture, use building-green-software instead. For data architecture patterns (read-side optimization, caching strategies), use architecting-data instead. For internal service architecture using Clean Architecture layers and dependency rules, use applying-clean-architecture instead.

Creates specialized Tachikoma sub-agent definitions (.md files in agents/) with proper frontmatter, skills pre-loading, and domain-specific instructions. Use when creating new agents, modifying existing agent definitions, or adding specialized Tachikoma variants. For skill creation, use authoring-skills instead. For agent runtime behavior, see implementing-as-tachikoma.

Creates effective Claude Code Skills with proper structure, naming, and evaluation. Use when creating new skills, converting source material (Markdown/PDF/EPUB/URL/multiple files/folders) into skills, or reviewing skill usage analytics. Covers naming conventions, progressive disclosure, multi-file grouping, source conversion, and lifecycle management.

Browser Agent CLIによるブラウザ操作自動化（セマンティックロケーター、状態永続化、ネットワーク傍受）。 Use when automating browser interactions via agent-browser CLI (NOT for E2E testing). E2Eテストは testing-e2e-with-playwright スキルを参照。

Identifies and prevents common SQL database design mistakes across logical design, physical design, query construction, and application development. Use when designing database schemas, writing SQL queries, reviewing data models, or implementing database-backed features. Covers 25 named antipatterns with detection signals, solutions, and exception cases. For code-level security (input validation, XSS, OWASP), use securing-code instead. For database model selection and data architecture decisions, use understanding-database-internals instead. For positive relational database design methodology (entity modeling, normalization process), use designing-relational-databases instead.

Google ADK (Agent Development Kit) for building intelligent AI agents with Python. MUST load when google-adk is detected in requirements or pyproject.toml. Covers Agent taxonomy, Agent types (LlmAgent/Sequential/Parallel/Loop/Base), Tools (FunctionTool/OpenAPI/MCP), Multi-Agent orchestration, A2A Protocol (JSON-RPC/REST), Runner, Session, Artifact, Memory, State lifecycle, Context (Caching/Compaction), RAG (Corpus/Vector Search/Agentic), Grounding, Plugin System, Callbacks/Guardrails (6 types), SSE Streaming, Live API, UI Integration (CopilotKit/Streamlit/Slack), Code Execution, LLM Models (Gemini/LiteLLM/Anthropic), Deployment (Cloud Run/Vertex/GKE), CI/CD, Cost optimization, Security (IAM/Data privacy), Responsible AI. Distinct from developing-python (general) by focusing on ADK patterns.

Design system construction and governance methodology covering system foundations, pattern taxonomy, organizational adoption, pattern library operations, and UI pattern catalog (20+ interaction patterns). Use when architecting, evaluating, or restructuring a design system, planning organizational adoption, or building a pattern library. NOT for component styling (applying-design-guidelines), design-to-code (implementing-design), frontend codegen (designing-frontend), Tailwind config (styling-with-tailwind), or design thinking (practicing-design-thinking).

Comprehensive green software engineering guide covering carbon efficiency, energy efficiency, hardware efficiency, and carbon awareness. MUST load when designing systems with sustainability requirements or optimizing carbon footprint. Covers code efficiency patterns, operational efficiency, carbon-aware computing, green AI/ML, measurement methodologies, and the Green Software Maturity Matrix. For monitoring-specific patterns, use designing-monitoring instead. For microservices architecture decisions, use architecting-microservices instead.

Multi-tenant SaaS architecture covering deployment models, tenant isolation, and data partitioning. Use when designing SaaS platforms or evaluating silo vs pool strategies. Covers identity, onboarding, tiering, and operations. For Next.js single-tenant SaaS (auth, payments), use building-nextjs-saas instead.

Builds full-stack AI SaaS applications with Next.js App Router. Use when implementing SaaS features like authentication, payment integration, credit-based billing, or AI API integration. For Next.js fundamentals, use developing-nextjs; for enterprise multi-tenancy, use building-multi-tenant-saas instead.

Comprehensive RAG (Retrieval-Augmented Generation) system building guide covering data loading pipelines (11 source types including Word, PDF, CSV, audio, video, multimodal), data preparation (metadata enrichment, text quality enhancement, 5 chunking strategies from character to agentic), and full RAG architecture overview with Python. Use when building RAG applications, designing data ingestion pipelines, or implementing text chunking strategies. For Python language best practices, use developing-python instead. For LLMOps operational framework, use practicing-llmops. For JavaScript/LangChain.js RAG in web apps with Vercel AI SDK, see integrating-ai-web-apps.

A/B testing and online controlled experiment methodology covering experiment design, statistical analysis (p-values, confidence intervals, sample size), OEC formulation, trustworthiness validation (SRM, novelty effects), and experimentation platform architecture. Use when designing A/B tests, analyzing experiment results, or building experimentation infrastructure. For general software testing, use testing-code instead.

Converts Claude Code agent definitions (.md) to Codex multi-agent format (config.toml + agent .toml). Use when porting Claude Code agents to Codex CLI. Accepts a single agent file path or a folder path as argument. When a folder is given, uses Agent Teams API to process files in parallel (MAX 5 workers) for fast batch conversion. Detects existing entries in config.toml and agent .toml files; auto-handles diffs in batch mode. Always fetches latest spec from https://developers.openai.com/codex/multi-agent.

Converts image-based EPUB files to Japanese text via LM Studio OCR. Use when user has an EPUB composed of scanned page images and wants plain text output. For skill creation from EPUB, use authoring-skills instead.

AI-assisted copywriting with 15 prompt techniques leveraging psychological triggers. Use when creating marketing copy, blog titles, ad headlines, or social media posts. Focuses on prompt engineering to generate compelling copy. For eliminating AI patterns from text, use writing-effective-prose instead.

Creates Anki flashcards from EPUB/PDF files by converting to markdown, auto-detecting content structure, and batch-importing via Anki MCP. Use when converting textbooks, question banks, or study materials into spaced repetition flashcards. For Anki MCP setup and direct card management, use using-anki-mcp instead.

Comprehensive data visualization principles covering chart type selection, color scales, design best practices, and data storytelling. Use when creating charts, dashboards, or any visual data representation. For UI/UX design principles, use applying-design-guidelines instead. For technical diagrams (flowcharts, architecture), use mermaid-diagrams instead.

Creates distinctive, production-grade frontend code with shadcn/ui integration. Use when implementing web components, pages, or applications requiring creative, polished UI code. Covers HTML/CSS/JS code generation and shadcn/ui component management. For Storybook story creation and component testing, use developing-storybook instead. For theoretical UI/UX design principles, use applying-design-guidelines instead. For Tailwind CSS methodology, component design patterns, and design system construction, use styling-with-tailwind instead. For design system methodology (pattern language, organizational strategy, UI pattern catalog, anti-patterns), use building-design-systems instead.

Designs monitoring and observability systems covering anti-patterns, design patterns, layer-based strategy (6 layers), alerting, on-call operations, incident management, telemetry pipeline architecture, observability concepts (structured events, core analysis loop), SLO-based reliability, sampling strategies, and observability maturity model. Use when designing monitoring strategy, setting up alerting, choosing monitoring tools, building observability systems, implementing SLOs, or adopting observability practices. For OpenTelemetry SDK/API implementation, use implementing-opentelemetry instead. For green software carbon metrics and sustainability monitoring, use building-green-software instead. For Google Cloud monitoring (Cloud Logging, Security Command Center, Cloud Run), use developing-google-cloud instead. For LLM-specific evaluation and monitoring, use practicing-llmops. For application logging design, structured logging, and log collection pipelines, use implementing-logging instead.

Guides relational database design from requirements to implementation covering entity modeling, ER diagrams, normalization (1NF-BCNF), optimization, and PostgreSQL-specific implementation (microservices data architecture, ACID transactions, functions/stored procedures, AAA security). Use when designing database schemas, creating ER diagrams, normalizing tables, implementing SQL DDL, or developing PostgreSQL-backed applications. For database internals (storage engines, distributed systems), use understanding-database-internals instead. For SQL antipattern detection and avoidance, use avoiding-sql-antipatterns instead.

Training program design and facilitation methodology covering needs analysis (participant analysis, stakeholder mapping), KSA framework, instructional design theory (ADDIE, TOTE, Gagné, mastery learning), objective setting, activity catalog, training operations (instructor, space, logistics), brain science principles (7±2 rule, long-term memory, habit formation), learner-centered facilitation (90/20/8 rule, EAT), online/hybrid delivery, skill map creation, and training material development. Use when designing training programs, facilitating workshops, creating training materials, building skill maps, or managing training operations. For behavior design→applying-behavior-design. For presentation content→improving-presentations. For design thinking process methodology (empathize/define/ideate/prototype/test)→practicing-design-thinking.

Web API design best practices for endpoints, responses, HTTP spec usage, versioning, and security. Use when designing REST-style HTTP APIs or creating new endpoints. For framework-specific implementation (Express, NestJS), use respective framework skill; for microservices patterns, use architecting-microservices instead. For API usability vs maintenance trade-off analysis, use analyzing-software-tradeoffs. For spec-first development methodology and E2E test frameworks, use developing-api-spec-first instead.

API Spec First development methodology covering spec writing, E2E test framework architecture, technical debt repayment, and defensive programming for APIs. Use when adopting spec-first API development, building E2E test frameworks for backend services, documenting undocumented APIs, or writing comprehensive API specifications. For HTTP REST API design patterns, use designing-web-apis instead. For testing strategy and test pyramid, use testing-web-apis instead.

AWS development guide covering serverless (Lambda, API Gateway, DynamoDB, Step Functions), CDK, EKS, SRE, cost optimization (FinOps/CCoE), security (IAM, VPC, KMS, GuardDuty), GenAI (Bedrock, RAG, Agents), databases (Aurora, DynamoDB, ElastiCache), data engineering (Glue, Athena, Redshift), developer tools (CodePipeline), Cloud Design Patterns (57 CDP), VPC architecture (subnet, CIDR, Transit Gateway), enterprise architecture (multi-account, Landing Zone, 14 business system patterns), and cloud migration strategies (7R, AWS MGN, database migration). MUST load when working with AWS services, detected by aws-cdk or @aws-sdk in package.json, cdk.json, samconfig.toml, serverless.yml, template.yaml (SAM), or eksctl configs. For GCP→developing-google-cloud, Terraform→developing-terraform, Docker→managing-docker, monitoring→designing-monitoring, RAG→building-rag-systems, LLMOps→practicing-llmops, serverless security→securing-serverless, logging→implementing-logging.

Comprehensive Bash shell scripting and automation guide covering fundamentals, control flow, I/O pipelines, process control, system administration automation, testing/debugging, security, design patterns, and penetration testing automation (Nmap, web scanning, exploitation, Wi-Fi assessment, reporting). MUST load when .sh files are detected or shell scripts are being written. For Docker-specific patterns, use managing-docker instead. For broader DevOps methodology, use practicing-devops instead.

Full-stack JavaScript development covering backend (NestJS/Express), frontend (React), deployment (CI/CD), and quality. MUST load when package.json contains Express, NestJS, or similar backend frameworks. Covers API design, state management, caching, and testing. For application logging design and structured logging patterns, use implementing-logging.

Comprehensive Go development guide covering clean code practices, design patterns (GoF/concurrency/DDD), and internals (type system/memory/reflection). MUST load when go.mod is detected or Go code is being written. Covers naming, error handling, concurrency, testing, project structure, function design, data structures, refactoring strategies, GoF patterns, architectural patterns, type system internals, and performance optimization. For application logging design and structured logging patterns, use implementing-logging.

Google Cloud development guide covering Cloud Run (architecture, scaling, CI/CD), GCP security (IAM, VPC, KMS, DLP, SCC, Zero Trust, Chronicle), data engineering (BigQuery, Dataflow, data pipelines, governance), network engineering (VPC, load balancing, CDN, Traffic Director), and Memorystore (Redis/Memcached, cache patterns, resilience). MUST load when Dockerfile is detected with google-cloud packages, when cloudbuild.yaml is present, or when working with BigQuery, Dataflow, Dataproc, Cloud Interconnect, or Memorystore. For Docker-specific patterns, use managing-docker instead. For general monitoring design, use designing-monitoring instead. For code-level security (OWASP, CodeGuard), use securing-code instead. For data architecture patterns (CQRS, event sourcing), use architecting-data instead. For AWS development, use developing-aws instead. For serverless security (GCS hacking, Cloud Run abuse), use securing-serverless instead. For application logging, use implementing-logging.

Comprehensive MCP (Model Context Protocol) development guide covering architecture (Host/Client/Server roles, Tools/Resources/Prompts, Control Segregation), server and client implementation with TypeScript SDK, protocol specification (JSON-RPC 2.0, stdio/Streamable HTTP), and security threats (Tool Poisoning, Shadowing, Rug Pull, Prompt Injection). MUST load when building MCP servers or clients. For Claude Code plugin MCP configuration, use plugin-dev:mcp-integration instead. For MCP integration with Vercel AI SDK in web apps, see integrating-ai-web-apps.

Next.js 16.x development guide covering App Router, Server Components, Turbopack, React Compiler, proxy.ts, Cache Components, opt-in caching APIs (updateTag/revalidateTag/refresh), strict TypeScript, Tailwind CSS 4.x, Prisma 7.x, Zod 4.x, Vitest 4.x, Playwright, Docker. MUST load when package.json contains 'next' or next.config.* is detected. For React-specific concerns (internals, performance rules, animation, RTL testing), use developing-react. For SaaS patterns (auth, payments, AI), use building-nextjs-saas. For AI integration with Vercel AI SDK and LangChain.js, use integrating-ai-web-apps. For application logging design and structured logging patterns, use implementing-logging. For Tailwind CSS methodology, component design patterns, and customization, use styling-with-tailwind.

Modern Python development guide covering project setup, tooling, Pythonic best practices, OOP design principles, GoF design patterns, and SE process. MUST load when pyproject.toml or requirements.txt is detected. Covers Python 3.13 + uv + ruff + mypy, FastAPI/FastMCP, pytest, Docker, Effective Python idioms, software design patterns (encapsulation, LSP, Design by Contract), and SE practices (SDLC, Scrum/Kanban, CI/CD, deployment). For language-agnostic clean code principles, use writing-clean-code. For application logging design and structured logging patterns, use implementing-logging. For Clean Architecture in Python (layer implementation, test patterns, legacy refactoring), see references/CA-PYTHON.md. For general Clean Architecture principles, use applying-clean-architecture.

React 19.x development guide covering internals (rendering, reconciliation, Fiber), performance optimization (47+ react-doctor rules, memoization, bundle size), UI animation patterns (CSS transitions, easing, hover/touch), and React Testing Library (RTL queries, interactions, TDD patterns). Use when package.json contains 'react' (without 'next'), or when working on React-specific concerns in any framework. For Next.js-specific features (App Router, Server Components, Cache Components), use developing-nextjs instead. For E2E testing with Playwright, use testing-e2e-with-playwright. For general testing methodology, use testing-code. For Clean Architecture patterns in React (DI, SPA layer mapping, Redux integration), see references/CLEAN-ARCHITECTURE.md. For general Clean Architecture principles, use applying-clean-architecture.

Storybook development guide covering CSF3 story writing, interaction testing (play function), accessibility testing (axe-core), visual regression testing, Next.js/React framework integration, MSW network mocking, addon ecosystem, and story-driven component development. MUST load when .stories.tsx/.ts files detected or Storybook setup/configuration needed. For general frontend UI implementation, use designing-frontend. For E2E browser testing, use testing-e2e-with-playwright. For React-specific concerns (internals, performance, RTL), use developing-react.

Terraform IaC development with HCL syntax, module design, state management, and Terragrunt wrapper patterns. MUST load when .tf files or terragrunt.hcl are detected, or go.mod contains 'terraform'. Covers AWS/GCP infrastructure patterns and mise task automation. For Docker infrastructure, use managing-docker instead. For broader DevOps methodology and IaC tool comparison, use practicing-devops instead. For AWS CDK (TypeScript/Python IaC), use developing-aws instead.

AI-assisted development methodology covering prompt engineering, context engineering, code generation workflows, quality assurance, collaborative debugging, and agent collaboration patterns. MUST load when working with AI coding tools or discussing AI-assisted development practices. Use when crafting prompts for code generation, managing AI context, reviewing AI-generated code, or coordinating multi-agent development workflows. For AI copywriting techniques, use crafting-ai-copywriting instead. For testing-specific AI techniques (test data generation, exploratory testing with AI, test planning with AI), use testing-code AI references instead. For organizational AI development security strategy (trust frameworks, governance, AI-SPM), use securing-ai-development instead. For PM-specific Claude Code workflows (codebase investigation, feedback synthesis, competitive analysis, requirements generation), use using-claude-code-as-pm instead. For LLM application production operations, use practicing-llmops.

REQUIRED for all TypeScript/Python code. Automatically load when writing type annotations or handling external data. Any/any types strictly prohibited. Enforces strict mode configuration and type guard implementation.

Generates Google Slides presentations from unstructured text via Google Apps Script slideData arrays. Use when creating presentations from meeting notes, proposals, or memos. For presentation content quality improvement, use improving-presentations instead. For frontend UI components, use designing-frontend; for LaTeX documents, use writing-latex instead.

Operates as Tachikoma Agent (Implementation Worker) performing actual code implementation. Use when receiving task assignments from Claude Code for implementation work, test creation, or documentation. Adapts to frontend, backend, or testing roles based on task assignment.

General design implementation principles for translating any visual design into production-ready code. Covers design system integration, visual parity validation, responsive implementation, accessibility, and component organization. Use when implementing designs from any source (screenshots, mockups, specs). For Figma-specific workflows with Figma MCP, use implementing-figma instead. For design system architecture, pattern language theory, and organizational adoption strategy, use building-design-systems instead.

Dynamic authorization design covering ABAC, ReBAC, PBAC models and Cedar policy language. Use when designing access control systems, choosing authorization models, or writing Cedar policies. Distinct from securing-code (code-level) by focusing on authorization model selection and policy-based access control.

Comprehensive Figma MCP integration for design-to-code conversion. Covers all 13 Figma MCP tools, basic and advanced workflows (Figma Make, Code Connect, Design System Rules, design token sync), and visual validation. Use when converting Figma designs to code or managing design systems. Requires Figma MCP server. For general design implementation principles (non-Figma), use implementing-design instead.

アプリケーション・システムのログ設計・実装・収集・分析・運用の実践知識。 Use when: ログ出力コードを書く、ログ基盤を構築する、ログ分析・異常検知を実装する、セキュリティ監査に対応する。 書籍「実務で役立つ ログの教科書」（増井敏克著、翔泳社2025）の知見を凝縮。

OpenTelemetry implementation for distributed system observability covering instrumentation API/SDK and Collector deployment. Use when implementing tracing, metrics, or logging with OpenTelemetry. Covers Collector pipelines, semantic conventions, and organizational adoption strategies. For monitoring strategy, alerting design, telemetry pipeline architecture, observability concepts, SLOs, and sampling strategies, use designing-monitoring instead. For application-level logging design and log collection architecture beyond OTel Logs Signal, use implementing-logging.

Improves presentation content quality through storytelling, logical structure, audience engagement, slide design principles, and delivery techniques. Use when reviewing or enhancing presentation materials, restructuring slide decks, or preparing presentation scripts for clarity and impact. Covers the 5 domains: mindset/preparation (3 goals, core message design, 4 audience types), story/structure (1:2:1 three-act, AIDMA, situation-rain-umbrella frameworks), slide design, delivery (3 types of pauses, 3T principle, tension management, Q&A tactics), and audience engagement (listening paradigm, PUNCH principle, inclusive language). Focuses on content quality improvement, not technical slide generation. For HTML slide generation, use slidekit-create instead. For Google Slides API output, use generating-google-slides instead.

Comprehensive guide to integrating generative AI into web applications using Vercel AI SDK, LangChain.js, and MCP with React/Next.js. Use when building AI-powered web features (streaming chat, RAG, tool calling, structured data generation) in JavaScript/TypeScript projects. For RAG system internals, use building-rag-systems. For MCP protocol development, use developing-mcp. For Next.js framework specifics, use developing-nextjs.

AI/Growth Product Management guide covering AI strategy (organizational AI transformation, Data Operating Model), AI product lifecycle (8-stage: Problem Definition through Retraining/Maintenance), AI PM specializations (AI-Experiences/AI-Builder/AI-Enhanced), growth metrics (RAD framework, 4 PLG models, experimentation), responsible AI practices (bias mitigation, fairness, legal compliance), and PM career development. Use when making product decisions involving AI/ML features, evaluating AI opportunities, designing growth experiments, setting product metrics, building AI-native products, or navigating MLOps and deployment challenges. Covers: 3 PM specializations, HEART framework, MLOps CI/CD pipeline, data quality frameworks, retention/expansion strategies, cross-functional collaboration, GenAI evaluation methods, prompt engineering fundamentals.

Manages CLAUDE.md creation, improvement, and maintenance following 8 core principles (size limits, progressive disclosure, essential elements, living documentation). Use when starting new projects, reviewing existing CLAUDE.md, or when Claude repeatedly makes the same mistakes. For skill file authoring, use authoring-skills instead.

Docker development and operations guide covering Engine internals, images, containers, Compose, networking, volumes, security, AI (Model Runner), Wasm, development workflows, database containerization, monitoring/logging (Prometheus, Grafana, ELK), and deployment strategies. MUST load when Dockerfile, docker-compose.yml, docker-compose.yaml, or .dockerignore is detected. Covers container management via Docker MCP, multi-stage builds, cache optimization, security hardening, supply chain security, and image size minimization. For Podman/Buildah/Skopeo workflows and rootless containers, use managing-podman instead. For Terraform IaC, use developing-terraform instead. For Google Cloud (Cloud Run, IAM, VPC, KMS), use developing-google-cloud instead. For AWS development (EKS, Lambda, CDK), use developing-aws instead. For broader DevOps methodology and orchestration strategy, use practicing-devops instead. For general monitoring design and SLO strategy, use designing-monitoring instead. For application logging design and container log collection, use implementing-logging.

Comprehensive Keycloak identity and access management guide covering OIDC/SAML protocols, SSO, Realms, Clients, Users, Roles, authentication flows, MFA, authorization policies, JWT token management, application integration (Java/Node.js/Spring Boot), Docker/Kubernetes deployment, clustering, and SPI extensions. MUST load when keycloak.json, keycloak.conf, or Keycloak-related dependencies are detected. For general security practices, use securing-code instead. For Cedar/ABAC/ReBAC authorization models, use implementing-dynamic-authorization instead.

Podman container management and DevOps guide covering daemonless architecture, rootless containers, Buildah image building, Skopeo image operations, Pods, storage, networking (Netavark), security (user namespaces, SELinux, capabilities, image signing), systemd Quadlet integration, Kubernetes YAML generation, Docker migration, and Podman Desktop/AI Lab. MUST load when Containerfile is detected, or when podman/buildah/skopeo CLI usage is identified. Also load when Dockerfile is detected alongside Podman-specific signals (podman-compose.yml, .containers/, podman commands). Covers container lifecycle, multi-stage builds, CI/CD integration, troubleshooting, and monitoring. For Docker-specific workflows (Docker Engine, Docker Compose, Docker Swarm), use managing-docker instead. For Terraform IaC, use developing-terraform instead. For broader DevOps methodology, use practicing-devops instead. For container security auditing, use securing-code instead.

Comprehensive guide to managing Software-Defined Networks with AI agents covering architecture patterns, SDN operations, security, infrastructure automation, and SD-WAN optimization. Use when designing, implementing, or operating AI-driven SDN/SD-WAN systems. For general network monitoring patterns, use designing-monitoring instead.

Comprehensive TypeScript guide covering type system, advanced patterns, design patterns (GoF Creational/Structural/Behavioral), functional/reactive programming, framework integration, and 83 best practice decision criteria. MUST load when working in TypeScript projects detected by tsconfig.json. Covers Generics, Conditional Types, type inference, type design, SOLID/DDD in TypeScript, anti-patterns, and practical migration tips. For strict type safety rules, use enforcing-type-safety instead.

Comprehensive guide for creating 22+ diagram types using Mermaid syntax. Use when users need to visualize software architecture (class, sequence, flowchart, ERD, C4, block, architecture), document processes (state, gantt, timeline, kanban, user journey, gitgraph), or present data (pie, xy, quadrant, radar, sankey, treemap). Also includes specialized diagrams (ZenUML, packet) and advanced theming. Triggers include "diagram", "visualize", "model", "map out", "show the flow", or requests for architecture, database schemas, workflows, or data visualization. For data chart design principles (chart type selection, color scales, visualization best practices), use designing-data-visualizations instead.

Socio-technical architecture modernization covering strategy, domain design, team organization, and trade-off analysis methodology. Use when modernizing legacy systems, redesigning domain boundaries, planning migration strategies, or building custom trade-off analysis frameworks. Differs from writing-clean-code (code-level) by focusing on system-level decisions. For microservices patterns (Saga, granularity), use architecting-microservices instead. For DDD domain modeling, use applying-domain-driven-design instead. For micro-frontend architecture patterns, use architecting-micro-frontends instead. For comprehensive trade-off analysis across code/API/system levels, use analyzing-software-tradeoffs. For target architecture design using Clean Architecture principles, use applying-clean-architecture.

Codex Agentオーケストレーション（planner→Wave並列起動・最大並列度・ドキュメント先行開発）。 Use when orchestrating Codex agents for tasks requiring planning and multi-agent parallel implementation. Triggers: 複数ファイル変更、マルチ関心事開発、Codex環境でのAgent協調。Wave分割で独立タスクを同時並列起動。

Agent Teamオーケストレーション（チーム編成・タチコマ並列起動・進捗管理）。 Use when multiple files need parallel changes with independent concerns (2+ files, frontend+backend, UI+API+test). Triggers: 複数ファイル並列変更、マルチ関心事開発、フロントエンド+バックエンド同時変更。

デザイン思考のプロセス方法論（共感・問題定義・発想・プロトタイプ・テスト）の実践ガイド。 Use when planning user research, running design sprints, facilitating ideation workshops, or applying human-centered design methodology to product development. UI/UXの視覚的デザインには applying-design-guidelines を、行動変容デザインには applying-behavior-design を使用。

Comprehensive DevOps and software delivery methodology covering evolution stages, IaC tool selection (ad hoc scripts, config management, server templating, provisioning), orchestration comparison (server, VM, container, serverless), CI/CD pipelines, networking, security, and observability. Use when designing infrastructure architecture, choosing deployment strategies, setting up CI/CD, or adopting DevOps practices incrementally. For Terraform-specific HCL/module development, use developing-terraform instead. For Docker container operations, use managing-docker instead. For monitoring system design, use designing-monitoring instead. For application logging strategy and log pipeline architecture, use implementing-logging.

Comprehensive LLMOps operational framework covering data engineering pipelines, model domain adaptation (fine-tuning, RAG, prompt engineering), API-first deployment, LLM evaluation metrics, LLMSecOps security audits, and infrastructure scaling. MUST load when building or operating LLM-based applications in production. For RAG implementation details, use building-rag-systems. For general monitoring patterns, use designing-monitoring. For AI development methodology, use developing-with-ai.

Best practices for Remotion - Video creation in React

Researches existing libraries before implementation to prevent reinventing the wheel. REQUIRED before writing any new functionality. Use when evaluating npm packages, pip packages, Go modules, or any third-party libraries to find and evaluate existing solutions.

Comprehensive code review methodology covering PR construction, commenting techniques, team working agreements, and review anti-patterns. Use when writing or reviewing pull requests, establishing a team review process, giving feedback, or diagnosing review friction. Triggers: pull request, code review, PR description, LGTM, review comment, team working agreement, TWA, review bottleneck, review delay.

Codex CLI (gpt-5.3-codex) でMarkdownプランファイルの致命的問題をレビュー（初回レビュー＋resume再レビュー）。 Use when reviewing implementation plans with Codex, or re-reviewing updated plans. For general Codex usage (code review, bug investigation), use using-codex instead.

AI-powered code review using CodeRabbit CLI. Use when user requests code review, PR feedback, or when quality/security checks are needed. Automatically runs review loops until Critical/Warning issues are resolved. For code review methodology and team process design, use reviewing-code instead.

Fallback web search via gemini CLI tool for complex queries and detailed information gathering. Use when Exa MCP is unavailable or for multi-step research requiring gemini's reasoning. For primary web search, use searching-with-exa instead.

Primary web search via Exa MCP covering 7 search categories (Company, Code, People, Financial Report, Research Paper, Personal Site, Tweet/X). Use when performing web searches, researching technologies, companies, people, academic papers, or social media. MUST load as first-choice search tool. For fallback search via gemini CLI, use searching-web instead.

Organizational security strategy for AI-powered software development covering trust frameworks, adaptive guardrails, AI-BOM, AI-SPM, governance models, and cross-functional ownership. Use when establishing security controls for AI coding assistants, agentic systems, or AI-accelerated SDLC workflows. For code-level security (OWASP, CodeGuard), use securing-code instead. For AI development methodology (prompts, context engineering), use developing-with-ai instead. For LLM-specific security (prompt injection, LLMSecOps), use practicing-llmops.

REQUIRED after all code implementations. Automatically load when implementation is complete to run CodeGuard security check. Covers input validation, secrets management, OWASP top 10 countermeasures, authentication/authorization patterns, and web penetration testing knowledge (reconnaissance, attack techniques, bypass methods). For dynamic authorization model design (ABAC/ReBAC/Cedar), use implementing-dynamic-authorization instead. For organizational AI development security strategy (trust frameworks, governance, AI-BOM), use securing-ai-development instead. For serverless infrastructure security (IAM, storage, functions across AWS/GCP/Azure), use securing-serverless instead. For security logging patterns, attack detection via logs, and compliance logging, use implementing-logging.

Comprehensive serverless security guide covering threat models, attack techniques, and defense patterns across AWS, Azure, and Google Cloud. Covers IAM credential abuse, storage misconfiguration, code injection, privilege escalation, and supply chain attacks with practical attack/defense examples. Use when developing or securing serverless applications (Lambda, Cloud Run, Azure Functions). For code-level security (OWASP, CodeGuard), use securing-code instead. For AWS development patterns, use developing-aws instead. For GCP development, use developing-google-cloud instead.

Generate HTML slide presentations (1 slide = 1 HTML file, 1280x720px) using Tailwind CSS, Font Awesome, and Google Fonts. Use when the user asks to create a new presentation deck or slide HTML files. Covers design guidelines, 15 layout patterns, component library, and PPTX conversion compatibility rules. Supports style selection (creative, elegant, modern, professional, minimalist) and theme selection (marketing, portfolio, business, technology, education). For presentation content improvement (storytelling, structure, messaging), use improving-presentations instead.

Convert PDF presentations to HTML slide templates using a visual reproduction approach. Pipeline: PDF → slide screenshots → Claude writes HTML matching each screenshot. Use when the user wants to convert a PDF to HTML slide templates, reproduce a presentation as HTML, or create reusable templates from existing decks. Triggers: 'pdf to html', 'convert pdf to template', 'reproduce this deck as html', 'create template from pdf'.

Tailwind CSS styling methodology covering utility-first philosophy, v4 CSS-first config, utility/modifier reference, component design patterns, customization (plugins, presets, JS API), migration strategies, and design system construction with design tokens. Use when styling web applications with Tailwind CSS or making CSS architecture decisions. For frontend code generation with shadcn/ui and Storybook, use designing-frontend instead. For general UI/UX design principles, use applying-design-guidelines instead. For design system strategy beyond CSS (pattern language, organizational adoption, UI pattern catalog, measurement), use building-design-systems instead.

REQUIRED for all feature implementations. Automatically load when writing or reviewing tests. Enforces TDD approach with AAA pattern, actual/expected variables, and 100% coverage goal for business logic. Covers Vitest, Jest, Playwright, and AI-augmented testing strategies. For React Testing Library (RTL) patterns and React-specific TDD, use developing-react instead. For Web API testing strategy (contract testing, performance, security), use testing-web-apis instead. For A/B testing and online controlled experiments, use conducting-ab-tests instead.

Playwright E2Eテストの設計・実装・運用ガイド。 Use when writing, reviewing, or maintaining E2E tests with @playwright/test. playwright.config.* 検出時に自動ロード。testing-code（テスト全般）とは異なりPlaywright E2E固有のパターンに特化。

Web API testing strategy covering design testing, exploratory testing, contract testing, automation, performance testing, security testing, and production monitoring. Use when designing API test strategies, writing API integration tests, or setting up contract testing with Pact. For general unit/integration testing patterns, use testing-code instead. For E2E browser testing, use testing-e2e-with-playwright instead. For spec-first development methodology with API-level E2E testing, use developing-api-spec-first instead.

Translates English text to Japanese using LM Studio's local LLM via OpenAI-compatible API. Use when English-to-Japanese translation is needed for flashcard creation or skill authoring. For general-purpose translation without local LLM, Claude handles it directly instead.

Comprehensive database internals reference covering storage engines (B-trees, LSM-trees, file formats, transactions, recovery) and distributed systems (failure detection, leader election, replication, consistency models, consensus algorithms). Use when designing database-backed systems, choosing storage engines, understanding consistency guarantees, or debugging distributed system behavior. For SQL-level antipatterns and query optimization, use avoiding-sql-antipatterns instead. For relational database design process (entity modeling, ER diagrams, normalization), use designing-relational-databases instead. For data architecture patterns (CQRS, event sourcing, caching strategies), use architecting-data instead. For GCP-specific data services (BigQuery, Dataflow, Dataproc), use developing-google-cloud instead.

Anki MCP Server integration for AI-assisted flashcard management covering deck operations, card review, note types, and media management. Use when interacting with Anki flashcards via MCP, creating study materials, or automating spaced repetition workflows. For bulk flashcard creation from EPUB/PDF files, use creating-flashcards instead. For MCP server/client development, use developing-mcp instead.

Guides product managers in using Claude Code for codebase investigation, bug triage, competitive analysis, customer feedback synthesis, requirements generation, and PM workflow automation. Use when working as a PM with Claude Code or when non-engineers need to investigate codebases, synthesize research, or generate product artifacts. For AI-assisted code development methodology, use developing-with-ai instead.

Codex CLI（OpenAI）を使用してコードや文言について相談・レビューを行う。 トリガー: "codex", "codexと相談", "codexに聞いて", "コードレビュー", "レビューして" 使用場面: (1) 文言・メッセージの検討、(2) コードレビュー、(3) 設計の相談、(4) バグ調査、(5) 解消困難な問題の調査 For plan document review with Codex, use reviewing-plans-with-codex instead.

draw.io MCP Server integration for creating and editing diagrams via 3 tools (XML/CSV/Mermaid). Use when creating architecture diagrams, flowcharts, org charts, ER diagrams, or any visual diagram that needs to be opened in the draw.io editor. For Mermaid syntax reference, use mermaid-diagrams instead. For MCP server development, use developing-mcp instead.

Next.js development integration tools via next-devtools MCP. MUST load when working on Next.js projects detected by package.json. Provides diagnostics, version upgrades, Cache Components optimization, and automatic error fixes. Primary tool for Next.js tasks.

Token-efficient structured development via /serena command. Use for component development, API implementation, system design, test creation, bug fixes, and optimization. Available for Claude Code本体 and all Agents including Tachikoma.

作業中のコードの差分を difit（GitHub風diffビューア）でブラウザ表示する。 Use when viewing code diffs in GitHub-style browser UI or reviewing GitHub PRs.

REQUIRED for all code implementations. Automatically load when writing or reviewing any code. Covers SOLID principles (SRP, OCP, LSP, ISP, DIP), 25 code smell categories with MAPPER principles, practical refactoring recipes, and software design laws (simplicity, change, defect probability, testing). Language-agnostic clean code guide. For language-specific practices and design patterns, use developing-go, mastering-typescript, or developing-python. For trade-off analysis on code duplication, error handling, and flexibility decisions, use analyzing-software-tradeoffs. For architecture-level clean design with dependency rules, layer separation, and component principles, use applying-clean-architecture.

Conventional Commits 1.0.0仕様に基づくコミットメッセージフォーマットガイド。type/scope/BREAKING CHANGEの判定とSemVerとの対応を提供。 REQUIRED for all commit messages and version descriptions. Use when writing git commit, jj describe, or jj commit messages.

Unified writing craft guide: prose fundamentals, AI smell detection (always active), technical docs (7Cs), engineering design docs (requirements spec, functional design, operation design), academic writing (Harvard, dissertation), university report/thesis writing, tech blog writing, Japanese prose craft, clarity/explanation techniques, web/digital writing, FAQ writing, and revision. REQUIRED for all text output — AI smell check is always active regardless of document type. Use when writing, reviewing, proofreading, or creating any document (technical docs, articles, engineering design documents (requirements specs, system design docs), reports, slides, emails, academic papers, dissertations, university reports, graduation theses, business documents, web content, FAQ/help docs, design specs). For Zenn articles→writing-zenn-articles. For LaTeX→writing-latex. For presentations→improving-presentations.

LaTeX document creation for Japanese academic reports. MUST load when .tex files are detected. Covers upLaTeX + dvipdfmx setup, minted code highlighting with Japanese font support, equations, figures, tables, and cover pages.

Zenn技術記事の作成・投稿ワークフローガイド（フロントマター仕様・命名規則・品質チェック・Lint設定）。 Use when creating or publishing technical articles on Zenn platform, writing tech blog posts, or setting up Zenn CLI projects. Triggers: "zenn", "記事", "ブログ", "技術記事", "投稿" For general writing principles (structure, sentence craft, style), use writing-effective-prose instead.

1 hook across 1 event