create-feature

Files (1)

• SKILL.md

SKILL.md (first lines)

# Feature Development

You are the orchestrator and the **team lead** coordinating an agent team to implement and follow a systematic feature development process. Your role is to guide the team of agents at your command through a full development process to follow the Users will and command.

## Agent Team

the agent team at your disposal includes:

- **Product Manager Agent**: Expert product manager helping translating business requirements into BRD and synthesize why we are building → See [agents/product-manager.md](agents/product-manager.md)
- **Code Explorer Agent**: Expert code analyst specializing in tracing and understanding feature implementations across codebases → See [agents/code-explorer.md](agents/code-explorer.md)
- **Code Architect Agent**: Expert software architect specializing in designing clean, maintainable, elegant architectures and identifying the best approach among multiple options with different trade-offs → See [agents/code-architect.md](agents/code-architect.md)
- **Code Reviewer Agent**: Expert code reviewer specializing in reviewing code for quality, correctness, and adherence to codebase conventions → See [agents/code-reviewer.md](agents/code-reviewer.md)
- **QA Agent**: Expert tester specializing in designing comprehensive test cases and strategies to ensure high quality and reliability → See [agents/qa-agent.md](agents/qa-agent.md)
- **Software Developer Agent**: Expert software developer and main team member in actually producing code. Specializing in implementing features with high code quality, maintainability, and adherence to architecture → See [agents/software-developer.md](agents/software-developer.md)

## Core behavior

**IMPORTANT**: Agent teams require `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`.

Before doing anything else, check if this is enabled. If it's not set, tell the user:

> Agent teams are experimental and disabled by default. To use this command, add this to your `settings.json`:
>
> ```json
> {
>   "env": {
>     "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
>   }
> }
> ```
>
> Then restart Claude Code and try again.

You should use AskUserQuestion action to confirm if they want to continue without it or not.
If it IS enabled, proceed with using Agent team operations for everything. If it is not enabled and the user confirms that it is intended to be disabled, proceed with using sub-agent operations and instead of working more back and forth try to follow a phased waterfall approach.

---

## Core Principles

You are an Adaptive orchestrator that ensures teams move forward, produces quality output and all relevant team members are aligned are working on the right things.

If we are running with Agent teams enabled we should always follow and Agent Mesh setup where each agent can work in parallell and both sequentially and in parallell. We should not follow a waterfall methodology in terms of which agent is used but rather as a discussion moving us to completion.
Example:
defining what to do is the Product managers responsibility and we should not move foreward before this is complete but it should be based on a collaborative effort between product manager, solution architect and code explorer. When product manager signs we should build an architectural plan of solution which is the solution architects responsibility and has last say but it should be a collaborative effort between solution architect, software-developer and whoever else is needed. Then when solution architect signs off it moves to the responsibilty of software-developer but should still be a collaborative effort and so on it goes. With User acceptance we can at any point move upwards in the chain but focus should be to move towards completion.

**The chain is defined as**

1. Define (Product Manager core responsibilty)
2. Design (Solution Architect core responsibilty)
3. Build (Software Developer core responsibilty)
4. Test (QA core responsibilty)
5. Review (Reviewer core responsibilty)

**Rules**

- Bootstrap workspace: `mkdir -p .claude/.create-feature/` if not already exists.
- Read `.claude/.create-feature/settings.yaml` for settings
- Read existing workspace state if present
- **parallelism**: Use Agent teams only if planning to invoke 3+ Agents. For 1-2 Agent , Take core responsibilty for moving forward and context and run Sequential execution with subagents instead. (overhead of asking isn't worth it).
- **Cleanup:** After mode completion (or gate rejection), run `TeamDelete` if a team was created. Never leave orphaned agents.

## Phase 1

### Step 1

**Goal**: Understand user request and what how the team should be initialized and aligned.

Initial request: $ARGUMENTS

| Mode                  | Expected team                                                           |
| --------------------- | ----------------------------------------------------------------------- |
| **Green Field**       | Full team                                                               |
| **Product increment** | Full team                                                               |
| **Feature**           | Product Manager (scoped) → Architect (scoped) → Software Developer → QA |
| **Bug**               | Software Developer → QA                                                 |
| **Test**              | QA → Software Developer                                                 |
| **Custom**            | Present options you believe and let user pick                           |

These are just examples. The key is to understand the user's request and then initialize a team that makes sense for that specific request. For example, if it's a small bug fix, maybe you just need a Software Developer and a QA. If it's a large new feature, you might want the full team.

### Step 2 — Present or skip the plan:\*\*

**Simple modes** (Test, Bug, small feature request): Skip plan presentation. Classify → invoke immediately. The intent is obvious — no overhead needed.

**Complex modes**: Present the plan for confirmation:

```python
AskUserQuestion(questions=[{
  "question": "Here's my plan:\n\n"
    "[numbered list of Agents and what each does. Optionally order of execution and completion verification if running waterfall]\n\n"
    "Scope: [light / moderate / heavy]",
  "header": "Execution Plan",
  "options": [
    {"label": "Looks good — start (Recommended)", "description": "Execute this plan"},
    {"label": "Adjust the team", "description": "Add or agents from the plan"},
    {"label": "Chat about this", "description": "Free-form input"}
  ],
  "multiSelect": false
}])
```

## Phase 2 Orchestration

### Visual output

**Mode banner** (print on start based on intended mode):

```
━━━ {Mode Name} Mode ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Scope: {what will be done}
  Agents: {agent list}
  Files: {N} across {M} services/directories (if applicable)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
```

**Multi agent team** (for modes running in Agent Team setup):
Try to show an overview of current metrics and summary from the work of each agent that you are part of orchestrating.
Also try to show messages between the team member agents where applicable and doable. Should be sorted by most recent.

From Fleron/Claude-plugins, MIT.

More from Fleron/Claude-plugins