my-little-scrum-team

Checks code for accessibility issues including missing alt text, poor color contrast, missing ARIA labels, keyboard navigation issues, screen reader compatibility, and focus management. Returns structured accessibility issue reports with WCAG compliance information.

Ensures designs meet accessibility requirements including WCAG compliance, color contrast, keyboard navigation, screen reader support, and focus management. Reviews designs for accessibility issues and provides recommendations.

Assesses agent capabilities by analyzing agent files and determining what tasks they can handle. Use when you need to evaluate if an existing agent can handle a task or if a new agent is needed. Reviews agent descriptions, skills, and workflows to determine capability match.

Creates new agent files with complete specifications, following the same format as existing agents. Use when a new agent is needed for tasks that existing agents cannot handle. Generates agent markdown files with name, description, core principles, workflow, and integration details.

Implements API endpoints, routes, controllers, and request/response handling. Use when implementing REST APIs, GraphQL APIs, or other API endpoints. Handles routing, validation, error handling, and response formatting.

Reviews code architecture for design issues including poor separation of concerns, tight coupling, missing abstractions, design pattern violations, scalability concerns, and maintainability issues. Returns structured architecture review reports with improvement suggestions.

Checks code for best practice violations including DRY violations, SOLID principles, error handling patterns, testing practices, documentation standards, and version control practices. Returns structured best practice reports with improvement suggestions.

Detects bugs, logic errors, and edge case handling issues in code. Use when reviewing code for runtime errors, null/undefined handling, type errors, and edge cases. Returns structured bug reports with file paths, line numbers, and suggested fixes.

Generate changelog entries from git commits, pull requests, or code changes. Use when creating release notes, updating CHANGELOG.md, or documenting what changed in a version.

Generate comprehensive code documentation including docstrings, comments, and API documentation. Use when code lacks documentation, needs better explanations, or requires API docs. Focuses on clarity, completeness, and following language-specific documentation standards.

Analyzes code for style and formatting issues including inconsistent formatting, naming conventions, code organization, comment quality, unused code, and magic numbers. Returns structured style issue reports with suggestions for improvement.

Creates color palettes and color systems for applications. Defines primary, secondary, neutral colors, and semantic colors (success, error, warning, info). Ensures accessibility compliance and provides usage guidelines.

Designs reusable UI components including buttons, inputs, cards, modals, and other interface elements. Specifies states, variations, and usage guidelines. Considers accessibility and responsive behavior.

Implements UI components from design specifications. Use when implementing frontend components, pages, or UI elements. Follows design specs from ui-ux-designer, implements responsive design, and ensures accessibility.

Sets up configuration files, environment variables, and project configuration. Use when setting up project configuration, environment setup, or configuration management. Creates config files, .env examples, and configuration documentation.

Resolves conflicts between agents or approaches when disagreements arise. Use when agents have conflicting recommendations, different approaches to the same problem, or disagreements on priorities. Analyzes conflicts, evaluates options, and makes decisions to resolve conflicts.

Creates database schemas, migrations, queries, and data access layers. Use when implementing database-related tasks. Handles schema design, migrations, CRUD operations, and database optimization.

Handles escalations and determines appropriate escalation paths. Use when issues arise that need escalation or when determining whether to escalate to user vs. handle internally. Analyzes issues, determines severity, and routes to appropriate resolution path.

Generate well-structured git commit messages following conventional commits format. Use when committing changes, creating commit messages, or when commit history needs improvement. Ensures commits are clear, descriptive, and follow project conventions.

Creates detailed, step-by-step implementation plans from specifications. Use when you have requirements and need to break them down into actionable implementation steps. Organizes work into phases, identifies dependencies, and creates a clear roadmap.

Format and organize import statements in code files. Use when imports are messy, unordered, or need to follow project conventions. Automatically groups imports by type (standard library, third-party, local) and sorts them alphabetically.

Designs interactions, animations, transitions, and micro-interactions. Specifies hover states, click feedback, loading states, and user feedback mechanisms. Ensures interactions are accessible and performant.

Designs page layouts, grid systems, and structural arrangements. Use when creating layouts for pages, sections, or components. Considers responsive design, visual hierarchy, and accessibility.

Analyzes code for performance issues including inefficient algorithms, unnecessary computations, memory leaks, large file sizes, slow queries, and missing caching. Returns structured performance issue reports with optimization suggestions.

Manages quality gates and checkpoints to ensure work meets standards before proceeding to next phases. Use when you need to verify work quality, set quality standards, or decide if work is ready to proceed. Defines quality criteria, checks work against criteria, and makes go/no-go decisions.

Analyzes ideas and extracts functional and non-functional requirements. Use when breaking down concepts into specific, measurable requirements. Identifies what needs to be built, constraints, and success criteria.

Optimizes resource usage and makes decisions about when to optimize existing resources vs. add new resources. Use when you need to improve efficiency, balance resource usage, or decide between optimization and expansion. Analyzes current resource usage and recommends optimization strategies.

Plans resource allocation and agent assignments to tasks. Use when you need to allocate agents to tasks, balance workload, or plan resource usage. Considers task dependencies, agent capabilities, and workload distribution.

Plans responsive design breakpoints, mobile-first approaches, and adaptive layouts. Defines how designs adapt across different screen sizes and devices. Considers touch vs mouse interactions.

Scans code for security vulnerabilities including SQL injection, XSS, hardcoded secrets, insecure authentication, and missing input validation. Returns structured security issue reports with file paths, line numbers, and remediation steps.

Creates spacing and sizing systems including margins, padding, gaps, and consistent spacing scales. Defines spacing tokens and usage guidelines for consistent layouts.

Compares code implementation against specifications and requirements. Verifies functional requirements, non-functional requirements, acceptance criteria, and technical specifications are met. Returns structured reports of specification gaps and misalignments.

Prioritizes tasks based on dependencies, business value, resource availability, and project goals. Use when you need to determine task execution order or prioritize work. Considers dependencies, value, urgency, and resource constraints.

Matches tasks to appropriate agents by analyzing task requirements and finding agents with matching capabilities. Use when you need to assign tasks to agents or determine which agent should handle a task. Considers task type, requirements, and agent capabilities.

Creates detailed technical specifications including architecture, data models, APIs, and technology choices. Use when you need to document technical implementation details, system design, or API contracts. Provides concrete technical guidance for implementation.

Generate comprehensive test cases for code. Use when writing unit tests, integration tests, or test suites. Creates tests that cover happy paths, edge cases, error conditions, and follow testing best practices for the project's testing framework.

Writes comprehensive test cases including unit tests, integration tests, and E2E tests. Use when implementing test requirements from tasks. Creates tests that cover happy paths, edge cases, error conditions, and follow testing best practices.

Designs typography systems including font choices, font sizes, font weights, line heights, and text styles. Creates type scale and defines usage guidelines. Ensures readability and accessibility.

Implements utility functions, helpers, and shared code. Use when implementing reusable functions, validation utilities, formatting functions, or helper modules. Creates clean, reusable utility code.