agentic

Structures, writes, and reviews Terraform infrastructure code. Covers module layout, remote state, workspace strategy, variable and secrets handling, CI plan/apply pipeline, naming conventions, and multi-region deployment patterns (provider aliases, per-region state, failover strategies), while delegating shared risk classification, version guards, and rollback contract to `terraform-risk-playbook`. Invoked when the user asks to write Terraform, set up infrastructure as code, or review IaC.

Creates or updates AWS-oriented Terraform module structure and implementation scaffolding. Focuses on file layout, variable/output contracts, provider and version constraints, tagging standards, safe composition patterns, and address-stability guardrails.

Designs and implements Terraform module tests for AWS-targeted modules. Covers terraform-native tests, validation gates, fixture composition, and risk-focused assertions for regressions, address migration, and unsafe changes.

Designs AWS-targeted Terraform infrastructure plans before implementation. Focuses on service selection, module boundaries, state/backends, environment separation, security/compliance guardrails, acceptance criteria, and explicit risk/validation assumptions.

Diagnoses Terraform/OpenTofu risk before generating changes. Defines the response contract, failure-mode routing, version/runtime guards, validation commands, and rollback expectations for modules, tests, CI, and state work.

Uses lightweight AWS stack emulation for faster local Terraform iteration. Defines what can be safely validated locally, compatibility caveats, and the handoff boundary to real-AWS verification and reviewed plan/apply flows.

Architecture-focused code review covering hexagonal boundary violations, DDD anti-patterns, CQRS misuse, and microservices coupling issues. Applied in addition to the language-specific review skill when architecture markers are detected. Invoked when reviewing hexagonal architectures, DDD patterns, or microservices boundaries.

Deep PHP-specific code review covering strict types, PHPStan compliance, PSR standards, domain modeling, and ORM boundary violations. Applied in addition to the generic code-review skill when PHP code is detected. Invoked when reviewing PHP PRs, Symfony/Laravel changes, or performing PHP-specific quality checks.

Deep Go-specific code review covering goroutine lifecycle, data races, error wrapping, domain modeling, and interface design. Applied in addition to the generic code-review skill when Go code is detected. Invoked when reviewing Go PRs, Go code changes, or performing Go-specific quality checks.

Deep Python-specific code review covering type annotations, async pitfalls, mutable defaults, threading safety, and domain modeling. Applied in addition to the generic code-review skill when Python code is detected. Invoked when reviewing Python PRs, Py changes, or performing Python-specific quality checks.

Orchestrates code review by detecting the project language and architecture, then routing to the appropriate specialized review skill (code-review-go, code-review-typescript, code-review-python, code-review-php, code-review-architecture). Falls back to the generic checklist when no specific skill applies. Invoked when the user asks for a review, code check, PR review, or quality assessment.

Deep TypeScript-specific code review covering type safety, ESM/CJS, async correctness, money precision, and domain modeling. Applied in addition to the generic code-review skill when TypeScript/JavaScript code is detected. Invoked when reviewing TS/JS PRs, TypeScript changes, or performing TypeScript-specific quality checks.

Generates a compact structural orientation document (.agentic/project-map.md) so any agent can understand codebase structure without filesystem exploration. Invoked when onboarding to a codebase, exploring unfamiliar projects, or auditing code layout and conventions.

Formats Markdown files consistently using project-native tooling first (repo scripts/config), then safe fallback formatters, and verifies the result with lint/check commands. Invoked when the user asks to format markdown, tidy docs, normalize README files, or fix markdown style drift.

Preserves cross-session continuity with deterministic MEMORY.md, index.md, and snapshot handoffs under .agentic/memories/.

Maintains concise indexed memory entries for applied plans under .agentic/memories/ with clear boundaries between memory and plan sources. Memory retrieval is prioritized before loading historical plan files.

Guides the user through selecting and configuring an MCP (Model Context Protocol) server for a project. Recommends servers based on the stack, then walks through the just mcp-add wizard. Invoked when the user asks to set up MCP, add a tool integration, or configure external service access for AI agents.

Issue-backed plan persistence on GitHub via one managed issue comment with an idempotent marker. Prefers GitHub MCP when available and falls back to `gh` CLI when MCP is unavailable or misconfigured. Uses local plan persistence only when issue persistence is unavailable or not desired.

Persists the current or completed plan as a structured Markdown file under .agentic/plans/ with a datestamped, slugged filename and registers it in the plans index. Enables multi-agent setups to discover past architectural decisions and plans without re-deriving context. Invoked when the user says "save this plan", "persist the plan", "record this decision", or at the end of any planning session that produced actionable architectural decisions.

Automatically persists every plan produced by the agent as a structured Markdown file under .agentic/plans/ with a datestamped slug and updates the plans index. Prevents PLAN.md from being accidentally committed to the repository. Invoked automatically at the end of any planning session — no user prompt required. Triggered whenever an agent completes a plan, proposes a multi-step approach, or produces an architectural decision.

Guides aggregate modeling decisions for DDD services: aggregate root boundaries, child entity vs value object decisions, invariants, snapshot/primitives mapping, specification/criteria usage, and repository contract design. Invoked when the user asks to model or refactor domain entities and aggregate behavior.

Orchestrates a GitHub-issue-driven delivery workflow from issue intake to PR creation using reviewer-first then worker execution. Invoked when the user provides a GitHub issue link/number and asks to start end-to-end delivery.

Designs implementation-grounded architecture, sequence, and flow diagrams from existing code and documentation. Ensures notation is chosen intentionally, avoids invented components or flows, and explicitly flags mismatches across ADRs, RFCs, and code.

Selects, configures, and integrates a static analysis tool for the project's language. Covers tool selection, rule configuration, CI integration, fixing existing violations, and pre-commit hook setup. Invoked when the user asks to add linting, set up static analysis, or configure a code quality tool.

Establishes or reviews directory layout, server/client boundaries, routing, data-fetching strategy, and testing structure for Next.js 14+ App Router TypeScript applications. Invoked when the user asks to structure a Next app, set App Router conventions, or review architecture for React parity.

Establishes or reviews the directory layout, feature boundaries, state design, routing approach, and data-fetching conventions for a React 18+ TypeScript application. Invoked when the user asks to structure a React app, set up a scalable architecture, or review React project organization.

Applies the three-tier test taxonomy for React applications: unit tests for hooks and pure logic, component tests for behavior and interactions, and end-to-end tests for user flows. Uses Vitest, React Testing Library, and Playwright while focusing on observable behavior over implementation details.

Establishes or reviews the directory layout, component conventions, composable design, Pinia store structure, and Vue Router configuration for a Vue 3 TypeScript application. Invoked when the user asks to structure a Vue app, set up the project layout, or review Vue architecture.

Applies the three-tier test taxonomy for Vue 3 applications: writes unit tests for composables and Pinia stores with Vitest, component tests for behaviour and user interactions with @testing-library/vue, and acceptance tests for full user flows with Playwright. Ensures tests focus on observable behaviour, not implementation details. Invoked when adding or reviewing tests for a Vue project.

Creates or updates local multi-service orchestration using docker compose. Covers compose.yaml design, service health checks, depends_on readiness, env files, named volumes, migrations/seeds jobs, verification commands, and cleanup workflows for local development.

Creates or updates an optimized, production-ready Dockerfile and .dockerignore. Focuses on image build strategy, runtime hardening, caching, and minimal production images. Invoked when the user asks to write a Dockerfile, improve container image quality, or harden image builds.

Executes the full PR-driven development workflow: create an isolated feature branch from the current work, commit all staged changes, rebase cleanly onto the selected base branch (skipping any ancestor commits already merged), push the branch, and open a GitHub pull request linked to a related issue. Includes guidance for stacked/chained PRs. Invoked when the user says "open a PR", "create a pull request", "push and PR", or "branch, rebase and PR".

Sets up and uses Git worktrees for parallel task workspaces in the same repository clone, including safe cleanup of local worktrees. Invoked when the user asks to work on multiple branches at once, isolate tasks without extra clones, or create/remove worktrees.

Gathers inputs, defines initiatives, prioritises with an impact/effort matrix, sequences dependencies, and produces a roadmap table. Invoked when the user asks to plan a technical roadmap, prioritise engineering initiatives, or create a quarter/half-year engineering plan.

Designs or reviews React component APIs. Handles prop drilling decisions, composition patterns, controlled/uncontrolled contracts, and minimal public API surfaces for React 18+ TypeScript components. Invoked when creating new components, refactoring existing ones, or reviewing component contracts.

Designs or reviews Vue 3 component APIs. Handles prop drilling decisions, applies compound component patterns with provide/inject, defines minimal public API surfaces with typed props/emits/slots, and enforces Vue 3.4+ composition conventions. Invoked when creating new components, refactoring existing ones, or reviewing component contracts.

Syncs engineering documentation (ADR, RFC, architecture) from docs/engineering/ to Confluence Cloud using the `mark` tool. Operates in two modes: scaffold (creates the directory tree locally) and CI sync (pushes on every main push). Only files with mark metadata headers are synced. Enforces diagram hierarchy (Mermaid > PlantUML > SVG > PNG).

Meta-skill: deploys the full agentic configuration to a target project — AGENTS.md composition, vendor file generation, and skill deployment — in a single workflow. Invoked when the user asks to deploy or update agent config, sync the agentic setup, or set up agents in a project.

Guides manual dependency injection wiring for Go services: three-tier naming taxonomy (Provide/MustProvide/Must), Must-pattern entrypoints, OS-signal-driven context lifecycle, common provider structs, infrastructure must-builders, interface-segregated bus registration, decorator/tracing wrappers, and per-responsibility DI file layout. Invoked when asked to wire or scaffold a Go service DI layer, or when reviewing code inside a di/ or wire/ package.

Transforms JSON input into Token-Oriented Object Notation (TOON) to reduce token consumption in LLM prompts and context windows. Applies the full TOON spec: inline primitive arrays, tabular format for uniform object arrays, and list format for heterogeneous or nested structures. Invoked when the user asks to compress, optimize, or convert JSON for LLM use, or to reduce token count on structured input data.