Untitled

Anonymous
Plain Text
11/04/2026 11:20 PM
8.4 KB
20
Indexable
Never
# Coder Team - Roles, Review Groups, and Quality Gates

> Load in full at the start of a session. Storage/loading route: [agents.md](./agents.md); GitHub practices: [GitHub Behavior.md](./GitHub%20Behavior.md); lessons learned: [Lessons Learned.md](./Lessons%20Learned.md); local models: [Token Optimization.md](./Token%20Optimization.md).

## 1. Decision principles

- Quality over speed; validate and review each result appropriately. Code: builds/tests; documentation only: consistency, links, and diff, without unnecessary app/model runs.
- Review non-trivial decisions from **at least three relevant roles**. Roles are perspectives, not a requirement to use separate agents. Briefly weigh concerns against each other; record conflicts and the reasoned decision in the issue/PR or ADR.
- **Security and QA have veto power:** resolve blockers. In a tie, the architect decides; for user-related matters, the PO/end-user advocate decides. Human approval gates remain in force.
- Write clearly for beginners through intermediate experts; code comments should briefly explain only non-obvious reasons.
- Respectfully verify user assumptions against actual behavior and correct them when necessary. Explain and jointly verify standard operation first, rather than deriving an unnecessary UI change from a misunderstanding.
- Keep project changes traceable through issues/branches/PRs. Do not copy central control content into a product repository.

## 2. Roles

| Role | Critical perspective | Typical outcome |
|---|---|---|
| Product Owner / Requirements | Problem, audience, value, scope, priority, and definition of done? | Issue, acceptance criteria |
| Architect | Technology, coupling, maintainability, scalability, technical debt; could it be simpler? | ADR, structure, interfaces |
| Security Engineer | Malicious inputs, secrets, privacy, TLS, permissions, and dependencies? | Threat analysis, security check |
| UX/UI Designer | Self-explanatory, consistent, contrast/keyboard access, understandable errors? | Layout/flows, UI rules |
| Backend Developer | Logic, data/APIs/system access, failure cases, robustness, performance? | Code, interfaces, tests |
| Frontend Developer | Design implemented, responsive interaction, inputs/states correct? | UI code, state management |
| Exploratory Developer | Simpler approach? What does a prototype/experiment demonstrate? | Short-lived spike, feasibility |
| Tester | Happy path, edge/failure cases, and regressions? | Test cases, runner, bug issues |
| QA / Quality Assurance | Criteria met, docs current, known bugs, release-ready? | QA report, approval/rejection |
| DevOps / Release Manager | Reproducible build/CI, versions, packages, install/update, rollback? | Workflows, tags, release notes |
| Technical Writer / Documentation | Understandable for a new user? | README, CHANGELOG, user guide |
| Code Reviewer | Readability, style, consistency, necessary comments, duplication? | PR review |
| Performance/Resource Analyst | CPU, RAM, network, response time, and energy appropriate? | Measurements, optimizations |
| End-User Advocate | Understandable and pleasant without IT knowledge? | Usability feedback in `test` |
| Platform/Operations Advocate (per product) | Target systems/runtime, offline operation, restart, installation/uninstallation? | Platform/operations matrix |
| Privacy/Data Steward (when user data is involved) | Purpose, necessary data, storage location, retention/deletion? | Data flow and deletion rules |

## 3. Review groups

| Work step | Perspectives | Decision |
|---|---|---|
| Idea/requirement | PO, architect, UX, end user, security | Value, scope, acceptance criteria |
| Architecture/design | Architect, security, backend, frontend, UX, exploratory | Structure/technology/interfaces, ADR |
| Spike | Exploratory, architect, performance | Discard or adopt properly |
| Implementation | Backend/frontend, reviewer, security | Self-review before PR |
| Working branch -> `dev` | Reviewer, tester, security, architect, UX | Checklist 4.1 |
| `dev -> test` | Tester, QA, UX, performance | Provide stable state for human testing |
| `test -> main` | User, QA, security, release manager, documentation, architect | User approval and QA completion |
| Refactoring/optimization | Architect, reviewer, performance, tester | Benefit weighed against regression risk |
| Bugfix/hotfix | Tester, backend/frontend, security, QA | Root cause, fix, regression test |

## 4. Quality gates

`dev` allows independent development/spikes, still through an issue/working branch/PR. After a complete self-review, the agent may complete `dev -> test` without additional user approval; the user then receives the state as a second pair of eyes. **`test -> main` remains blocked until the user explicitly approves that exact tested state.** Public release is a separate gate under GitHub A7.

### 4.1 Ready / Done

**Issue Ready:** Problem, acceptance criteria, labels/priority, relevant role perspectives, and open questions are resolved.

**Working branch -> dev:**
- [ ] Issue linked; describe what/why/how it was tested.
- [ ] Code builds cleanly; new/regression tests pass. Validate documentation-only changes appropriately instead of using a product build.
- [ ] Changed OS integrations are appropriately smoke-tested; persistent shell/registry effects only in a test account/VM and with user approval.
- [ ] Code is readable, architecture is simple/consistent, errors are visible; add necessary why-comments.
- [ ] Security reviewed (section 5); UX text/flows and understandable errors reviewed.
- [ ] Directly affected docs/CHANGELOG are current; self-review and CI succeed.

**Additional requirements for dev -> test:**
- [ ] Full test run on the merged state, appropriate technical smoke test, and self-review from the relevant roles.
- [ ] No open critical/high bugs.
- [ ] Test build and startup path provided; manual user review is still pending, do not claim acceptance.
- [ ] Test feedback recorded/prioritized as issues; fixes start again from a `dev` working branch.

**Additional requirements for test -> main:**
- [ ] Manual tests from tester/end-user perspectives completed; no open critical/high bugs.
- [ ] User reviewed the specific tested state and explicitly confirmed promotion.
- [ ] QA report, including user findings, posted as a PR comment **before the merge**.
- [ ] Security final check, current docs, release notes, version tag, and rollback path confirmed.

## 5. Minimum security requirements

- Validate external file/network/UI/argument inputs; prefer allowlists and protect file paths against traversal.
- Secure required network transport with TLS/HTTPS; do not disable certificate validation. Use only the local Ollama API as described in Token Optimization.
- No secrets in code/repositories/logs; use environment variables or secure storage and maintain `.gitignore`. Keep sensitive data out of logs/errors.
- Least privilege; no unnecessary admin permissions. Minimize dependencies and check their provenance, maintenance status, and known vulnerabilities.
- Automated runners execute tests; testers/QA own coverage and acceptance in the Copilot workflow. Local models do not assume that responsibility.

## 6. Project start and completion

Before first implementation, clarify: **problem/audience/use**, **MVP/non-goals**, target systems/runtime/permissions/offline operation, installation/updates/uninstallation, measurable UX/accessibility/privacy/security/reliability/performance goals, and delivery/rollback path. First inspect the repository, project brief, ADRs, build, and tests; do not inherit technology from a previous project.

Technical workflow: [GitHub B5](./GitHub%20Behavior.md#b5-standard-change-workflow). Record far-reaching decisions in an ADR, otherwise in an issue/PR comment. Put reusable lessons in Lessons Learned, Git procedures in GitHub Behavior, and model policy in Token Optimization; do not repeat them everywhere.

Before delivery, briefly ask: Is the problem actually solved (PO)? Simplest viable solution (architect)? Abuse/invalid inputs (security)? Understandable interaction (UX/end user)? Missing edge cases (tester)? Documentation and traceability complete (QA/documentation)?

**Preserve product documents:** README, CHANGELOG, SECURITY, LICENSE, THIRD-PARTY-NOTICES, project brief, provider/interface documentation, and ADRs (`docs/adr/NNNN-title.md`) belong in the project. Do not delete Markdown files indiscriminately; agent guidance is handled only according to the root entry point.
Editor is loading...
Leave a Comment