Corewell SDLC Rumble · Demo · Nov 9, 2026

From Jira card to tested code

The AI does the typing. People make the decisions. Tests prove it. One small feature, a class waitlist, goes through every step with the tools Corewell has today: Jira, GitHub, GitHub Copilot in VS Code, Actions, and Playwright.

AI Copilot does the work Human gate a person decides Automated the pipeline checks

Where AI works, and where people decide

5steps where AI does the work
5points where a person decides
7automated checks on every PR
1 Card2 Spec3 Approve4 Assess5 Tests6 Build7 Review8 Deploy
AIGitHub Copilot Drafts the specScores the riskWrites the testsWrites the codeReviews the PR
PeopleHuman gates Writes the cardApproves the rulesLead confirms riskDev approves PRMerges, PO accepts
AutomatedPipeline gates Playwright: redLint, security, testsRed check blocks mergePreview deploy

Rule of thumb: AI writes, people decide, the pipeline proves. No AI output reaches users without a human approval and a green build.

The 8 steps

  1. 1

    The Jira card

    Product owner

    CSD-1 is short and unclear, like most real cards: "add a waitlist", "some time to claim it". A developer would have to guess the rules.

    Tool: JiraOutput: a card
  2. 2

    Card becomes a spec

    Copilot

    Copilot reads the card and writes business rules R1–R6 with exact numbers, Given/When/Then acceptance criteria, and a list of open questions it will not guess.

    Tool: Copilot Chat in VS CodeType: /spec-from-jira
  3. 3

    Approval

    Product owner + QA

    A person answers the open questions and approves the rules, not the code. The card moves to Spec Approved. Nothing is built before this.

    Tool: Jira status + spec status: Approved

    "The business owner approves the rules. Product and QA agree before anyone builds."

  4. 4

    Assessment

    CopilotLead confirms

    Copilot scores the risk: PHI, auth, payments, size. The score sets the review path. CSD-1 is Low. CSD-3 (phone and date of birth on the roster) is High.

    Type: /assess-changeLow: AI review + 1 devHigh: + dev lead + security
  5. 5

    Tests first: red

    CopilotPlaywright

    Each acceptance criterion becomes one Playwright test with the same ID (AC1–AC7). They fail, because the code does not exist yet. The proof comes before the code.

    Type: /tests-from-specResult: 7 fail, 4 pass
  6. 6

    Build: green

    Copilot agentActions

    Copilot writes the code until the tests pass. The change is small: one logic file and one data file. GitHub Actions runs 3 jobs on the pull request: code quality, security, and tests.

    Result: 11 tests pass, all checks greenBranch: CSD-1-waitlist
  7. 7

    Review: the bug gets caught

    Copilot reviewPlaywright gateDeveloper approves

    Copilot code review checks the PR against the spec. Two planted problems show the gates: a one-line logic bug (AC4 and AC6 fail), and CSD-3 built without approval. Its tests pass, but the PHI guard and Semgrep stop it.

    Review rules: .github/copilot-instructions.md
  8. 8

    Deploy and close the loop

    Cloudflare PagesMerge

    Every branch gets a preview URL. The same Playwright tests can run against the preview. CI publishes a change record and posts its link on the PR and the Jira card.

    Then: CSD-2 changes 24 hours to 48. Spec, tests, and code move together.

The rules, and the test that proves each one

RuleWhat it saysTestGreen buildBroken build
R1Confirmed plus offered seats can never be more than the class capacity.AC7PassPass
R2When a class is full, a new person joins the waitlist and sees their position (#1, #2).AC1, AC2AC1AC2AC1AC2
R3One email holds only one place per class, a seat or a waitlist place. Case and spaces do not matter.AC3PassPass
R4When a seat opens, the first person on the waitlist gets a seat offer and a notice.AC4PassFail
R5A seat offer is held for 24 hours. The person can accept it in that time.AC5PassPass
R6An offer not accepted in 24 hours expires. The seat goes to the next person.AC6PassFail

Rules come from the approved spec: CSD-1-class-waitlist.md. Click a result to open that test in the Playwright report.

What Playwright does

A robot user that checks the rules

Playwright is a free, open-source testing tool from Microsoft. It opens a real browser and uses the app the way a person does: it types, clicks, and reads the screen. Then it compares what it sees with what the rule says. If they do not match, the test fails.

  • Where it runs: on a laptop (npm test) and in GitHub Actions on every pull request.
  • What it stops: a failed test blocks the merge, so a broken rule cannot reach users.
  • What it gives you: an HTML report with every test, every step, its time, and a screenshot of each failure.
  • Why it fits here: Corewell QA already uses Playwright. This demo writes the tests from the acceptance criteria before the code, not after.

Test AC6 in plain words

open CPR & First Aid (3 seats, 2 taken)
register Jordan Kim       → class is full
register Riley Chen       → waitlist #1
register Morgan Diaz      → waitlist #2
click Cancel on Sam Lee  → Riley gets the offer
click +23 hours          ✓ Riley still "Offered"
click +1 hour            ✓ Riley's offer expired
                         ✓ Morgan now "Offered"

It tests both sides of the 24-hour limit. In the broken build, Morgan gets the first offer, so this test fails.

Build checks: quality and security gates

CheckToolWhat it catchesConfig
Code qualityESLintBugs, unused code, functions too complex to review (complexity over 12)eslint.config.js
Accessibilityaxe + PlaywrightWCAG 2.1 A and AA problems: contrast, labels, keyboard useaccessibility.spec.js
PHI guardCustom scriptPatient data patterns: phone, SSN, date of birth, MRN fields, real emailsphi-guard.mjs
Code securitySemgrepCross-site scripting (HTML from variables), eval, sensitive data in browser storage.semgrep.yml
SecretsGitleaksAPI keys, passwords, and tokens in code.gitleaks.toml
Dependenciesnpm auditPackages with known high-severity vulnerabilitiespackage.json
BehaviorPlaywrightEvery acceptance criterion in the approved specwaitlist.spec.js

The security catch: CSD-3

CSD-3 asks to show phone and date of birth on the roster. The assessment says High risk, but in this branch someone built it anyway. All 11 tests pass. The security job fails:

  • PHI guard: 4 findings in the seed data (phone numbers and date-of-birth fields).
  • Semgrep: 1 finding. The roster builds HTML from data with innerHTML, which allows cross-site scripting.

All results in one place

The check results page shows every check on every branch, with the real tool output.

"Passing tests is not enough. The pipeline also checks for patient data, unsafe code, and secrets."

Change control: a shareable record for every change

What CI makes on every run

  1. All checks run: quality, security, and tests.
  2. CI builds one change record page: Jira key, PR, branch, commit, every check result with the tool output, and the full Playwright report.
  3. CI publishes it to Cloudflare at its own permanent link. Later runs do not change it.
  4. CI posts the link as a comment on the PR and on the Jira card.

"The approver does not need GitHub access. They open one link and see what changed, what was checked, and the result."

Sample change records

Built by change-record.mjs in the workflow. Also kept 90 days as a GitHub Actions artifact.

Test results at each step

AI usage and rough cost per story

Since June 1, 2026, GitHub Copilot bills AI use by tokens at each model's API rate, paid from monthly AI Credits. Copilot Business includes $19 of credits per user each month. Code completions stay included. The table below is an estimate for one story like CSD-1. Change the rates to match the model you pick.

AI stepInput tokensOutput tokensCost
Total per story

Change the numbers

Monthly AI cost (estimate)
Included credits ($19 × devs)
Extra spend

The coding agent and code review also use GitHub Actions minutes, which are not in this number.

How to track the real numbers

  1. GitHub billing: on github.com, the org's Billing Overview page shows AI Credit use by user and model. Set budgets per org, cost center, or user.
  2. On each PR: the PR template now asks which AI was used and about how many tokens, so cost connects to the Jira card.
  3. Across tools: the Augusto AI usage dashboard joins Copilot, Claude, and other AI spend, so leaders see one number.

How this maps to Corewell today

StepCorewell todayWhat the demo shows
Card → specRequirements live in different placesOne shared spec per card, in the repo
ApprovalInformalA clear human gate in Jira
AssessmentNot doneRisk level sets who must review
Tests firstQA writes Playwright after the buildTests from acceptance criteria, before code
AI reviewCopilot code review is offReview against the spec, with a test gate
TraceabilityHard to follow a rule to its testRule → AC → test → report → PR → card

Same tools you have today. What changes is the order: rules first, tests second, code third, with a person approving at each gate.