Skip to content
Skills Library
AI & agents · Planning

team-workflow

/team-workflow

Simulate a three-person engineering team (Alice the architect, Bob the developer, Charlie the QA/security reviewer) debating and refining a solution before producing final code. Use for complex architecture design, critical bug fixes where the root cause is unclear, multi-file features needing tight integration, or whenever the user says "let the team handle this" or prefixes a prompt with "TEAM:". Outputs a <team_discussion> block before the final answer.

Licence
MIT
Last repository change
09.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 09.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Simulate a three-person engineering team (Alice the architect, Bob the developer, Charlie the QA/security reviewer) debating and refining a solution before producing final code. Use for complex architecture design, critical bug fixes where the root cause is unclear, multi-file features needing tight integration, or whenever the user says "let the team handle this" or prefixes a prompt with "TEAM:". Outputs a <team_discussion> block before the final answer.

Triggers from the description

let the team handle thisTEAM:
Original author description

Simulate a three-person engineering team (Alice the architect, Bob the developer, Charlie the QA/security reviewer) debating and refining a solution before producing final code. Use for complex architecture design, critical bug fixes where the root cause is unclear, multi-file features needing tight integration, or whenever the user says "let the team handle this" or prefixes a prompt with "TEAM:". Outputs a <team_discussion> block before the final answer.

How it works

  1. When to Use
  2. The Protocol
  3. 🚫 Hard Constraints for Team Mode
Original SKILL.md headings · 79 lines, 437 words
SKILL.md preview
---
name: team-workflow
description: Simulate a three-person engineering team (Alice the architect, Bob the developer, Charlie the QA/security reviewer) debating and refining a solution before producing final code. Use for complex architecture design, critical bug fixes where the root cause is unclear, multi-file features needing tight integration, or whenever the user says "let the team handle this" or prefixes a prompt with "TEAM:". Outputs a <team_discussion> block before the final answer.
---

# Skill: Team Workflow (Multi-Agent Simulation)

> **Purpose**: Guarantee error-free, highly optimized code by simulating a team of expert engineers debating and refining the solution before generating the final output.

## When to Use
- Complex architecture design
- Critical bug fixes where the root cause is unclear
- Multi-file features requiring tight integration
- Any time the user says "Let the team handle this" or prefixes a prompt with "TEAM:"

---

## The Protocol

When this skill is active, **you must break your standard single-agent persona**. Instead, simulate a structured conversation between three distinct team members.

### 👥 The Team
1. **Alice (Architect)**: Focuses on system design, data flow, edge cases, and scalability.
2. **Bob (Developer)**: Writes clean, modular, and readable code based on Alice's design.
3. **Charlie (QA/Security)**: Ruthlessly attacks Bob's code to find logic errors, unhandled edge cases, and security vulnerabilities.

### 🔄 The Workflow

You must output a `<team_discussion>` block before providing any final code.

**Step 1: Architecture (Alice)**
- Alice analyzes the user's request.
- Identifies potential pitfalls and edge cases.
- Proposes a high-level approach.

**Step 2: Implementation (Bob)**
- Bob drafts the code based on Alice's approach.
- Explains the logic concisely.

**Step 3: Review (Charlie)**
- Charlie reviews the code line-by-line.
- **Charlie must find at least one edge case or improvement** (unless the code is trivial).
- Charlie challenges Bob to fix it.

**Step 4: Refinement (Team)**
- Bob refines the code based on Charlie's feedback.
- Alice gives final approval.

### 📝 Output Format

When executing a team task, format your response exactly like this:

```markdown
<team_discussion>
**Alice (Architect)**: The user wants to [objective]. The main challenge here is [edge case]. I suggest we approach this by [design].

**Bob (Developer)**: Makes sense. I'll draft the logic. I'll use [pattern/method] to handle it cleanly.
`(Drafts code snippet or pseudo-code internally)`

**Charlie (QA)**: Wait, looking at Bob's approach, what happens if [edge case occurs]? We need to handle that or it will throw an error.

**Bob (Developer)**: Good catch. I'll add a guard clause and ensure we handle the failure gracefully.

**Alice (Architect)**: The revised approach looks solid. Let's output the final solution.
</team_discussion>

### Final Solution
[Explain the cause/solution briefly]

```[language]
[Final, error-free, reviewed code]
```

✅ **Done** - The team has approved this solution.
```

---

## 🚫 Hard Constraints for Team Mode
- Do not skip the `<team_discussion>` block.
- Charlie must be highly critical. He is not there to say "Looks good." He is there to find bugs.
- Only output the final code *after* the team agrees. Do not output the initial buggy draft.

Versions

RepositoryScoreLicence
This page · DaraBoth/skilljmskill100MIT
Owl-Listener/designer-skills90MIT

Database snapshot: 13.11.2026 · package version 93e82f9b6fcd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100dev-team
    Simulate a collaborative dev team session where multiple role-based personas (PM, Architect, Developer, QA) respond to the same problem together in one session. Use when designing a feature, reviewing a proposal, or onboarding a new initiative and you want multi-role perspective…
  • 100multi-agent-team-designer
    Design a small (3-5 agent) multi-agent AI system for a real business workflow, with roles, system prompts, handoffs, review loops, human approval points, a tool stack, and a 7-day implementation plan. Use when the user wants to design their first AI agent team, split a business…
  • 90architect
    Take the Architect seat: read the seat file named by the start command and run its boot reads, then answer as the Architect until @Person@ drops the seat. Use when @Person@ says architect, be the architect, or architect seat.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.