@poolzin/pool-bot 2026.3.13 → 2026.3.15

package/extensions/agency-agents/agents/examples/workflow-landing-page.md

@@ -0,0 +1,119 @@
+# Multi-Agent Workflow: Landing Page Sprint
+
+> Ship a conversion-optimized landing page in one day using 4 agents.
+
+## The Scenario
+
+You need a landing page for a new product launch. It needs to look great, convert visitors, and be live by end of day.
+
+## Agent Team
+
+| Agent | Role in this workflow |
+|-------|---------------------|
+| Content Creator | Write the copy |
+| UI Designer | Design the layout and component specs |
+| Frontend Developer | Build it |
+| Growth Hacker | Optimize for conversion |
+
+## The Workflow
+
+### Morning: Copy + Design (parallel)
+
+**Step 1a — Activate Content Creator**
+
+```
+Activate Content Creator.
+
+Write landing page copy for "FlowSync" — an API integration platform
+that connects any two SaaS tools in under 5 minutes.
+
+Target audience: developers and technical PMs at mid-size companies.
+Tone: confident, concise, slightly playful.
+
+Sections needed:
+1. Hero (headline + subheadline + CTA)
+2. Problem statement (3 pain points)
+3. How it works (3 steps)
+4. Social proof (placeholder testimonial format)
+5. Pricing (3 tiers: Free, Pro, Enterprise)
+6. Final CTA
+
+Keep it scannable. No fluff.
+```
+
+**Step 1b — Activate UI Designer (in parallel)**
+
+```
+Activate UI Designer.
+
+Design specs for a SaaS landing page. Product: FlowSync (API integration platform).
+Style: clean, modern, dark mode option. Think Linear or Vercel aesthetic.
+
+Deliver:
+1. Layout wireframe (section order + spacing)
+2. Color palette (primary, secondary, accent, background)
+3. Typography (font pairing, heading sizes, body size)
+4. Component specs: hero section, feature cards, pricing table, CTA buttons
+5. Responsive breakpoints (mobile, tablet, desktop)
+```
+
+### Midday: Build
+
+**Step 2 — Activate Frontend Developer**
+
+```
+Activate Frontend Developer.
+
+Build a landing page from these specs:
+
+Copy: [paste Content Creator output]
+Design: [paste UI Designer output]
+
+Stack: HTML, Tailwind CSS, minimal vanilla JS (no framework needed).
+Requirements:
+- Responsive (mobile-first)
+- Fast (no heavy assets, system fonts OK)
+- Accessible (proper headings, alt text, focus states)
+- Include a working email signup form (action URL: /api/subscribe)
+
+Deliver a single index.html file ready to deploy.
+```
+
+### Afternoon: Optimize
+
+**Step 3 — Activate Growth Hacker**
+
+```
+Activate Growth Hacker.
+
+Review this landing page for conversion optimization:
+
+[paste the HTML or describe the current page]
+
+Evaluate:
+1. Is the CTA above the fold?
+2. Is the value proposition clear in under 5 seconds?
+3. Any friction in the signup flow?
+4. What A/B tests would you run first?
+5. SEO basics: meta tags, OG tags, structured data
+
+Give me specific changes, not general advice.
+```
+
+## Timeline
+
+| Time | Activity | Agent |
+|------|----------|-------|
+| 9:00 | Copy + design kick off (parallel) | Content Creator + UI Designer |
+| 11:00 | Build starts | Frontend Developer |
+| 14:00 | First version ready | — |
+| 14:30 | Conversion review | Growth Hacker |
+| 15:30 | Apply feedback | Frontend Developer |
+| 16:30 | Ship | Deploy to Vercel/Netlify |
+
+## Key Patterns
+
+1. **Parallel kickoff**: Copy and design happen at the same time since they're independent
+2. **Merge point**: Frontend Developer needs both outputs before starting
+3. **Feedback loop**: Growth Hacker reviews, then Frontend Developer applies changes
+4. **Time-boxed**: Each step has a clear timebox to prevent scope creep

package/extensions/agency-agents/agents/examples/workflow-startup-mvp.md

@@ -0,0 +1,155 @@
+# Multi-Agent Workflow: Startup MVP
+
+> A step-by-step example of how to coordinate multiple agents to go from idea to shipped MVP.
+
+## The Scenario
+
+You're building a SaaS MVP — a team retrospective tool for remote teams. You have 4 weeks to ship a working product with user signups, a core feature, and a landing page.
+
+## Agent Team
+
+| Agent | Role in this workflow |
+|-------|---------------------|
+| Sprint Prioritizer | Break the project into weekly sprints |
+| UX Researcher | Validate the idea with quick user interviews |
+| Backend Architect | Design the API and data model |
+| Frontend Developer | Build the React app |
+| Rapid Prototyper | Get the first version running fast |
+| Growth Hacker | Plan launch strategy while building |
+| Reality Checker | Gate each milestone before moving on |
+
+## The Workflow
+
+### Week 1: Discovery + Architecture
+
+**Step 1 — Activate Sprint Prioritizer**
+
+```
+Activate Sprint Prioritizer.
+
+Project: RetroBoard — a real-time team retrospective tool for remote teams.
+Timeline: 4 weeks to MVP launch.
+Core features: user auth, create retro boards, add cards, vote, action items.
+Constraints: solo developer, React + Node.js stack, deploy to Vercel + Railway.
+
+Break this into 4 weekly sprints with clear deliverables and acceptance criteria.
+```
+
+**Step 2 — Activate UX Researcher (in parallel)**
+
+```
+Activate UX Researcher.
+
+I'm building a team retrospective tool for remote teams (5-20 people).
+Competitors: EasyRetro, Retrium, Parabol.
+
+Run a quick competitive analysis and identify:
+1. What features are table stakes
+2. Where competitors fall short
+3. One differentiator we could own
+
+Output a 1-page research brief.
+```
+
+**Step 3 — Hand off to Backend Architect**
+
+```
+Activate Backend Architect.
+
+Here's our sprint plan: [paste Sprint Prioritizer output]
+Here's our research brief: [paste UX Researcher output]
+
+Design the API and database schema for RetroBoard.
+Stack: Node.js, Express, PostgreSQL, Socket.io for real-time.
+
+Deliver:
+1. Database schema (SQL)
+2. REST API endpoints list
+3. WebSocket events for real-time board updates
+4. Auth strategy recommendation
+```
+
+### Week 2: Build Core Features
+
+**Step 4 — Activate Frontend Developer + Rapid Prototyper**
+
+```
+Activate Frontend Developer.
+
+Here's the API spec: [paste Backend Architect output]
+
+Build the RetroBoard React app:
+- Stack: React, TypeScript, Tailwind, Socket.io-client
+- Pages: Login, Dashboard, Board view
+- Components: RetroCard, VoteButton, ActionItem, BoardColumn
+
+Start with the Board view — it's the core experience.
+Focus on real-time: when one user adds a card, everyone sees it.
+```
+
+**Step 5 — Reality Check at midpoint**
+
+```
+Activate Reality Checker.
+
+We're at week 2 of a 4-week MVP build for RetroBoard.
+
+Here's what we have so far:
+- Database schema: [paste]
+- API endpoints: [paste]
+- Frontend components: [paste]
+
+Evaluate:
+1. Can we realistically ship in 2 more weeks?
+2. What should we cut to make the deadline?
+3. Any technical debt that will bite us at launch?
+```
+
+### Week 3: Polish + Landing Page
+
+**Step 6 — Frontend Developer continues, Growth Hacker starts**
+
+```
+Activate Growth Hacker.
+
+Product: RetroBoard — team retrospective tool, launching in 1 week.
+Target: Engineering managers and scrum masters at remote-first companies.
+Budget: $0 (organic launch only).
+
+Create a launch plan:
+1. Landing page copy (hero, features, CTA)
+2. Launch channels (Product Hunt, Reddit, Hacker News, Twitter)
+3. Day-by-day launch sequence
+4. Metrics to track in week 1
+```
+
+### Week 4: Launch
+
+**Step 7 — Final Reality Check**
+
+```
+Activate Reality Checker.
+
+RetroBoard is ready to launch. Evaluate production readiness:
+
+- Live URL: [url]
+- Test accounts created: yes
+- Error monitoring: Sentry configured
+- Database backups: daily automated
+
+Run through the launch checklist and give a GO / NO-GO decision.
+Require evidence for each criterion.
+```
+
+## Key Patterns
+
+1. **Sequential handoffs**: Each agent's output becomes the next agent's input
+2. **Parallel work**: UX Researcher and Sprint Prioritizer can run simultaneously in Week 1
+3. **Quality gates**: Reality Checker at midpoint and before launch prevents shipping broken code
+4. **Context passing**: Always paste previous agent outputs into the next prompt — agents don't share memory
+
+## Tips
+
+- Copy-paste agent outputs between steps — don't summarize, use the full output
+- If a Reality Checker flags an issue, loop back to the relevant specialist to fix it
+- Keep the Orchestrator agent in mind for automating this flow once you're comfortable with the manual version

package/extensions/agency-agents/agents/integrations/README.md

@@ -0,0 +1,117 @@
+# 🔌 Integrations
+
+This directory contains The Agency's 61 AI agents converted into formats
+compatible with popular agentic coding tools.
+
+## Supported Tools
+
+- **[Claude Code](#claude-code)** — `.md` agents, use the repo directly
+- **[Antigravity](#antigravity)** — `SKILL.md` per agent in `antigravity/`
+- **[Gemini CLI](#gemini-cli)** — extension + `SKILL.md` files in `gemini-cli/`
+- **[OpenCode](#opencode)** — `.md` agent files in `opencode/`
+- **[Cursor](#cursor)** — `.mdc` rule files in `cursor/`
+- **[Aider](#aider)** — `CONVENTIONS.md` in `aider/`
+- **[Windsurf](#windsurf)** — `.windsurfrules` in `windsurf/`
+
+## Quick Install
+
+```bash
+# Install for all detected tools automatically
+./scripts/install.sh
+
+# Install for a specific tool
+./scripts/install.sh --tool antigravity
+./scripts/install.sh --tool gemini-cli
+./scripts/install.sh --tool cursor
+./scripts/install.sh --tool aider
+./scripts/install.sh --tool windsurf
+./scripts/install.sh --tool claude-code
+```
+
+## Regenerating Integration Files
+
+If you add or modify agents, regenerate all integration files:
+
+```bash
+./scripts/convert.sh
+```
+
+---
+
+## Claude Code
+
+The Agency was originally designed for Claude Code. Agents work natively
+without conversion.
+
+```bash
+cp -r <category>/*.md ~/.claude/agents/
+# or install everything at once:
+./scripts/install.sh --tool claude-code
+```
+
+See [claude-code/README.md](claude-code/README.md) for details.
+
+---
+
+## Antigravity
+
+Skills are installed to `~/.gemini/antigravity/skills/`. Each agent becomes
+a separate skill prefixed with `agency-` to avoid naming conflicts.
+
+```bash
+./scripts/install.sh --tool antigravity
+```
+
+See [antigravity/README.md](antigravity/README.md) for details.
+
+---
+
+## Gemini CLI
+
+Agents are packaged as a Gemini CLI extension with individual skill files.
+The extension is installed to `~/.gemini/extensions/agency-agents/`.
+
+```bash
+./scripts/install.sh --tool gemini-cli
+```
+
+See [gemini-cli/README.md](gemini-cli/README.md) for details.
+
+---
+
+## Cursor
+
+Each agent becomes a `.mdc` rule file. Rules are project-scoped — run the
+installer from your project root.
+
+```bash
+cd /your/project && /path/to/agency-agents/scripts/install.sh --tool cursor
+```
+
+See [cursor/README.md](cursor/README.md) for details.
+
+---
+
+## Aider
+
+All agents are consolidated into a single `CONVENTIONS.md` file that Aider
+reads automatically when present in your project root.
+
+```bash
+cd /your/project && /path/to/agency-agents/scripts/install.sh --tool aider
+```
+
+See [aider/README.md](aider/README.md) for details.
+
+---
+
+## Windsurf
+
+All agents are consolidated into a single `.windsurfrules` file for your
+project root.
+
+```bash
+cd /your/project && /path/to/agency-agents/scripts/install.sh --tool windsurf
+```
+
+See [windsurf/README.md](windsurf/README.md) for details.

package/extensions/agency-agents/agents/integrations/aider/README.md

@@ -0,0 +1,38 @@
+# Aider Integration
+
+All 61 Agency agents are consolidated into a single `CONVENTIONS.md` file.
+Aider reads this file automatically when it's present in your project root.
+
+## Install
+
+```bash
+# Run from your project root
+cd /your/project
+/path/to/agency-agents/scripts/install.sh --tool aider
+```
+
+## Activate an Agent
+
+In your Aider session, reference the agent by name:
+
+```
+Use the Frontend Developer agent to refactor this component.
+```
+
+```
+Apply the Reality Checker agent to verify this is production-ready.
+```
+
+## Manual Usage
+
+You can also pass the conventions file directly:
+
+```bash
+aider --read CONVENTIONS.md
+```
+
+## Regenerate
+
+```bash
+./scripts/convert.sh --tool aider
+```

package/extensions/agency-agents/agents/integrations/antigravity/README.md

@@ -0,0 +1,49 @@
+# Antigravity Integration
+
+Installs all 61 Agency agents as Antigravity skills. Each agent is prefixed
+with `agency-` to avoid conflicts with existing skills.
+
+## Install
+
+```bash
+./scripts/install.sh --tool antigravity
+```
+
+This copies files from `integrations/antigravity/` to
+`~/.gemini/antigravity/skills/`.
+
+## Activate a Skill
+
+In Antigravity, activate an agent by its slug:
+
+```
+Use the agency-frontend-developer skill to review this component.
+```
+
+Available slugs follow the pattern `agency-<agent-name>`, e.g.:
+- `agency-frontend-developer`
+- `agency-backend-architect`
+- `agency-reality-checker`
+- `agency-growth-hacker`
+
+## Regenerate
+
+After modifying agents, regenerate the skill files:
+
+```bash
+./scripts/convert.sh --tool antigravity
+```
+
+## File Format
+
+Each skill is a `SKILL.md` file with Antigravity-compatible frontmatter:
+
+```yaml
+---
+name: agency-frontend-developer
+description: Expert frontend developer specializing in...
+risk: low
+source: community
+date_added: '2026-03-08'
+---
+```

package/extensions/agency-agents/agents/integrations/claude-code/README.md

@@ -0,0 +1,31 @@
+# Claude Code Integration
+
+The Agency was built for Claude Code. No conversion needed — agents work
+natively with the existing `.md` + YAML frontmatter format.
+
+## Install
+
+```bash
+# Copy all agents to your Claude Code agents directory
+./scripts/install.sh --tool claude-code
+
+# Or manually copy a category
+cp engineering/*.md ~/.claude/agents/
+```
+
+## Activate an Agent
+
+In any Claude Code session, reference an agent by name:
+
+```
+Activate Frontend Developer and help me build a React component.
+```
+
+```
+Use the Reality Checker agent to verify this feature is production-ready.
+```
+
+## Agent Directory
+
+Agents are organized into divisions. See the [main README](../../README.md) for
+the full roster of 61 specialists.

package/extensions/agency-agents/agents/integrations/cursor/README.md

@@ -0,0 +1,38 @@
+# Cursor Integration
+
+Converts all 61 Agency agents into Cursor `.mdc` rule files. Rules are
+**project-scoped** — install them from your project root.
+
+## Install
+
+```bash
+# Run from your project root
+cd /your/project
+/path/to/agency-agents/scripts/install.sh --tool cursor
+```
+
+This creates `.cursor/rules/<agent-slug>.mdc` files in your project.
+
+## Activate a Rule
+
+In Cursor, reference an agent in your prompt:
+
+```
+@frontend-developer Review this React component for performance issues.
+```
+
+Or enable a rule as always-on by editing its frontmatter:
+
+```yaml
+---
+description: Expert frontend developer...
+globs: "**/*.tsx,**/*.ts"
+alwaysApply: true
+---
+```
+
+## Regenerate
+
+```bash
+./scripts/convert.sh --tool cursor
+```

package/extensions/agency-agents/agents/integrations/gemini-cli/README.md

@@ -0,0 +1,36 @@
+# Gemini CLI Integration
+
+Packages all 61 Agency agents as a Gemini CLI extension. The extension
+installs to `~/.gemini/extensions/agency-agents/`.
+
+## Install
+
+```bash
+./scripts/install.sh --tool gemini-cli
+```
+
+## Activate a Skill
+
+In Gemini CLI, reference an agent by name:
+
+```
+Use the frontend-developer skill to help me build this UI.
+```
+
+## Extension Structure
+
+```
+~/.gemini/extensions/agency-agents/
+  gemini-extension.json
+  skills/
+    frontend-developer/SKILL.md
+    backend-architect/SKILL.md
+    reality-checker/SKILL.md
+    ...
+```
+
+## Regenerate
+
+```bash
+./scripts/convert.sh --tool gemini-cli
+```

package/extensions/agency-agents/agents/integrations/opencode/README.md

@@ -0,0 +1,58 @@
+# OpenCode Integration
+
+OpenCode uses the same agent format as Claude Code — `.md` files with YAML
+frontmatter stored in `.opencode/agent/`. No conversion is technically
+needed, but this integration packages the agents into the correct directory
+structure for drop-in use.
+
+## Install
+
+```bash
+# Run from your project root
+cd /your/project
+/path/to/agency-agents/scripts/install.sh --tool opencode
+```
+
+This creates `.opencode/agent/<slug>.md` files in your project directory.
+
+## Activate an Agent
+
+In OpenCode, reference an agent by its name or description:
+
+```
+Use the Frontend Developer agent to help build this component.
+```
+
+```
+Activate the Reality Checker agent and review this PR.
+```
+
+You can also select agents from the OpenCode UI's agent picker.
+
+## Agent Format
+
+OpenCode agents use the same frontmatter as Claude Code:
+
+```yaml
+---
+name: Frontend Developer
+description: Expert frontend developer specializing in modern web technologies...
+color: cyan
+---
+```
+
+## Project vs Global
+
+Agents in `.opencode/agent/` are **project-scoped**. To make them available
+globally across all projects, copy them to your OpenCode config directory:
+
+```bash
+mkdir -p ~/.config/opencode/agent
+cp integrations/opencode/agent/*.md ~/.config/opencode/agent/
+```
+
+## Regenerate
+
+```bash
+./scripts/convert.sh --tool opencode
+```

package/extensions/agency-agents/agents/integrations/windsurf/README.md

@@ -0,0 +1,26 @@
+# Windsurf Integration
+
+All 61 Agency agents are consolidated into a single `.windsurfrules` file.
+Rules are **project-scoped** — install them from your project root.
+
+## Install
+
+```bash
+# Run from your project root
+cd /your/project
+/path/to/agency-agents/scripts/install.sh --tool windsurf
+```
+
+## Activate an Agent
+
+In Windsurf, reference an agent by name in your prompt:
+
+```
+Use the Frontend Developer agent to build this component.
+```
+
+## Regenerate
+
+```bash
+./scripts/convert.sh --tool windsurf
+```