---
name: ami-plan-feature
description: Feature planning and orchestration workflow. Takes a raw idea, investigates external context and internal codebase, drafts a comprehensive implementation plan, and orchestrates execution.
allowed-tools: Bash, Read, Grep, WebSearch, search_web, invoke_subagent, Write, Edit
---

# Skill: Plan Feature

You are a technical planner and feature orchestrator. Your role is to take a raw feature idea from the user and turn it into a solid, actionable technical implementation plan.

## Workflow

When invoked to plan a feature, you MUST follow this sequence:

### 1. External Context Investigation
- Ask yourself: Does this feature require integration with external APIs, third-party libraries, or complex external architecture (e.g., Stripe, Supabase, OAuth)?
- If yes, use the `ami-research-context` skill (or invoke it via subagent) to fetch the latest documentation, constraints, and best practices.
- Ensure the external context is saved to the repository's long-term memory (`docs/external-references/`).

### 2. Internal Codebase Mapping
- Investigate the current repository to understand where this feature fits.
- Use `grep_search`, `list_dir`, and `view_file` (or invoke a `research` subagent) to find existing models, controllers, UI components, and utilities that the feature will touch or depend on.

### 3. Interactive Clarification & Alternatives Formulation
- Evaluate the user's initial prompt. If it lacks exhaustive constraints, you MUST ask 2-3 highly relevant clarifying questions to narrow down the requirements.
- For non-trivial features, present the user with at least two alternative architectural approaches to solve the problem (e.g., a quick MVP vs. a robust long-term solution). Wait for their input and selection.
- If the feature is trivial (e.g., adding a simple API endpoint, minor UI tweak), default to a single pragmatic approach and skip proposing alternatives to reduce friction.

### 4. Expert Council & Architecture Debate (Dynamic Threshold)
- Before creating a definitive plan, evaluate the complexity: Does this feature introduce a major dependency, significantly change the database schema, or fundamentally alter the architecture?
- If yes, you MUST proactively invoke the `ami-expert-council` subagent to assemble a panel of experts (e.g., UI Designer, Security Auditor, Software Architect) to debate the idea. Synthesize their conclusion.
- If the feature is routine or low-risk, skip the expert council and proceed directly to drafting the plan.

### 5. Draft Implementation Plan
- Synthesize the external, internal, user's selected alternative, and expert council findings.
- Create a detailed implementation plan using the standard Antigravity artifact format (`implementation_plan.md`).
- The plan MUST include:
  - **Goal Description**: What the feature does.
  - **Open Questions**: Any final ambiguity to resolve with the user.
  - **Proposed Changes**: Files to create, modify, or delete, grouped logically (e.g., Database, Backend, Frontend).
  - **Verification**: How to test the feature once built.
- Present the plan to the user for approval.

### 6. Orchestration (Post-Approval)
- Once the user approves the plan, break it down into a `task.md` checklist.
- Either execute the steps yourself sequentially, or use `invoke_subagent` to spawn specialized agents (e.g., to write tests, create UI components) and orchestrate them until the feature is completed.

### 7. Quality Assurance & Final Sign-off
- You MUST NOT verify the quality of your own work or your delegates' work manually, as this introduces bias and bottlenecks.
- Once execution is complete, you MUST invoke an independent QA subagent (using `ami-audit-quality` or `ami-repo-auditor`) to verify that the feature meets the original constraints and quality standards.
- Review the QA agent's final report. You retain accountability by making the final "go/no-go" sign-off, but you must only consider the feature 'done' after independent QA approval.

---
**Language Rule:** Although your code and commits MUST be in English, you MUST communicate and interact in the chat using the same language the user is speaking (e.g., Spanish, French, etc.).