tac

PROACTIVELY use when planning AI Developer Workflow execution with composable steps. Designs ADW orchestration strategies with Plan/Build/Review/Fix step composition.

PROACTIVELY use when designing agent files, system prompts, or configurations. Builds custom agent configurations for domain-specific problems using Claude Agent SDK patterns.

PROACTIVELY use when auditing or optimizing context composition. Modes - analyze (audit health, score context infrastructure), optimize (R&D framework recommendations for reduction and delegation). Specialized for context auditing and token efficiency.

PROACTIVELY use after implementation is complete to generate feature documentation. Creates concise documentation from implementation changes. Specialized for doc generation and conditional docs updates.

PROACTIVELY use when E2E tests fail. Analyzes failed E2E tests using screenshots and error context, applies fixes, and re-validates user journeys.

PROACTIVELY use when running end-to-end tests. Executes E2E test specifications with browser automation, captures screenshots, and reports structured results.

PROACTIVELY use when designing WebSocket event broadcasting for ADW observability. Creates event streaming specifications with summarization and client distribution.

PROACTIVELY use when querying domain expertise. Answers questions using an agent expert's expertise file as a mental model. Provides fast, grounded responses without code exploration. The REUSE step of Act-Learn-Reuse.

PROACTIVELY use when creating new agent experts. Generates initial expertise.yaml file from codebase analysis. Seeds a new agent expert's mental model by exploring code, identifying patterns, and creating structured YAML expertise.

PROACTIVELY use before self-improve to assess drift or for periodic health checks. Validates expertise file against codebase reality. Checks file paths, function names, and schema accuracy without making changes. Returns validation report with drift detection.

PROACTIVELY use when designing permission hooks for agent governance and security controls. Specialized for creating hook implementations that control agent permissions and provide audit trails.

PROACTIVELY use when classifying GitHub issues into problem classes (chore, bug, feature) for ADW routing. Specialized for classification decisions with nuanced understanding.

PROACTIVELY use after workflow completion to calculate and update agentic coding KPIs for ZTE progression tracking. Specialized for metrics analysis and trend assessment.

PROACTIVELY use when assessing agentic layer maturity. Analyzes codebase for agentic layer components and coverage. Specialized for audit and investment recommendations.

PROACTIVELY use when setting up new agentic projects. Creates minimum viable agentic layer structure including directories, templates, and stubs. Specialized for scaffolding.

PROACTIVELY use when designing complex multi-agent workflows requiring phase coordination. Plans multi-agent orchestration workflows with phase design and agent coordination.

PROACTIVELY use when creating minimal, surgical fixes for specific issues. Creates patch plans for targeted fixes. Specialized for scope-limited issue resolution.

PROACTIVELY use when generating plans from high-level requirements. Generates comprehensive plans from meta-prompt templates using extended thinking. Specialized for planning work - reads codebase, understands patterns, produces detailed specifications.

PROACTIVELY use when executing generated plans that require code changes. Follows plans precisely, makes code changes, runs validation commands. Specialized for implementation phase.

PROACTIVELY use when evaluating prompt files for improvement opportunities. Analyzes and classifies existing prompts by sophistication level, structural sections, and quality indicators.

PROACTIVELY use when creating new slash commands, skills, or agent prompts. Generates well-structured prompts at TAC sophistication levels 1-7 from high-level specifications.

PROACTIVELY use for fast codebase reconnaissance in multi-agent systems. Quickly analyzes specific areas of a codebase to provide findings for orchestration workflows. Optimized for parallel deployment.

PROACTIVELY use when executing generated plans that require code changes. Implements plans generated by the SDLC planner for ADW workflows. Specialized for implementation phase - follows plans precisely, makes code changes, runs validation.

PROACTIVELY use when converting GitHub issues to implementation plans. Generates comprehensive plans from GitHub issues for ADW workflows. Specialized for planning phase - analyzes issues, understands codebase, produces specifications.

PROACTIVELY use when expertise files need validation and updating. Runs self-improve workflow to validate mental model against codebase, identify drift, and update expertise.yaml to maintain accuracy.

PROACTIVELY use when ready to merge validated work to main. Validates state completeness and executes merge for ZTE shipping. Specialized for production deployment - the final gate before production.

PROACTIVELY use after implementation to validate against specification. Reviews implementation, captures screenshots, and classifies issues by severity. Specialized for spec-based validation.

PROACTIVELY use when tests fail. Analyzes failed tests, identifies root causes, applies fixes, and re-validates. Specialized for test failure resolution.

PROACTIVELY use when executing unit/integration tests and reporting results in structured JSON format. Specialized for test execution with comprehensive reporting.

PROACTIVELY use when creating MCP tools and custom SDK integrations. Generates custom tool boilerplate with @tool decorator including parameter schemas, error handling, and MCP server configuration.

PROACTIVELY use when coordinating multi-phase workflows. Manages phase transitions and result aggregation across agents. Specialized for orchestration of complex multi-agent workflows.

PROACTIVELY use when creating numbered steps, conditionals, loops, and delegation patterns for prompt workflows. Designs well-structured workflow sections for agentic prompts with appropriate control flow patterns.

PROACTIVELY use when validating ADW workflow step outputs and contracts. Checks step completeness, output formats, and success criteria.

PROACTIVELY use when setting up parallel agent environments. Creates isolated Git worktree environments for parallel agent execution. Specialized for environment configuration and isolation.

Guide creation of AI Developer Workflows (ADWs) that combine deterministic orchestration code with non-deterministic agents. Use when building automated development pipelines, designing AFK agent systems, or implementing the PITER framework.

Create specialized agent experts with pre-loaded domain knowledge using the Act-Learn-Reuse pattern. Use when building domain-specific agents that maintain mental models via expertise files and self-improve prompts.

Implement hooks for permission control and security in custom agents. Use when adding security controls, blocking dangerous operations, implementing audit trails, or designing permission governance.

Manage agent fleet through CRUD operations and lifecycle patterns. Use when creating, commanding, monitoring, or deleting agents in multi-agent systems, or implementing proper resource cleanup.

Guide creation of focused single-purpose agents following the One Agent One Prompt One Purpose principle. Use when designing new agents, refactoring general agents into specialists, or optimizing agent context for a single task.

Track and measure agentic coding KPIs for ZTE progression. Use when measuring workflow effectiveness, tracking Size/Attempts/Streak/Presence metrics, or assessing readiness for autonomous operation.

Assess agentic layer maturity using the 12-grade classification system (Class 1-3). Use when evaluating codebase readiness, identifying next upgrade steps, or tracking progress toward the Codebase Singularity.

Audit codebase for agentic layer coverage and identify gaps. Use when assessing agentic layer maturity, identifying investment opportunities, or evaluating primitive coverage.

Analyze existing prompt and suggest improvements using the Seven Levels framework

Audit a codebase for agentic layer coverage and identify investment opportunities. Use to assess agentic maturity and find gaps.

Design WebSocket event broadcasting for ADW observability. Use when streaming workflow events to external dashboards or monitoring systems.

Generate a comprehensive bug fix plan with root cause analysis. Use when you have a bug to investigate before implementing a fix.

Generate a comprehensive chore plan from a one-line description. Use for maintenance tasks, cleanup, refactoring, or dependency updates.

Classify a GitHub issue into a problem class (chore, bug, or feature) for ADW routing. Use to determine which planning template to apply.

Design closed-loop prompts with Request-Validate-Resolve structure for reliable agentic workflows. Use when creating self-validating agents, adding feedback loops, or improving agent reliability through verification.

Create a Git commit with agent attribution for ADW workflows. Use after implementing changes to create semantically formatted commits.

Design composable agentic primitives for flexible workflows. Use when creating reusable workflow building blocks, designing SDLC primitives, or building agent operations that can be combined in different ways.

Design Plan/Build/Review/Fix workflow steps for ADWs. Use when creating composable workflow primitives, defining step contracts, or implementing step isolation patterns.

Set up conditional documentation loading to prevent context pollution. Use when organizing project docs, implementing progressive disclosure, or reducing CLAUDE.md token consumption with on-demand loading.

Configure hook-based event handling for ADW observability. Use when setting up PreToolUse, PostToolUse, or other hooks for workflow monitoring.

Audit current context composition and identify optimization opportunities. Use when context window is overloaded, agents are underperforming, or applying the R&D framework to optimize token usage.

Design memory hierarchy with progressive loading for optimal context management. Use when organizing CLAUDE.md imports, implementing just-in-time context loading, or designing priming hierarchies for agents.

Load task-specific context dynamically based on task type (bug, feature, review, chore, research). Use to focus context before starting work.

Show current context window state and consumption analysis. Use to check context health and identify optimization opportunities.

Scaffold a new custom agent configuration with Claude Agent SDK patterns. Use when adding a new specialized subagent.

Scaffold a new agent expert structure with expertise.yaml, question, self-improve, and plan prompts

Generate a new agentic prompt at specified level (1-7) using meta-prompting. Use when creating new slash commands or workflow prompts.

Generate custom tool boilerplate with @tool decorator for Claude Agent SDK. Use when adding new tools to custom agents.

Design custom agents from scratch using Claude Agent SDK patterns. Use when building domain-specific agents, designing agents with full SDK control, or creating specialized agents with custom tools and prompts.

Generate configuration for a team of specialized agents. Use when setting up multi-agent workflows.

Generate concise feature documentation from implemented changes. Use after completing a feature to capture what was built for future reference.

Design E2E tests following user-story-driven patterns with verification checkpoints. Use when creating end-to-end tests, validating complete user journeys, or designing Playwright/Cypress test patterns.

Design YAML expertise file structures for agent experts. Use when creating mental models for domain-specific agents, defining expertise schema, or structuring knowledge for Act-Learn-Reuse workflows.

Generate a comprehensive feature implementation plan with user story, phases, and testing strategy. Use when planning new functionality before implementation.

Design gateway scripts as entry points for agentic coding. Use when creating CLI entry points for agents, designing subprocess-based agent invocation, or building script interfaces for agentic workflows.

Generate a semantic Git branch name from issue context for ADW workflows. Use before starting work on an issue.

Set up Git worktrees for agent parallelization with isolated environments. Use when setting up parallel agent execution, creating isolated environments per agent, or enabling concurrent development workflows.

Design hook-based event systems for ADW observability. Use when implementing real-time event broadcasting, creating hook pipelines, or building agent activity monitoring.

Execute a generated plan file - a Higher-Order Prompt (HOP) that accepts another prompt (the plan) as input. Use after generating a plan with /bug, /feature, or /chore.

Run self-improve on an expert's mental model to sync with codebase. Use periodically to keep expertise files accurate.

Set up isolated Git worktree environment for parallel agent execution. Use when parallelizing agents across branches.

Configure issue classification for ADWs to route work to the correct templates. Use when setting up automatic classification of GitHub issues into chores, bugs, and features.

Audit a codebase for the 12 leverage points of agentic coding. Identifies gaps and provides prioritized recommendations. Use when improving agentic coding capability, analyzing why agents fail, or optimizing a codebase for autonomous work.

List available tools for custom agent configuration. Use as reference when defining agent tool access.

Show the seven levels of agentic prompts with quick reference. Use when deciding prompt complexity level.

Reload previous session context from a context bundle file. Use to resume work from a previous session.

Create meta prompts, meta agents, and meta skills that build other agentic components. Use when scaling agentic layer development, creating generators/templates, or implementing "build the system that builds the system" patterns.

Guide creation of minimum viable agentic layer for a codebase. Use when starting agentic coding in a new project, bootstrapping essential components, or creating the minimal scaffolding for agent success.

Choose appropriate model for custom agent tasks. Use when selecting between Haiku, Sonnet, and Opus for agents, optimizing cost vs quality tradeoffs, or matching model capability to task complexity.

Build observability interfaces for multi-agent systems. Use when monitoring multi-agent execution, tracking agent metrics, implementing logging for parallel agents, or debugging agent workflows.

Run orchestration workflow for a complex task using multi-agent patterns. Use when a task requires coordinated scout-build-review phases.

Write prompts for orchestrator workflows with phases and aggregation. Use when designing multi-phase workflows, writing agent command prompts, or implementing result aggregation patterns.

Design O-Agent systems for multi-agent fleet management. Use when building orchestrator agents, designing multi-agent architectures, or creating unified interfaces for agent fleet control.

Create minimal, surgical patch plans for targeted fixes. Use when fixing specific issues from review, creating focused patches, or avoiding scope creep in fix implementations.

Create minimal surgical patch plan for targeted fix. Use for small, focused changes rather than full feature implementations.

Set up PITER framework elements for AFK agent systems. Use when configuring prompt input sources, triggers, environments, and review processes for autonomous agent workflows.

Assist in generating comprehensive plans from templates using extended thinking. Use when generating plans from meta-prompt templates, reviewing plan quality, or ensuring plans meet team standards.

Prime agent with codebase understanding. Runs git ls-files, reads README, and summarizes project structure. Use at start of session or when context is lost.

Design user-facing agent experts for adaptive UX and personalization. Use when building product features that learn from user behavior, creating per-user expertise files, or implementing AI-driven personalization.

Guide selection of appropriate prompt level for a task. Use when choosing between simple prompts and complex workflows, applying the seven levels framework, or matching task complexity to prompt investment.

Design composable prompt sections for building agentic prompts. Use when creating reusable prompt components, designing LEGO-block prompt sections, or structuring prompts for the stakeholder trifecta.

Create a GitHub pull request with full context linking back to the original issue. Use after implementation is complete and ready for review.

Ask an agent expert a question using its expertise mental model. Use for quick domain-specific answers without code exploration.

Apply R&D framework to optimize prompts and context. Use when optimizing context window usage, reducing prompt size, delegating to specialized agents, or applying systematic context management.

Analyze a failed E2E test, fix the underlying issue, and verify the fix. Use after /test-e2e reports failures.

Analyze a failed test, fix the underlying issue, and verify the fix. Use after /test reports failures.

Design spec-based review workflows with visual proof and issue classification. Use when setting up review processes, validating against specifications, or implementing screenshot-based visual validation.

Compare implementation against specification to verify alignment. Use after implementation to verify requirements are met.

Create minimum viable agentic layer structure for a project. Use when adding agentic capabilities to a new project.

Execute the scout-then-build pattern for a feature implementation. Use when you need to explore the codebase before implementing changes.

Generate initial expertise.yaml from codebase exploration. Use to bootstrap a new agent expert's mental model.

Write self-improve prompts that sync expertise files with codebase reality. Use when creating maintenance workflows for agent experts, designing validation logic, or implementing the LEARN step of Act-Learn-Reuse.

Validate state and merge branch to main for production deployment. Use as final ZTE step after all checks pass.

Add console output and logging to make errors visible to agents. Standard out is a critical leverage point - without it, agents cannot see errors or understand application state. Use when agents fail silently, when debugging agentic workflows, or when setting up a new codebase for agentic coding.

Start an AI Developer Workflow with composable steps. Use when executing plan_build, plan_build_review, or plan_build_review_fix workflows.

Design swimlane UI patterns for visualizing ADW execution. Use when building observability dashboards, monitoring agent workflows, or creating real-time status displays.

Design effective system prompts for custom agents. Use when creating agent system prompts, defining agent identity and rules, or designing high-impact prompts that shape agent behavior.

Set up task-based multi-agent systems with shared task files. Use when setting up parallel agent execution, designing worktree isolation patterns, or implementing task file coordination.

Guide creation of meta-prompt templates that encode engineering workflows into reusable, scalable units. Use when creating slash commands that generate plans, designing workflow templates, or encoding team best practices into agentic prompts.

Create Level 6 template meta-prompts that generate other prompts. Use when building prompt generators, designing high-leverage meta-prompts, or creating templates that scaffold other prompts.

Execute end-to-end test specification and report results. Use after implementation to validate user journeys before review.

Set up test validation commands for any project type. Use when configuring test runners, setting up validation commands for a new project, or enabling closed-loop agent workflows.

Run project test suite and report results in structured JSON format. Use to validate implementation before commit or review.

Create custom tools using the @tool decorator for domain-specific agents. Use when building agent-specific tools, implementing MCP servers, or creating in-memory tools with the Agent SDK.

List all available Claude Code tools with their parameters and capabilities. Use to understand current tool availability before starting a task.

Calculate and update agentic coding KPIs to measure ZTE progression. Use after completing an ADW cycle to track metrics.

Upgrade an existing prompt to a higher level. Use when a prompt needs more advanced capabilities (control flow, delegation, etc.).

Validate AI Developer Workflow step outputs and contracts. Use when verifying workflow step completeness before proceeding.

Guide progression from In-Loop to Out-Loop to Zero-Touch Engineering. Use when assessing agentic maturity, planning ZTE progression, or identifying requirements for autonomous operation.