Documentation

Everything you need to run Baxter — from first install to the templates and philosophy behind it.

Templated Artefacts

Templated artefacts are Baxter's core skills — every one produces its output from a template in templates/; paste any raw request and Baxter drafts a verified document. Each template has a dedicated folder in artefacts/ — edit any to match your team's conventions.

These templates are yours to change.

Open any file in templates/ and adjust the sections, headings, or acceptance criteria format to match your team's standards. The agent reads whichever version is on disk — no config required.

What the agent reads when building each artefact

BRD — your raw request only. No codebase check — written before code exists. Non-technical by design: Who, Why, What, with features one line each.
PRD — every CR touching the module (joined together) + linked BRDs + coderepo/ to fill gaps no CR covers. Full artefact verification. Stays local — never pushed to GitHub.
PDcoderepo/ (reflecting the module after its CRs are built) + artefacts/module-registry/modules.md + artefacts/role-registry/roles.md for the access columns + linked BRDs and TIPs. Full artefact verification. Never reads the module's PRD as an input — the template has nowhere for one to appear — so drift between requested and built stays visible.
TIP — linked BRD + coderepo/ + artefacts/module-registry/modules.md. Full artefact verification including data model.
TC — PRD + PD for the feature's module, both generated automatically first if either is missing. Full artefact verification. Where the two disagree, generates two labelled test cases rather than picking a side.
BRcoderepo/ + artefacts/module-registry/modules.md. Verifies the behaviour is a genuine bug, not expected functionality.
CRcoderepo/ + artefacts/module-registry/modules.md + linked BRDs. Verifies feasibility and checks for conflicts.
AI — linked BRD + coderepo/. Full artefact verification including integration and data model.
DIA — linked CR or BRD + coderepo/. Verifies flows and states match the real codebase.
ERD — linked BRD, CR, or TIP + coderepo/. Verifies table names, column names, and relationships against the codebase schema.
Retrospective BRD update — existing BRD + linked TIP/PD + coderepo/. Reconciles a BRD you already have against what shipped, and increments its version. For a product built without a BRD at all, /generate-retrospective-brd writes a new one from the codebase instead — saved as {date}-{product}-retrospective-BRD.md, with every module marked Existing and the document itself labelled retrospective. Its check is about evidence quality, not feasibility: what the code proves versus what was inferred.
CLQ — generated from sanity check ❌ findings. No additional input needed. Opt-in: Baxter offers to draft it after any sanity check with blockers. Saved to artefacts/client-clarification-requests/.

Full artefact verification covers: names, technical feasibility, logic consistency, data model, roles and permissions, gaps and edge cases, and UX challenges.

Two registries every artefact is checked against

Both are generated from your codebase by a power skill, saved to artefacts/ and context/, and re-read before every artefact — never remembered from earlier in a conversation. Both are yours to edit; your correction always wins.

/generate-module-registry

Modules — what the product is made of

One row per module, with the filename slug that prefixes every artefact — {date}-{slug}-CR.md, {slug}-PRD.md, {MODULE}_TC01.md. Consistent module naming and grouping is the whole point: when a module drifts or gets regrouped, the artefact set fragments along with it. A module the registry does not have yet is marked (new module) in the artefact, never silently invented.

/generate-role-registry

Roles — who can do what

The product's default roles — built into the code, present in every deployment. Deliberately stricter than the module registry: the codebase is the only permitted source, with no provisional mode and no fallback. Customer-created custom roles, permissions, job titles held as data, service accounts, and subscription tiers are all excluded, and the exclusions are stated in the file rather than dropped silently.

Why roles are held to a higher standard: a wrong module name is visible — the slug is sitting in the filename. A wrong role name is not: it silently corrupts every access statement in every PD, PRD, and test case built on it, and nothing downstream catches it. So every role named in any artefact is written Display Name (`code_identifier`) on first appearance — the registry's name, then the literal value from the code. That identifier is the only code-level string allowed in an artefact body, and it is what makes a role claim checkable at all.

What to say for each artefact

You never name a template — just describe what you need in plain language. Add your codebase to coderepo/, paste any raw request into Claude Code, Cursor, or GitHub Copilot, and Baxter classifies it, runs the full sanity check against your source files, and asks before saving. The signal words show what Baxter listens for.

Artefact Example prompt — paste raw text like this
🐛 Bug Report (BR)
"The reports endpoint returns 500 when a duplicate name is submitted"
🔄 Change Request (CR)
"Add a bulk export option to the orders list"
🤖 AI Feature (AI)
"We need an AI feature to auto-suggest categories from the item description"
📋 Business Requirements (BRD) — pre-dev, for clients & leadership. Who, Why, What — non-technical
"Write up the requirements for recurring invoices"
📑 Product Requirements (PRD) — pre-dev, team-facing, joins a module's CRs
"Consolidate the requirements for the billing module"
📖 Product Documentation (PD) — post-dev
"Document the authentication module"
🏗️ Implementation Plan (TIP)
"Write an implementation plan for the bulk import feature"
🧪 Test Cases (TC)
"Generate test cases for the billing module"
🗂️ Entity Relationship Diagram (ERD)
"Draw an ERD for the orders and customers tables"
📐 Diagram (DIA)
"Diagram the checkout flow from API request to database"

Baxter applies the first match in priority order, confirms the template, and asks before saving. If nothing matches, it asks you one clarifying question. These prompts are illustrative — phrase yours however you like.

Folder layout

One folder, one producer — every folder under artefacts/ is named after the thing that fills it, and exactly one thing fills each.

agentic-ba/
├── coderepo/                             ← YOUR PROJECT SOURCE CODE HERE
│   └── (your app, API, schema, migrations…)
├── artefacts/                            ← named for the artefact each holds
│   ├── business-requirements/            ← BRDs
│   ├── product-requirements/             ← PRDs
│   ├── product-documentation/            ← PDs
│   ├── technical-implementation-plans/   ← TIPs
│   ├── test-cases/                       ← test cases
│   ├── test-plans/                       ← test plans
│   ├── bug-reports/                      ← bug reports
│   ├── change-requests/                  ← change requests
│   ├── ai-feature-specs/                 ← AI feature specs
│   ├── flow-diagrams/                    ← flowcharts, sequence, state
│   ├── er-diagrams/                      ← entity relationship diagrams
│   ├── client-clarification-requests/    ← client clarification requests
│   ├── module-registry/                  ← module registry (what the product is made of)
│   ├── role-registry/                    ← role registry (the product's built-in roles)
│   ├── release-notes/                    ← pre-release notes
│   ├── branch-comparisons/               ← branch diffs
│   ├── release-validation/               ← release validation reports
│   ├── sample-data/                      ← sample data records (beta)
│   └── change-visualisations/            ← clickable CR prototypes
├── templates/                            ← core skills: BR, CR, AI, BRD, PRD, PD, TIP, TC, DIA, ERD, CLQ
├── .claude/commands/                     ← power skills: thirteen slash-command workflows
├── context/                              ← free-form reference files (optional)
├── preferences.json                      ← optional configuration
├── CLAUDE.md                             ← agent instructions
└── AGENTS.md                             ← identical copy, kept in sync automatically

Where two things look related but come from different producers they still stay apart: test cases are authored from a template, test plans are generated from those cases by a skill, so they sit in test-cases/{MODULE}/ and test-plans/{MODULE}/, joined by the module name.

Bugs

artefacts/bug-reports/

Filed when something is broken. Verified against the codebase to confirm the behaviour is a genuine bug, not expected functionality.

BR — Bug Report

templates/BR-Bug-Report.md
Bug Report TitleProblem and ContextModule(s)Submodule(s)Expected BehaviourActual BehaviourHow to ReproducePreconditionsChecklistInstances TestedMedia / JAM Links
▶ Preview template
# [Module Name] Bug Report Title

## Problem and Context
(description of the end users issue, significance, and background)

## Module(s)
<Primary module(s) from artefacts/module-registry/modules.md where this bug occurs>

## Submodule(s)
<Specific submodule(s)/feature area(s) within the module(s) above. Also flag any additional module(s) likely impacted as a dependency, marked "(suggested — dependency)">

### Expected Behaviour

### Actual Behaviour

## How to Reproduce

### Preconditions (including roles tested, specific data point if any, or other)

## Checklist
(fixes required for this — restrict only to relevant steps)
- [ ] Item to fix 1
- [ ] Item to fix 2
- [ ] Item to fix 3

## Instances Tested
(If the input mentions instances, check them off here. If not, ignore this section.)
- [ ] Development
- [ ] Staging
- [ ] Demo
- [ ] Production

## Media (Including JAM.dev or video links if any)

Changes

artefacts/change-requests/

New features and behaviour changes. Baxter checks artefacts/change-requests/ for a CR that already covers the same request before drafting a new one. Feasibility and conflicts checked against the codebase. Grouped issues use a subfolder with a master CR and sub-CRs. Unfinished drafts and backlog ideas live in artefacts/change-requests/BA-backlog/ until finalised or pushed.

CR — Change Request

templates/CR-Change-Request.md
Feature TitleSummaryProblem & ContextUser StoryModule(s)Submodule(s)In Scope ChecklistOut of ScopeDesign & MediaAcceptance CriteriaTechnical NotesFinal Working Loom URLSource Request URL
▶ Preview template
# [Module Name] Feature Title
<prefix with the primary module name in square brackets, then a compact feature title>

## Summary
Clear explanation of why this is important to build and what value it brings.

## Problem & Context
<description of the users pain points and how this solution will help>

## User Story
As a [user], I want this [functionality] so that I can achieve this [benefit].

## Module(s)
<Primary module(s) from artefacts/module-registry/modules.md that this change affects>

## Submodule(s)
<Specific submodule(s)/feature area(s) within the module(s) above. Also flag any additional module(s) likely impacted as a dependency, marked "(suggested — dependency)">

## In Scope Checklist
- [ ] Item 1
- [ ] Item 2

## Out of Scope
(placeholder)

## Acceptance Criteria (QA Team)
(placeholder)

## Technical Notes (Dev Team)
(placeholder)

## Source Request URL (e.g. your issue tracker, Slack, email)
(placeholder)

AI Features

artefacts/ai-feature-specs/

AI and LLM-powered capabilities — auto-fill, suggestions, predictions, generation. Includes prompt templates, model selection, and grounding data.

AI — AI Feature Issue

templates/AI-Feature-Spec.md
AI Feature TitleSummaryProblem & ContextUser StoryIn Scope ChecklistOut of ScopeInput DataPrompt(s)Models & FallbackExecution SettingsGrounding DataDesign & MediaIntegration PlanAcceptance CriteriaVideo walkthrough
▶ Preview template
# AI Feature Title

## Summary
What the AI feature does and the value it delivers.

## Problem & Context
What the user is currently doing manually, and why AI is the right solution.

## User Story
As a [user], I want [AI capability] so that [benefit].

## Input Data
What data the model receives as context (fields, records, history).

## Prompt(s)
```
System: {system prompt}
User: {user prompt template}
```

## Models & Fallback
Primary: {model}  |  Fallback: {model}

## Acceptance Criteria
- AC-01: {Observable, testable AI output outcome}

Business Requirements

artefacts/business-requirements/

The one artefact written for the client, not the team. It answers three questions and stops there: who the product is for, why it exists, and what each module does — with features listed one line each. Written from a raw client request before any code exists, so there is no codebase check. Deliberately non-technical: no functional requirements, no acceptance criteria, no business rules, nothing about implementation. All of that lives in the module's PRD and its CRs, which is exactly why the two documents never overlap. A BRD's scope is also what tells you which module(s) will need a PRD once their CRs start accumulating. For a product already built without one, /generate-retrospective-brd writes a BRD straight from the codebase — saved as {date}-{product}-retrospective-BRD.md and marked retrospective in its title, type line, and artefact ID, so it is never mistaken for a BRD written before the build.

BRD — Business Requirements Document

templates/BRD-Business-Requirements-Document.md
OverviewWho — roles and stakeholdersWhy — current situation, objectives, benefitsWhat — modules and high-level featuresScopeAssumptions & ConstraintsOpen QuestionsLinked DocumentsRevision History
▶ Preview template
# Business Requirements Document (BRD)

> **Status:** DRAFT | IN REVIEW | APPROVED
> **Artefact ID:** `{YYYY-MM-DD}-{product-slug}-BRD`
> **Scope:** {Whole product — or the named module(s) this document covers}
> **Author:** Claude (AI) — **Verified by:** {Name / Role}

---

## 1. Overview
{Two or three sentences in plain English: what the product is, who it
serves, and the outcome it delivers.}

---

## 2. Who

### 2.1 Roles

| Role | Who they are | What they use the product for | Modules |
| --- | --- | --- | --- |

---

## 3. Why

### 3.2 Objectives

| # | Objective | Why it matters | How we know it worked |
| --- | --- | --- | --- |
| OBJ-01 | | | |

---

## 4. What

### 4.1 {Module Name} — {New | Existing}

**Purpose:** {One sentence — what this module does for the people who use it.}
**Used by:** {Roles from Section 2.}

**Features:**
- {Feature name} — {one line: what the user can do, and what they get.}

> Features are listed at capability level only. No field lists, rules, or
> acceptance criteria — those belong in the module's PRD and its CRs.

Product Requirements

artefacts/product-requirements/

Team-facing, module-scoped, and where all the detail a BRD leaves out actually lives. A PRD joins every CR that has touched one module into a single consolidated requirements picture — what should happen, sourced from the CRs themselves — then fills in any existing behaviour no CR ever formally covered, so it reflects the whole module rather than just its CR-shaped pieces. Still a before-code artefact: requirements, not an implementation record. That is what separates it from a PD, which documents the same module strictly as built. PRDs stay local — never pushed to GitHub, never shown to a client.

PRD — Product Requirements Document

templates/PRD-Product-Requirements-Document.md
Module SummarySource Change Requests (the join)Functional Requirements (FR-xx, tagged by source CR or Baseline)Non-Functional RequirementsScopeOpen Items / GapsLinked Artefacts
▶ Preview template
# Product Requirements Document (PRD)

> **Status:** DRAFT | IN REVIEW | APPROVED
> **Artefact ID:** `{YYYY-MM-DD}-{module-slug}-PRD`
> **Module:** {Module Name} (or named group of modules)
> **Version:** {e.g. 1.0}

---

## 1. Module Summary
{What this module does today, who uses it, and its scope within the product.}

---

## 2. Source Change Requests

| CR | Summary | Date |
|----|---------|------|
| [{CR title}]({relative path}) | {What it added or changed} | {YYYY-MM-DD} |

---

## 3. Functional Requirements

### FR-01: {Title}
**Description:** {What the system must do.}
**Source:** [{CR title}]({relative path}) — or — Baseline (existing behaviour, no CR)

**Acceptance Criteria:**
- AC-01-01: {Observable, testable outcome}

Product Docs

artefacts/product-documentation/

An after-code artefact: how a module is actually implemented, read straight from the codebase — never invented, never just what was requested. Written after a module's CRs have been built. Deliberately short and scannable: six sections, no per-module subsections and no Linked Artefacts table. It never reads the module's PRD as an input — there is nowhere in a PD for a PRD to appear at all, which is structural rather than a rule to remember, and it is what keeps drift between what was asked and what got built visible. The one artefact that pauses for the role registry: its access columns must be the product's real built-in roles, so if artefacts/role-registry/roles.md does not exist yet, Baxter runs /generate-role-registry first rather than drafting with unverified roles.

PD — Product Documentation

templates/PD-Product-Documentation.md
Overview (default roles + related modules)App Flow (Mermaid)Features by RoleModule ConnectionsNotifications & TriggersKnown Limitations
▶ Preview template
# Product Documentation (PD)

> **Status:** DRAFT | REVIEWED
> **Product:** {Product Name} | **Version:** {v2.4} | **Date:** {YYYY-MM-DD}

---

## Overview
{What it does, who uses it, problem solved. 2–3 sentences max.}

**Default roles:** [from the role registry — each as Display Name (`code_identifier`)]
**Related modules:** [from the module registry — names and groupings exactly as it has them]

---

## App Flow
```mermaid
flowchart LR
    Session --> A1[{Screen or action}]
    A2 --> B1[{Screen or action}]
```

---

## Features by Role

One column per role the product actually has — never padded, never truncated.

| Feature | What it does | {Role 1} (`{role_1_code}`) | {Role 2} (`{role_2_code}`) | Notes |
|---------|-------------|---------|---------|-------|
| {Feature A} | {Specific capability} | View | Create/Edit | {E.g. "Own records only"} |

---

## Module Connections

**Outbound to:**
- {Module}: Sends {payload} when {trigger} — {impact or dependency}

**Inbound from:**
- {Module}: Receives {payload} when {trigger} — {how it is used}

---

## Notifications & Triggers

- **{Event}** (triggered by {role or action}): Notifies {recipient role} via
  {in-app / email / SMS / webhook} — {what the message conveys}

---

## Known Limitations

- {Constraint — e.g. "Bulk imports limited to 1,000 records per file"}

Implementation

artefacts/technical-implementation-plans/

Technical plan for developers. Includes data model, tasks, and API contracts.

TIP — Technical Implementation Plan

templates/TIP-Technical-Implementation-Plan.md
Summary & Effort EstimateImplementation Tasks by LayerAPI ContractsData Model ChangesRisks & Open QuestionsTesting Notes
▶ Preview template
# Technical Implementation Plan (TIP)

> **Status:** DRAFT | IN REVIEW | APPROVED
> **Linked BRD:** [{BRD filename}](../business-requirements/{BRD-filename}.md)
> **Effort:** S (<1 day) / M (1–3 days) / L (3–7 days) / XL (>7 days)

---

## 1. Implementation Tasks

### Backend
| #     | Task | FR(s) | Effort |
|-------|------|-------|--------|
| BE-01 |      |       |        |

### API
| #      | Task                     | FR(s) | Effort |
|--------|--------------------------|-------|--------|
| API-01 | {Endpoint to add/modify} |       |        |

### Frontend
| #     | Task                           | FR(s) | Effort |
|-------|--------------------------------|-------|--------|
| FE-01 | {Component/page to add/modify} |       |        |

---

## 2. API Contracts

### `{METHOD} /api/{endpoint}`
**Auth:** {the project's auth mechanism} — min role: {Role}

```json
{ "field_name": "string" }
```

---

## 3. Data Model Changes

| Column    | Type      | Nullable | Default         |
|-----------|-----------|----------|-----------------|
| id        | {id type} | No       | {generated how} |
| {field}   | {type}    | No       | —               |

Test Cases

artefacts/test-cases/{MODULE}/

One file per test case, grouped by module under test-cases/. Test plans come from a different producer — the /generate-test-plan power skill — so they live in test-plans/{MODULE}/, joined to their cases by the module name. Baxter never generates happy path tests alone — every set must cover all four types and always includes data validation and label accuracy scenarios. Once a suite is saved, Baxter mentions that a Test Plan (TP) can follow via /generate-test-plan — a TC suite is a prerequisite for a TP, never the reverse, and Baxter never runs it automatically.

TC — Test Case

templates/TC-Test-Cases.md
Metadata (ID, priority, type, linked PRD + PD, FR/AC)PreconditionsStep / Action / Input / Expected Result tablePostconditionsExecution log
▶ Preview template
# Test Case: {MODULE}_TC{NN}_{Short_Name}

> **Status:** DRAFT | READY | PASS | FAIL | BLOCKED
> **Priority:** High / Medium / Low
> **Type:** Happy Path / Negative / Role-Based / Edge Case
> **Linked PRD:** [{PRD filename}](../../product-requirements/{PRD-filename}.md) — what should happen
> **Linked PD:** [{PD filename}](../../product-documentation/{PD-filename}.md) — what currently happens
> **FR/AC:** FR-{xx}, AC-{xx}-{xx}

---

## Preconditions
- Tester is logged in as **{Role}** on **{environment}**
- {Any required data or system state}

---

## Test Steps

| Step | Action                              | Input Data    | Expected Result      |
|------|-------------------------------------|---------------|----------------------|
| 1    | {Click / Navigate / Enter / Select} | {Exact value} | {Observable outcome} |
| 2    |                                     |               |                      |

---

## Postconditions
- {What must be true in the system after the test passes}

---

## Execution

| Field       | Value                       |
|-------------|-----------------------------|
| Executed by |                             |
| Environment | Staging / Demo / Production |
| Result      | PASS / FAIL / BLOCKED       |

What Baxter covers in every test suite

Every generated test suite must include all four types. Baxter reads the module's PRD (what should happen) and PD (what currently happens) to derive scenarios — nothing is invented. When the two disagree on a requirement, Baxter never picks a side silently: it generates two distinct test cases, one for the PRD's required behaviour and one for the PD's actual behaviour, with the latter flagged as a possible defect.

Happy Path

  • Minimum valid submission — mandatory fields only
  • Full submission — all fields populated

Negative

  • Each mandatory field submitted empty — correct error shown, record not saved
  • Each format-validated field submitted with invalid value (wrong email format, invalid date, non-numeric in number field)
  • All fields empty in a single submission
  • Required dropdown or select left unselected

Edge Case

  • Field submitted at character limit (must save) and one character over (must reject or truncate)
  • Free-text field submitted with whitespace only — rejected or trimmed, not saved as-is
  • Free-text field submitted with special characters — handled safely and displayed correctly
  • Empty state — no records exist
  • Search or filter returns no results
  • Pagination at last page and single-page result sets

Role-Based

  • Each role that should have access can complete the action
  • Each role that should not have access is blocked with the correct message
  • Destructive actions blocked for non-permitted roles

Label and error message accuracy is verified in the test steps of every applicable TC — not assumed correct. A coverage summary (e.g. 2 Happy Path, 5 Negative, 4 Edge Case, 2 Role-Based — 13 TCs total) is appended after every generated suite.

Diagrams

artefacts/flow-diagrams/ · artefacts/er-diagrams/

Two separate templates, so two folders. Flowcharts, sequence, state, and user journey diagrams are DIAs and save to flow-diagrams/. Entity relationship diagrams have their own template, verified against the real schema, and save to er-diagrams/.

DIA — Diagram

templates/DIA-Diagram.md
PurposeDiagram (Mermaid)KeyNotes & AssumptionsRevision History
▶ Preview template
# Diagram: {Title}

> **Status:** DRAFT | IN REVIEW | APPROVED
> **Type:** Flowchart / Sequence / ER / State / User Journey
> **Linked artefact:** [{CR or BRD filename}](../change-requests/{filename}.md)

---

## Purpose
{1–2 sentences: what this diagram shows, why it was created, and who the audience is.}

---

## Diagram

```mermaid
flowchart LR
    A[{Start — e.g. User logs in}] --> B{Decision point}
    B -- Yes --> C[{Outcome A}]
    B -- No --> D[{Outcome B}]
    C --> E[{End state}]
    D --> E
```

---

## Key
- {Symbol or shape} — {what it represents}
- {Arrow style} — {what it means}

---

## Notes & Assumptions
- {Any decisions made in drawing the diagram that the reader should know about}

ERD — Entity Relationship Diagram

templates/ERD-Entity-Relationship-Diagram.md
PurposeMermaid ERD DiagramRelationship KeyNotes & AssumptionsRevision History
▶ Preview template
# ERD: {Title}

> **Status:** DRAFT | IN REVIEW | APPROVED
> **Linked artefact:** [{BRD, CR, or TIP filename}](../../path/to/artefact.md)

---

## Purpose
{Which tables are shown, why this diagram was created, and who the audience is.}

---

## Diagram

```mermaid
erDiagram
    TABLE_NAME {
        int id PK
        varchar name
        int foreign_id FK
        date created_at
    }
    OTHER_TABLE {
        int id PK
        varchar description
    }
    TABLE_NAME ||--o{ OTHER_TABLE : "has many"
```

---

## Relationship Key

| Notation   | Meaning                      |
|------------|------------------------------|
| ||--||     | One to one                   |
| ||--o{     | One to zero or many          |
| ||--|{     | One to one or many           |
| }o--o{    | Zero or many to zero or many |

---

## Notes & Assumptions
- {Any tables or columns omitted for clarity}

Clarifications

artefacts/client-clarification-requests/

Generated when the sanity check finds blockers. Opt-in after any ❌ finding.

CLQ — Client Clarification Request

templates/CLQ-Client-Clarification-Request.md
Subject lineOpening paragraphOne section per blocker (context + question)Next Steps
▶ Preview template
# Client Clarification Request (CLQ)

> **Status:** DRAFT | SENT | RESOLVED
> **Related Artefact:** [{artefact filename}](../{path}/{filename}.md)
> **Date:** {YYYY-MM-DD}

---

**Subject: {Feature or Module Name} — Clarification Required Before We Proceed**

{Opening: reviewed the request, conducted a full review, N points to raise before work can begin.}

---

## 1. {Blocker title — plain language}

{Context: what the request assumes, what the system currently does, why they conflict.}

**Question:** {One precise, answerable question.}

---

## Next Steps

Once you have reviewed these points, please reply with your answers or preferred approach.
We will not begin scoping or development until these are resolved.

Tips for getting the best results

You never need to structure your input

Paste raw emails, Slack messages, voice transcripts, or Google Doc excerpts exactly as they are. Baxter extracts what it needs. The messier the input, the more value Baxter adds.

Coderepo is the key to verification

Baxter automatically reads coderepo/ before writing every non-BRD artefact — without being asked, every time. How much gets verified tracks what is in there: a full codebase verifies everything, a partial one verifies the part that exists, a starter scaffold still anchors stack and data-model checks, and an empty folder means Baxter explicitly flags every field, module, and route it could not confirm rather than guessing. For production teams, always add your codebase. (A BRD skips the check because it is written before code exists — the one exception is /generate-retrospective-brd, which builds a BRD out of the codebase itself.)

A BRD stays at the business level — on purpose

Who the product is for, why it exists, and what each module does with its features listed one line each. No functional requirements, no acceptance criteria, no rules, nothing technical — all of that lives in the module's PRD and its CRs. Keeping the BRD at this altitude is what makes it something a client will actually read and sign off on. If a feature needs a second sentence, it belongs in a PRD.

You review. You approve. You commit.

Baxter always asks for confirmation before generating, and always presents the artefact for review before saving. Nothing is written without your sign-off. Your name goes in the revision history.

Templates are yours to change

Open any file in templates/ and edit the sections to match your team's standards. Baxter reads whatever is on disk — no config required.

One request at a time

If a client request contains multiple needs (e.g. a bug and a feature), handle them separately. Paste the bug first, then the feature request. Baxter handles one artefact per conversation.

Change Requests are checked for duplicates first

Before drafting a new CR, Baxter searches artefacts/change-requests/ for one that already covers the same request — matching by source link, then by topic — and reports the match instead of drafting a duplicate.

Roles are named exactly as your code names them

Every role in every artefact comes from the role registry, written as the display name followed by its code identifier — "Organisation Administrator (ORG_ADMIN)" — the first time it appears in a table or section. That identifier is the one code-level string allowed in an artefact body, because it is what makes the claim checkable: a display name on its own can be plausibly wrong and nothing downstream would catch it. Roles are held to a stricter standard than modules for exactly that reason — a wrong module name is visible in the filename slug, a wrong role name is silent. Product Documentation is the one artefact that pauses for this: if there is no registry yet, Baxter runs /generate-role-registry before drafting rather than filling the access columns with guesses.

Every CR and BR is tagged and titled by module

Baxter adds a Module(s) and Submodule(s) field to every CR and BR, pulled from your module registry, and flags any likely dependent modules as suggestions. The title itself is prefixed with the primary module — e.g. "[Orders] Print to PDF button on the customer profile".

Baxter The Agentic BA

Ready to work with Baxter?

Open source and free. Drop the harness into any project, open it in Claude Code, Cursor, or GitHub Copilot, and paste your first raw request.