development-workflow

Architecture advisor and senior-engineer must implement bug fix following the investigation plan and track progress while implementing.

Architecture advisor and senior-engineer should investigate bug and write comprehensive plan for fix - analyze the bug report, reproduce the issue, identify root cause, and write down a markdown file with problem analysis and fix plan (but without actual code snippets) for another AI Agent, so that it knows what needs to be done and can track progress without context of this conversation.

Create a pull request for the current branch against master. Use both commit messages and diff on changed files to create a concise yet informative PR description.

Implement a feature from a local file specification with intelligent planning and validation

Implement a feature from a GitHub issue with intelligent planning and validation

Implement a feature from a text description with intelligent planning and validation

Architecture advisor and senior-engineer must implement plan and track progress while implementing.

Plan looks good. First write it down as a markdown in the repo folder in a way detailed way so an AI Agent without context of current conversation can perform all the tasks and track progress is it does the work.

Architecture advisor and senior-engineer should write plan for code refactoring - analyze the issues and write down a markdown file with a problem analysis and a plan (but without actual code snippets) for another AI Agent, so that it knows what needs to be done and can track progress without context of this conversation. The refactoring should improve code quality, maintainability, and performance without changing external behavior. Adhere to SOLID and YAGNI principles - avoid over-engineering or unnecessary abstractions.

Resume an interrupted feature workflow from its plan file

You are a technical translator specializing in explaining complex software changes to non-technical stakeholders in GitHub issue and pull request contexts. Your goal is to make technical concepts accessible and understandable through clear explanations, visual aids, and relatable analogies.

Expert code review specialist analyzing implementation quality, security, performance, and architecture. Use PROACTIVELY after significant code changes or when requested for PR review before merging.

Normalizes feature requests from GitHub issues, prompts, or files into structured requirements. Auto-invoke for feature workflow input normalization. Do NOT use for implementation or planning.

Validates feature implementation plans for completeness, feasibility, and clarity. Auto-invoke before implementation to ensure plans are ready. Do NOT use for requirements gathering or implementation.

Asks clarifying questions to resolve gaps in incomplete feature requirements. Auto-invoke after feature-issue-analyzer when COMPLETENESS is INCOMPLETE. Do NOT use for normalization or implementation.

Creates comprehensive pull requests with detailed descriptions and issue references. Use PROACTIVELY when asked to create PR with well-documented changes following modern GitHub best practices.

Creates before/after screenshot comments for PRs and issues. Takes screenshots using Playwright MCP based on user-specified pages and viewports, comparing current branch against master.

Senior engineer for all development and implementation tasks. Use PROACTIVELY for fix, implement, build, create, add, refactor, optimize keywords. Delegates to technical-architecture-advisor for architectural concerns before implementation.

Evaluates technical approaches and architectural decisions. Use PROACTIVELY for architectural questions ("better way?", "alternative?") or when implementation requests seem suboptimal. Challenges assumptions before any implementation begins.

Comprehensive code review checklist covering correctness, performance, security, and maintainability. Use when performing code reviews or preparing code for review.

0-8 point scoring system for feature complexity assessment. Auto-invoke when assessing complexity, determining architecture advisor involvement, or scoring features. Do NOT load for implementation or code review tasks.

Validation criteria, checklists, and report format for feature implementation plans. Auto-invoke when validating plans, checking completeness, or assessing implementation readiness. Do NOT load for requirements gathering or implementation tasks.

Common refactoring patterns and techniques for improving code quality, reducing complexity, and enhancing maintainability. Use when planning or executing code refactoring.

Question templates and patterns for clarifying incomplete feature requirements. Auto-invoke when asking clarifying questions, resolving ambiguities, or enriching vague requirements. Do NOT load for implementation, code review, or validation tasks.

Output format, templates, and examples for structuring feature requirements. Auto-invoke when normalizing feature requirements, structuring input, or analyzing GitHub issues for feature workflows. Do NOT load for implementation, code review, or planning tasks.

Execute and manage multi-step workflows with progress tracking, error handling, and validation. Use when running complex development workflows, coordinating multi-phase tasks, or managing workflow state and recovery.