What We Used & How

How to read this

For each tool we state: what role used it, on what kind of work, how it was used in practice, and the honest result. We avoid “we use AI for everything” - reviewers want specifics.

Code & engineering

GitHub Copilot - Developers, all projects

Where: day-to-day coding across our .NET/C# services and front-end work on [Project A] and [Project B]. How: in-editor autocomplete and “explain this code.” Developers describe a function or paste a failing test and let Copilot draft the implementation, then review and adjust. Result: measurable speed-up on boilerplate, DTOs, and repetitive CRUD/controller code. Less helpful on domain-heavy logic where it confidently guessed wrong business rules. Net positive once developers learned to keep prompts scoped.

Claude Code / Cursor - Developers & Architect, `[Project C]`

Where: a greenfield microservice rebuild requiring multi-file changes and IaC. How: described the desired service and architecture; the tool scaffolded the project skeleton, Terraform, and Kubernetes manifests across files. Used heavily for refactoring legacy modules. Result: strong for scaffolding and cross-file refactors; the Architect still reviewed every line of generated IaC for insecure defaults and region/cost mistakes (see Problems & Workarounds).

Requirements & product

Claude / ChatGPT - BA & Stakeholders (Product Owner), `[Project A, D]`

Where: turning discovery-call transcripts and stakeholder emails into structured backlog. How: paste raw notes → ask for epics, user stories, and Given/When/Then acceptance criteria, plus an explicit edge-case list. The BA then validated against domain knowledge. Result: large time saving on the first draft and notably better edge-case coverage. Required careful review - the model occasionally invented plausible-but-wrong domain rules.

Quality & testing

AI code review (Copilot review / CodeRabbit) - Quality Engineer, `[Project B, C]`

Where: every pull request. How: AI posts a first-pass review (bugs, smells, missing tests) before a human reviewer looks, so the human focuses on design intent and security nuance. Result: caught real issues earlier and reduced review round-trips; needed tuning to cut noise so developers didn’t start ignoring comments.

AI test generation + Playwright - Quality Engineer, `[Project A, D]`

Where: functional and E2E coverage. How: generated a test matrix from acceptance criteria, then scaffolded Playwright scripts for the automatable subset. Result: compressed test authoring from days to hours; the Quality Engineer owned which cases mattered and pruned weak assertions.

Delivery & communication

Jira AI + Claude - Project Manager, all projects

Where: sprint reporting and risk detection. How: AI drafts the sprint status and flags at-risk stories; the PM edits and adds judgment on what the risks mean. Result: reporting time dropped sharply; the PM reinvested the time into actually clearing blockers.

Meeting assistants (Copilot in Teams / Fireflies) - PM & Stakeholders (PO), all projects

How: transcribe and summarize stakeholder and refinement meetings, extract action items with owners. Result: reliable record of decisions; occasional misattribution of who said what, so summaries are skimmed before circulation.

Summary table

Tool	Role(s)	Project(s)	Honest verdict
GitHub Copilot	Developers	A, B	Strong on boilerplate, weak on domain logic
Claude Code / Cursor	Devs, Architect	C	Great scaffolding; audit IaC carefully
Claude / ChatGPT	BA, Stakeholders (PO)	A, D	Big draft speed-up; validate domain rules
AI code review	Quality Eng.	B, C	Earlier defect catch; tune for noise
AI test gen + Playwright	Quality Eng.	A, D	Hours not days; review assertions
Jira AI + Claude	PM	All	Faster reporting; humans own judgment
Meeting assistants	PM, Stakeholders (PO)	All	Good records; skim before sharing