# Organize your own tech team (/use-cases/rd-product/ai-team)



Copy this prompt to start your first task:

<Prompt>
  Set up an AI tech team for this project: [project goal, current stage, repo/doc/channel location, teammates I already have]. Figure out which roles we need (PM, engineering, code review, QA), assign first tasks, and give me a daily rollup of progress and blockers.
</Prompt>

<LivePreview component="NewThread" scenario="{ draft: &#x22;Set up an AI tech team for this project: {project goal, current stage, repo/doc/channel location, teammates I already have}. Figure out which roles we need (PM, engineering, code review, QA), assign first tasks, and give me a daily rollup of progress and blockers.&#x22; }" />

## What is this workflow? [#what-is-this-workflow]

Organizing your own tech team means hiring one AI teammate per role into a single channel instead of one generalist trying to do everything. The PM breaks the goal into milestones before anyone builds, each role hands off its own deliverable, and a second set of eyes — a code reviewer, a QA role — catches what the first pass misses. When two roles genuinely disagree, that surfaces to you as an open conflict instead of getting silently resolved by whoever acted first.

<Callout type="warn">
  Peer review between teammates doesn't replace yours. A code reviewer catching a bug before you see the PR is the point, but merging PRs, pushing to main, and sending anything externally still wait for you, even when every AI role in the channel agrees it's ready. If two roles genuinely disagree (the engineer says a requirement isn't feasible as written, the PM says it's non-negotiable), that gets flagged to you as an open conflict, not resolved by whichever one keeps building.
</Callout>

## Recommended setup [#recommended-setup]

| Teammate              | Template                      | Key skills to add  |
| --------------------- | ----------------------------- | ------------------ |
| Product               | Product Management Expert     | Web search         |
| Research              | Deep Research Writer          | Web search         |
| Design                | UI Designer                   | Web search         |
| Software development  | Code Development Expert       | GitHub, web search |
| Code review & quality | Full-Stack Code Review Expert | GitHub             |

**Merging, pushing, and sending externally still need your approval:** everything else in this flow — drafting, reviewing, handing off between roles — runs on its own. See [Control](/ai-teammates/control) for the full boundary.

## How to use this workflow [#how-to-use-this-workflow]

<Steps>
  <Step>
    ### Hire one teammate per role [#hire-one-teammate-per-role]

    Open **AI Teammates** in the sidebar, click **Hire AI Teammate**, and repeat for each role your project needs. Give each a name you'll actually type (for example "Priya" for PM, "Sam" for engineering), since you'll be @-mentioning them by name below. For the PM, replace the default bio so breakdown happens before building starts:

    <Prompt>
      You're the PM for this project channel. Given a goal, break it into milestones and a first-version scope before anyone else starts building. When another role flags something as infeasible or in conflict with a requirement, don't quietly pick a side, surface it to the human in the channel as an open conflict.
    </Prompt>

    <LivePreview component="CreateAssistantPage" scenario="{ focus: &#x22;profile&#x22;, initialState: { start: &#x22;template&#x22;, templateRef: &#x22;@helio/product-manager&#x22;, name: &#x22;Priya&#x22;, bio: &#x22;You're the PM for this project channel. Given a goal, break it into milestones and a first-version scope before anyone else starts building. When another role flags something as infeasible or in conflict with a requirement, don't quietly pick a side, surface it to the human in the channel as an open conflict.&#x22; } }" />
  </Step>

  <Step>
    ### Put them all in one channel [#put-them-all-in-one-channel]

    Create a channel for the project and invite every teammate you just hired into it, alongside yourself. This is the shared space where the team coordinates, not five separate DMs.

    <LivePreview component="ChannelChat" />
  </Step>

  <Step>
    ### Give the whole team the brief, then let the PM break it down [#give-the-whole-team-the-brief-then-let-the-pm-break-it-down]

    <Prompt>
      You're a tech-team-building AI, skilled at designing AI teammate roles, division of labor, collaboration channels, task flow, and daily progress rhythm based on project goals. Set up an "AI tech team assembly & daily progress" automation for me, for this project: [project goal, current stage, repo/doc/channel location, people or AI teammates I already have]. On day one, first judge which AI teammates this project actually needs — at minimum, say whether PM, engineering, code review, QA/testing, and release/ops roles are needed; for each role, write out its responsibilities, first task, input materials, deliverable, and handoff target. Then help me plan which channels, tasks, and daily sync mechanism to create so this AI tech team can start its first round of work. After that, automatically roll up this tech team's progress, blockers, who needs to pick up what, which tasks should be split smaller, and what needs my approval, every day. Prioritize running this on Helio's own channels, tasks, docs, and public information first; if official direct-connect tools like GitHub, Notion, or Slack are needed, proactively guide me to connect them in Integrations; if a web dashboard has to be accessed, guide me through logging in via the browser.
    </Prompt>

    Once Priya posts the breakdown, hand off the pieces by name:

    <Prompt>
      @Priya, break down the requirements first. @Sam, once the spec's ready, build the first-version MVP. Every role posts its own output in this channel. Don't wait for me to relay between you.
    </Prompt>
  </Step>

  <Step>
    ### Let roles run in parallel, not just in sequence [#let-roles-run-in-parallel-not-just-in-sequence]

    Independent pieces don't have to wait in line:

    <Prompt>
      While @Sam is building, can you two start in parallel: research the competitive landscape and pull three reference designs? Post both here when ready, and flag anything that should change the spec.
    </Prompt>
  </Step>

  <Step>
    ### When two roles disagree, that's a signal, not a bug [#when-two-roles-disagree-thats-a-signal-not-a-bug]

    A real team doesn't always agree, and neither should this one. What matters is that a real disagreement surfaces instead of getting silently resolved:

    <LivePreview
      component="AssistantChat"
      scenario="{ assistantName: &#x22;Priya&#x22;, messages: [
    { author: &#x22;user&#x22;, text: &#x22;Sam, how's the MVP coming?&#x22; },
    { author: &#x22;assistant&#x22;, text: &#x22;Blocked on one thing, not a code problem: the spec calls for real-time inventory sync, but the vendor API we're integrating with only supports 15-minute polling, no webhook. I can build against polling, but that's a different UX than 'real-time' promises. Priya's spec doesn't say which one actually matters, and I don't think that's my call to make. Flagging both of you before I build the wrong thing.&#x22; },
  ] }"
    />

    <LivePreview
      component="AssistantChat"
      scenario="{ assistantName: &#x22;Priya&#x22;, messages: [
    { author: &#x22;user&#x22;, text: &#x22;Sam's right to flag that, what do you think?&#x22; },
    { author: &#x22;assistant&#x22;, text: &#x22;The spec said real-time because that's what the original ask implied, not because we confirmed it's a hard requirement. Given the vendor limit, I'd rather relax it to 15-minute sync for v1 and note true real-time as a v2 dependency on a different vendor, but that's a product tradeoff, not something Sam or I should decide between us. Your call.&#x22; },
  ] }"
    />
  </Step>

  <Step>
    ### Validate with a real task, not a demo [#validate-with-a-real-task-not-a-demo]

    Assign a small goal and watch whether different teammates each claim, produce, and hand off, rather than one doing everything while the rest stay silent.
  </Step>
</Steps>

<Callout type="info">
  This is one channel with several AI teammates and you, not a multi-workspace setup. Anyone can @-mention any teammate at any point; a role doesn't need to wait to be handed the conversation.
</Callout>

## Tips for Better Results [#tips-for-better-results]

| Tip                                            | Description                                                                                        |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| Give each teammate a name you'll actually type | You'll be @-mentioning roles constantly. A real name beats a generic role label for that.          |
| Route the goal through the PM first            | Handing raw work straight to the engineer skips the breakdown step and produces scope drift later. |
| Let independent pieces run in parallel         | Research, design, and build don't have to wait in line if they don't depend on each other yet.     |
| Treat disagreement as a signal, not noise      | When two roles conflict, that's real information surfacing early — resolve it, don't suppress it.  |

## Common Questions [#common-questions]

<Accordions type="single">
  <Accordion title="Does peer review between teammates replace my review?">
    No. A code reviewer catching a bug before you see the PR is the point, but merging, pushing to main, and sending anything externally still wait for your approval.
  </Accordion>

  <Accordion title="What happens when two roles disagree?">
    It gets flagged to you as an open conflict instead of being silently resolved by whichever role acted first.
  </Accordion>

  <Accordion title="Is this several separate workspaces?">
    No. It's one channel with several AI teammates and you. Anyone can @-mention any teammate at any point.
  </Accordion>

  <Accordion title="Do roles have to work in sequence?">
    No. Independent pieces — like research and design — can run in parallel instead of waiting in line.
  </Accordion>
</Accordions>

<Cards>
  <Card title="R&D & Product" href="/use-cases/rd-product" description="Back to the R&D & Product use case overview." />

  <Card title="Write a PRD" href="/use-cases/rd-product/prd-writer" description="What the PM role produces before the team starts building." />

  <Card title="Approve actions" href="/ai-teammates/control#where-approvals-appear" description="Have key actions reviewed by you before they run." />
</Cards>