code-review-standards

The Flowbaby Agent Team is the reference implementation for Flowbaby’s persistent memory system.

These agents are intentionally designed to take advantage of long-term, workspace-scoped memory. They demonstrate what agent workflows look like when memory is treated as infrastructure rather than chat history.

AI coding assistants are powerful but chaotic:

• They forget context between sessions
• They try to do everything at once (plan, code, test, review)
• They skip quality gates and security reviews
• They lose track of decisions made earlier

This repository provides specialized AI agents that each own a specific part of your development workflow:

| Agent | Role |

|-------|------|

| Roadmap | Product vision and epics |

| Planner | Implementation-ready plans (WHAT, not HOW) |

| Analyst | Deep technical research |

| Architect | System design and patterns |

| Critic | Plan quality review |

| Security | Comprehensive security assessment |

| Implementer | Code and tests |

| Code Reviewer | Code quality gate before QA |

| QA | Test strategy and verification |

| UAT | Business value validation |

| DevOps | Packaging and releases |

| Retrospective | Lessons learned |

| ProcessImprovement | Workflow evolution |

Each agent has clear constraints (Planner can't write code, Implementer can't redesign) and produces structured documents that create an audit trail.

Use as many or as few as you need, in any order. They are designed to know their own role and work together with other agents in this repo. They are designed to work together to create a structured and auditable development process. They are also designed to challenge each other to ensure the best possible outcome.

1. Get the Agents

```bash

git clone https://github.com/groupzer0/agents.git

```

2. Add to Your Project

Copy agents to your workspace (per-repo, recommended):

```text

your-project/

└── .github/

└── agents/

├── planner.agent.md

├── implementer.agent.md

└── ... (others you need)

```

Or install them at the user level so they are available across all VS Code workspaces. User-level agents are stored in your [VS Code profile folder](https://code.visualstudio.com/docs/configure/profiles):

• Linux: ~/.config/Code/User/
• macOS: ~/Library/Application Support/Code/User/
• Windows: %APPDATA%\Code\User\

> [!TIP]

> The easiest way to create a user-level agent is via the Command Palette: Chat: New Custom Agent → select User profile. VS Code will place it in the correct location automatically.

3. Use in Copilot Chat

In VS Code, select your agent from the agents dropdown at the top of the Chat panel, then type your prompt:

```text

Create a plan for adding user authentication

```

> [!NOTE]

> Unlike built-in participants (e.g., @workspace), custom agents are not invoked with the @ symbol. You must select them from the dropdown or use the Command Palette.

4. Flowbaby Requirement

These agents require Flowbaby to function correctly.

Flowbaby provides the persistent memory layer that allows agents to remember decisions, constraints, and prior work across sessions. Without Flowbaby, the agents fall back to stateless behavior and lose most of their intended value.

Install [Flowbaby](https://marketplace.visualstudio.com/items?itemName=flowbaby.flowbaby) for cross-session memory:

1. VS Code Extensions → Search "Flowbaby" → Install
2. Command Palette → "Flowbaby: Initialize Workspace"
3. Command Palette → "Flowbaby: Set API Key"

Flowbaby governs memory usage and evaluation limits for these agents.

5. (Optional) Use with GitHub Copilot CLI

You can also use these agents with the GitHub Copilot CLI by placing your .agent.md files under .github/agents/ in each repository where you run the CLI, then invoking them with commands like:

```bash

copilot --agent planner --prompt "Create a plan for adding user authentication"

```

Known limitation (user-level agents): The Copilot CLI currently has an upstream bug where user-level agents in ~/.copilot/agents/ are not loaded, even though they are documented ([github/copilot-cli#452](https://github.com/github/copilot-cli/issues/452)). This behavior and the recommended per-repository workaround were identified and documented by @rjmurillo. Until the bug is fixed, prefer .github/agents/ in each repo.

| Document | Purpose |

|----------|---------|

| [USING-AGENTS.md](USING-AGENTS.md) | Quick start guide (5 min read) |

| [AGENTS-DEEP-DIVE.md](AGENTS-DEEP-DIVE.md) | Comprehensive documentation |

| [CHANGELOG.md](CHANGELOG.md) | Notable repository changes |

| [memory-contract-example.md](vs-code-agents/memory-contract-example.md) | Memory usage patterns |

---

Typical Workflow

```text

Roadmap → Planner → Analyst/Architect/Security/Critic → Implementer → Code Reviewer → QA → UAT → DevOps

```

1. Roadmap defines what to build and why
2. Planner creates a structured plan at the feature level or smaller
3. Analyst researches unknowns
4. Architect ensures design fit. Enforces best practices.
5. Security audits for vulnerabilities. Recommends best practices.
6. Critic reviews plan quality
7. Implementer writes code
8. Code Reviewer verifies code quality
9. QA verifies tests. Ensures robust test coverage
10. UAT confirms business value was delivered
11. DevOps releases (with user approval)

---

🎯 Separation of Concerns

Each agent has one job. Planner plans. Implementer implements. No scope creep.

📝 Document-Driven

Agents produce Markdown documents in agent-output/. Every decision is recorded.

🔒 Quality Gates

Critic reviews plans. Security audits code. QA verifies tests. Nothing ships without checks.

🧠 Robust Memory

With [Flowbaby](https://github.com/groupzer0/flowbaby), agents remember decisions across sessions.

🔄 Handoffs

Agents hand off to each other with context. No lost information between phases.

---

[Flowbaby](https://github.com/groupzer0/flowbaby) is a VS Code extension that solves a specific problem: Copilot forgets what you've discussed. Across sessions, developers repeatedly re-explain context, architecture decisions, and constraints. Flowbaby captures, summarizes, and resurfaces relevant prior work automatically—bridging context between sessions and maintaining continuity within long-running conversations.

The persistent memory layer that powers the Flowbaby Agent Team.

Links

• GitHub: https://github.com/groupzer0/flowbaby
• VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=flowbaby.flowbaby
• Documentation: See the GitHub README for full setup guide

---

```text

agents/

├── CHANGELOG.md # Notable changes

├── README.md # This file

├── USING-AGENTS.md # Quick start guide

├── AGENTS-DEEP-DIVE.md # Comprehensive documentation

├── LICENSE # MIT License

└── vs-code-agents/ # Agent definitions

├── analyst.agent.md

├── architect.agent.md

├── critic.agent.md

├── devops.agent.md

├── implementer.agent.md

├── pi.agent.md # ProcessImprovement

├── planner.agent.md

├── qa.agent.md

├── code-reviewer.agent.md

├── retrospective.agent.md

├── roadmap.agent.md

├── security.agent.md

├── uat.agent.md

└── reference/

└── memory-contract-example.md

```

---

The **Sec