The standards behind everything we build.

The principles every agent meets before production, the design system every interface starts from, and how Cortex itself is built and served.

The disciplined way agents build software for us.

AI coding agents speed delivery up, and an agent with unchecked access to cloud environments is a real risk. The platform lets agents build freely while humans review, merge and own everything that reaches production.

Dev-first

A scaffolded project is plain code: src/, a spec, a build ledger and local CI. It builds on a laptop or in a container with local tooling. The platform layer stays out of the way until the software has earned it.

A method, not just a pipeline

Every actor, human or agent, follows one engineering method: specify behaviour as tests, work red, green, refactor in small steps, and keep main releasable. AI amplifies whatever method it runs on, so we write the method down.

Skills, composed by choreography

Capabilities such as scaffolding a repo, turning a BRD into a spec or standing up an environment ship as self-contained skills. They choose themselves from shared repo state, and a human triggers each step toward production.

The gates are the product. Agents open pull requests and a human merges. Nothing moves toward production without a person choosing to move it.

How a project travels.

Every project lives in its own wd-coe-<project> repo. It can stay in the first phase for as long as it likes, and nothing needs Azure until it is ready to ship.

Phase A

Scaffold and build locally

The scaffolder creates a dev-first repo from the template, with the build loop, local CI and a project-level AGENTS.md. It calls no Azure.

Who acts
The agent, with a human reviewing PRs
Where it runs
A laptop or a container
Command
scripts/new-project.sh
Phase B

Request an environment

When the software is ready, the Azure delivery layer is rendered into the repo and the dev environment is provisioned, with a human approving each call.

Who acts
The agent, with human approval
Where it runs
Dev, the only target an agent can reach
Command
scripts/stand-up-platform.sh
Foundation

Toward production

A person provisions stage and prod, sets branch protection and the gated GitHub Environments, and proves the boundary holds.

Who acts
A human, at the Foundation tier
Where it runs
Stage and prod, in the clean CoE tenant

Why production stays human-only.

Isolation is a property of the architecture, not a promise. An agent can act only where a credential it can obtain holds a role, so production sits in a tenant where agents have no identity at all.

  1. Tenant separation

    Agents have no identity in the tenant that holds stage and prod.

  2. Per-environment deploy identity

    The dev identity an agent drives holds nothing in the CoE tenant.

  3. OIDC bound to a GitHub Environment

    The prod credential is only mintable from a job running in the protected prod environment.

  4. Environment protection on prod

    A required human reviewer, main only. The triggering actor cannot approve themselves.

  5. Branch protection on main

    Agents open PRs and a human merges. This is the first oversight gate.

  6. Secretless identities

    Managed identities carry no secret, and tokens are short-lived.

Six layers, each independently sufficient. There is no path from a credential an agent can obtain to a change in production, even against a compromised agent, a prompt injection or a bad merge.

How we build, for humans and agents alike.

Tests are the contract. Every change beyond a one-line edit follows the same seven steps and meets the same Definition of Done.

  1. Explore. Read the code, tests and docs. Pin current behaviour before changing it.
  2. Specify. Write acceptance criteria as testable behaviour, including edge cases.
  3. Plan. Name the approach, the seams and what you will not do. Get it reviewed.
  4. Build test-first. Red, green, refactor in small commits. Keep the tree green.
  5. Integrate continuously. Small PRs, merged often. Keep main releasable.
  6. Self-review. Read your own diff as a reviewer would, and run the change.
  7. Open the PR. Record intent and the spec, then hand off. A human reviews and merges.

What every coding agent agrees to.

Agents load these automatically from AGENTS.md. Each project repo ships its own copy, derived from the platform rules.

Confine work to dev

Stage and prod hold no agent identity. If a task needs them, prepare the change and hand off.

Route every change through a PR

Branch, let CI run what-if, and let a human merge. Never push to main or merge your own PR.

Use only the dev deploy identity

CI provides it. There is no credential for the CoE tenant, by design.

Take names and tags from shared modules

Pin module versions and propose changes in the platform repo rather than copying code.

Keep secrets in Key Vault

Reference them. Never put them in code, parameter files or logs.

Stop and hand off

Owner rights, stage or prod, policy and identity changes belong to the human Foundation tier.