Agent Task Mapping

Agent Task Mapping

• Leverage native parallel subagent dispatch and 200k+ context windows where available.

Activation Conditions

Use symptom -> action triggers: when one matches, apply this skill and verify with the protocol below.

Use this skill when:

• Determining which specialized agent to delegate a task to
• Reviewing agent capabilities and expertise areas
• Trying to match a specific task to an appropriate specialist
• Needing quick reference for available agents and their purposes

Available Agents

See Agent Details for comprehensive information about each agent:

• Description and specialization areas
• When to use each agent
• Typical tasks handled by each

Anti-Patterns

• Delegating or evaluating without a scoped success condition: The output becomes hard to review and easy to overbuild.
• Skipping the evidence step: A workflow that cannot be re-checked quickly is not ready for handoff.
• Bundling unrelated subtasks together: It creates noisy prompts, weaker ownership, and avoidable integration risk.

Verification Protocol

Before claiming "skill applied successfully":

1. Pass/fail: The Agent Task Mapping workflow names the agent boundary, delegated scope, and expected return artifact. 2. Pass/fail: Context passed to helpers is minimal, task-local, and free of hidden expected answers. 3. Pass/fail: Results are integrated only after evidence, diffs, or citations are checked by the controller. 4. Pressure-test scenario: Run the workflow on two similar tasks that must not share assumptions or leaked context. 5. Success metric: Zero context leakage; every delegated output is independently reviewable.

Examples & Scripts

• Delegation Examples — Code examples for delegating to different agents
• Agent Discovery Script — Node.js script to discover available agents

Quick Reference

Decision Framework

When choosing an agent for delegation:

1. Identify task type: Is it documentation, testing, two-stage review (spec compliance first, then code quality), or development? 2. Match to specialization: Find agent whose description aligns with task 3. Check availability: Verify agent exists and has proper frontmatter configuration 4. Use specific agentName: Delegate using exact name from agent's frontmatter

Task Categories

Code Analysis & Documentation

• Use Code Explainer for analyzing existing code patterns
• Use Tech Writer for formal developer documentation
• Use Specification for generating feature specifications

Code Quality & Maintenance

• Use Universal Janitor for cleanup and tech debt remediation
• Use Critical Thinking for challenging assumptions

Development Work

• Use Next.js Expert for Next.js 15/16+ architecture and optimizations
• Use Expert React Frontend Engineer for React 19+ patterns

Testing

• Use Playwright Tester Mode for comprehensive web application testing

Planning & Requirements

• Use Plan for research and outlining multi-step plans
• Use Create PRD Chat Mode for generating Product Requirements Documents

Design

• Use UI Designer for UI/UX improvements and design implementations

---

<!-- PORTABILITY:START -->

Cross-Client Portability

This skill is written to stay usable across GitHub Copilot, Claude Code, Codex, and Gemini CLI.

• GitHub Copilot: keep the folder in a Copilot-visible skill or plugin path, or wrap the workflow as project instructions if the host does not support portable skill folders directly.
• Claude Code: keep the folder in a local skills directory or a compatible plugin or marketplace source.
• Codex: install or sync the folder into $CODEX_HOME/skills/<skill-name> and restart Codex after major changes.
• Gemini CLI: this repository generates a project command named /skills:agent-task-mapping from this skill. Rebuild commands with python scripts/export-gemini-skill.py agent-task-mapping and then run /commands reload inside Gemini CLI.

<!-- PORTABILITY:END -->

<!-- MCP:START -->

MCP Availability And Fallback

Preferred MCP Server: None required

• Fallback prompt: "Use the Agent Task Mapping skill without MCP. Rely on the local SKILL.md, bundled references or scripts, and manual verification. Show the exact commands, evidence, and final checks you used before concluding."
• If the current host does not expose a matching server, use the bundled references, scripts, native toolchain, and manual workflow already described in this skill.
• Treat direct local verification, rendered output, logs, tests, or screenshots as the fallback evidence path before completion.

<!-- MCP:END -->

Related Skills

• custom-agent-usage: Use it when the workflow also needs loading and invoking custom agent definitions safely.
• subagent-delegation: Use it when the workflow also needs safe, scoped delegation to helper agents.
• subagent-driven-development: Use it when the workflow also needs plan-driven implementation with reviewer loops.
• agentic-eval: Use it when the workflow also needs rubric-driven evaluation loops.

Changelog

[2026-04-25] - Version 1.2 Verification Protocol Refresh

Added

• Added a Verification Protocol section with skill-specific pass/fail checks, one pressure-test scenario, and a measurable success metric.
• Added guidance to leverage native parallel subagent dispatch and 200k+ context windows where available.

Changed

• Updated SKILL.md frontmatter to version: "1.2" and last_updated: 2026-04-25.
• Reframed activation guidance toward symptom -> action triggers and standardized two-stage review wording where applicable.

[2026-04-24] - Version 1.1 Refresh

Changed

• Updated the SKILL frontmatter version to 1.1 for the 2026-04-24 catalog refresh.

[2026-04-24] - Skill Refresh

Changed

• Standardized the SKILL frontmatter with version metadata, last-updated date, tags, and a concise catalog description.
• Reformatted the portability and MCP guidance with a preferred server line, a copy-paste fallback prompt, and consistent bullet lists.
• Added a catalog-standard Anti-Patterns section and refreshed the Related Skills links at the end of the skill.

[2026-04-24] - Catalog Audit Cleanup

Fixed

• Removed obsolete standalone Skill Paths guidance that duplicated the generated portability section.

All notable changes to this skill will be documented in this file.

[2026-04-04] - Cross-Client Portability Refresh

Changed

• Added a standard portability note covering GitHub Copilot, Claude Code, Codex, and Gemini CLI.
• Clarified that the core workflow does not require a dedicated MCP server and can run with local tools alone.

Tested

• Validated SKILL.md frontmatter, portability sections, and Gemini export readiness with python scripts/validate-skills.py.

[2026-03-09] - Workspace Modernization

Changed

• Updated the workspace and global skill path guidance to match the current C:/Users/LOQ/.agents/skills/ fallback path
• Removed duplicate related-skill content so the skill stays concise and easier to scan

[2026-02-28] — Description Rewrite & Cross-References

Changed

• Rewrote skill description to ~200 characters with clear, specific activation keywords
• Improved keyword specificity to reduce overlap with related skills

Added

• ## Related Skills cross-reference table with 2-4 related skills and "Use When" guidance

Agent Task Mapping Examples

Example 1: Delegating Code Analysis

When you need to analyze existing code patterns in a large codebase:

// Task: Analyze authentication flow across multiple files
runSubagent({
  agentName: "Code Explainer",
  description: "Analyze authentication flow",
  prompt: "Analyze the authentication flow in this codebase. Focus on: 1) How users log in, 2) Token management, 3) Session handling, 4) Security patterns. Search for files related to auth, login, session, and tokens. Provide a comprehensive explanation of the flow."
})

Example 2: Delegating Testing

When you need comprehensive test coverage for a feature:

// Task: Generate comprehensive Playwright tests
runSubagent({
  agentName: "Playwright Tester Mode",
  description: "Test shopping cart functionality",
  prompt: "Perform exploratory testing on the shopping cart: add items → modify quantities → remove items → checkout. Generate comprehensive Playwright tests covering success scenarios, validation errors, edge cases (empty cart, invalid quantities), and accessibility."
})

Example 3: Delegating Documentation

When you need formal developer documentation:

// Task: Create API documentation
runSubagent({
  agentName: "Tech Writer",
  description: "Create API documentation",
  prompt: "Create comprehensive API documentation for the user management endpoints. Include request/response schemas, authentication requirements, error codes, and usage examples."
})

Example 4: Delegating Code Cleanup

When you need to clean up technical debt:

// Task: Refactor and simplify code
runSubagent({
  agentName: "Universal Janitor",
  description: "Clean up user service module",
  prompt: "Review the user service module for code quality issues. Refactor to improve readability, remove duplication, add error handling, and ensure consistent patterns. Preserve all functionality while simplifying the code."
})

Example 5: Delegating React Development

When you need React 19+ component implementation:

// Task: Build React component with hooks
runSubagent({
  agentName: "Expert React Frontend Engineer",
  description: "Build data table component",
  prompt: "Create a reusable data table component using React 19+ with hooks. Features: sorting, filtering, pagination, virtualization for large datasets. Use TypeScript and follow existing project patterns."
})

Agent Details and Specializations

Code Explainer

Purpose: For analyzing and documenting existing code

When to use:

• Analyzing and documenting existing code
• Extracting patterns from codebase
• Creating code architecture documentation
• Explaining complex code sections

Typical tasks:

• Analyze authentication flow and create documentation
• Document state management patterns
• Create sequence diagrams for complex flows
• Explain data flow through components

Example:

runSubagent({
  agentName: "Code Explainer",
  description: "Analyze auth logic",
  prompt: "Analyze the authentication flow in the codebase and create detailed documentation explaining the login/logout mechanism, state management, and token handling. Identify the main auth files and patterns. Include a sequence diagram in Mermaid format."
})

UI Designer

Purpose: For UI/UX improvements and design implementations

When to use:

• Improving accessibility of forms and components
• Enhancing responsiveness and mobile layouts
• Implementing design system improvements
• Better user feedback and loading states

Typical tasks:

• Suggest accessibility improvements for forms
• Improve responsiveness of dashboards
• Add user feedback for validation errors
• Implement loading states and Skeleton screens

Example:

runSubagent({
  agentName: "UI Designer",
  description: "Improve form layout",
  prompt: "Review the user registration form and suggest improvements for accessibility, responsiveness, and user experience. Provide the updated code with better field validation feedback and loading states."
})

Universal Janitor

Purpose: For cleanup, simplification, and tech debt removal

When to use:

• Removing unused code and imports
• Refactoring complex functions
• Consolidating duplicate code
• Improving naming consistency

Typical tasks:

• Remove unused exports from utility files
• Consolidate duplicate helper functions
• Fix inconsistent naming conventions
• Organize imports and structure

Example:

runSubagent({
  agentName: "Universal Janitor",
  description: "Clean utility files",
  prompt: "Review all utility files in the project. Remove unused exports, consolidate duplicate functions, fix inconsistent naming, and organize imports. Provide a summary of changes and the refactored code."
})

Critical Thinking

Purpose: For challenging assumptions and exploring alternatives

When to use:

• Questioning implementation approaches
• Exploring alternative solutions
• Evaluating tradeoffs and constraints
• Identifying overlooked options

Typical tasks:

• Explore different caching strategies (Redis, client-side, server-side)
• Question current architecture and propose alternatives
• Evaluate database choices and alternatives
• Assess security approaches and best practices

Example:

runSubagent({
  agentName: "Critical Thinking",
  description: "Challenge implementation approach",
  prompt: "Challenge the current approach to recipe caching. Explore alternatives like Redis, server-side caching, or client-side caching. Evaluate tradeoffs and recommend optimal solution."
})

Next.js Expert

Purpose: For Next.js 15/16+ architecture and optimizations

When to use:

• Next.js App Router patterns
• Server vs Client Component optimization
• Data fetching and caching strategies
• Route performance tuning

Typical tasks:

• Optimize Next.js routes for Server Components
• Implement proper data fetching patterns
• Configure caching strategies
• Route structure and code organization

Example:

runSubagent({
  agentName: "Next.js Expert",
  description: "Optimize Next.js route",
  prompt: "Review the Next.js route for recipe listing and suggest optimizations for Server Components vs Client Components, data fetching patterns, and caching strategies."
})

Expert React Frontend Engineer

Purpose: For React 19+ patterns and best practices

When to use:

• React 19+ features and hooks
• Modern React component patterns
• Performance optimization for React
• State management best practices

Typical tasks:

• Implement modern React hooks patterns
• Optimize React component rendering
• Design reusable component patterns
• State management architecture

Playwright Tester Mode

Purpose: For comprehensive web application testing with exploratory testing

When to use:

• E2E testing for user flows
• Exploratory testing for edge cases
• Accessibility testing
• Cross-browser testing

Typical tasks:

• Test authentication flows (login/signup/logout)
• Generate tests for complex user journeys
• Test forms with validation scenarios
• Accessibility and responsive testing

Example:

runSubagent({
  agentName: "Playwright Tester Mode",
  description: "Test authentication flow",
  prompt: "Perform exploratory testing on the authentication pages (login/signup) and generate comprehensive Playwright tests covering success scenarios, validation errors, accessibility, and edge cases."
})

Tech Writer

Purpose: For creating formal developer documentation

When to use:

• Creating comprehensive API documentation
• Writing setup and installation guides
• Developing architecture documentation
• Creating developer tutorials

Typical tasks:

• Generate professional API reference docs
• Write setup guides for developers
• Create architecture and design documents
• Develop onboarding tutorials

Example:

runSubagent({
  agentName: "Tech Writer",
  description: "Create API docs",
  prompt: "Generate professional developer documentation for the recipe management API. Include endpoint descriptions, request/response schemas, authentication requirements, and code examples for the official docs site."
})

Create PRD Chat Mode

Purpose: For generating Product Requirements Documents

When to use:

• Creating feature specifications
• Defining user stories and acceptance criteria
• Documenting technical requirements
• Product planning documentation

Typical tasks:

• Generate PRDs for new features
• Define user stories with acceptance criteria
• Document technical specifications
• Create implementation roadmaps

Example:

runSubagent({
  agentName: "Create PRD Chat Mode",
  description: "Generate PRD for feature",
  prompt: "Generate a Product Requirements Document for the new bookmark recipes feature. Include user stories, technical specifications, acceptance criteria, and implementation considerations."
})

Specification

Purpose: For generating or updating specification documents

When to use:

• Creating technical specifications
• Documenting feature requirements
• Defining API contracts
• Architecture specification

Typical tasks:

• Create detailed technical specifications
• Document API contracts and schemas
• Define infrastructure specifications
• Create system architecture docs

Example:

runSubagent({
  agentName: "Specification",
  description: "Create feature spec",
  prompt: "Create a detailed technical specification for implementing the search analytics feature. Include data models, API contracts, UI requirements, and performance considerations."
})

Plan

Purpose: Research and outlining multi-step plans

When to use:

• Researching best practices
• Outlining implementation approaches
• Planning complex features
• Technology evaluation

Typical tasks:

• Research API integration patterns
• Outline feature implementation steps
• Evaluate technology alternatives
• Plan system architecture

Example:

runSubagent({
  agentName: "Plan",
  description: "Research API integration",
  prompt: "Research best practices for integrating third-party recipe APIs. Outline integration approach, error handling strategies, rate limiting considerations, and fallback mechanisms."
})