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.
The principles every agent meets before production, the design system every interface starts from, and how Cortex itself is built and served.
Nine non-negotiable standards for every Kainos agent, with the pre-ship checklist.
Read the principles →Colour tokens, typography and the DESIGN.md method every CoE interface starts from.
Open the design system →How Cortex is built and served: static pages, committed app builds and the serverless API.
See the architecture →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.
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.
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.
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.
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.
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.
scripts/new-project.shWhen 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.
scripts/stand-up-platform.shA person provisions stage and prod, sets branch protection and the gated GitHub Environments, and proves the boundary holds.
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.
The agent plans and applies freely here, inside one resource group per project.
Stage and prod stay in one tenant, so the last parity check before prod is real. Prod waits for a human approval.
Agents have no identity in the tenant that holds stage and prod.
The dev identity an agent drives holds nothing in the CoE tenant.
The prod credential is only mintable from a job running in the protected prod environment.
A required human reviewer, main only. The triggering actor cannot approve themselves.
Agents open PRs and a human merges. This is the first oversight gate.
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.
Tests are the contract. Every change beyond a one-line edit follows the same seven steps and meets the same Definition of Done.
main releasable.Agents load these automatically from AGENTS.md. Each project repo ships its own copy, derived from the platform rules.
Stage and prod hold no agent identity. If a task needs them, prepare the change and hand off.
Branch, let CI run what-if, and let a human merge. Never push to main or merge your own PR.
CI provides it. There is no credential for the CoE tenant, by design.
Pin module versions and propose changes in the platform repo rather than copying code.
Reference them. Never put them in code, parameter files or logs.
Owner rights, stage or prod, policy and identity changes belong to the human Foundation tier.
These live in wd-coe-platform and need GitHub access to the repo.
The authoritative design: topology, identity, governance, CI/CD and the multi-project factory.
docs/platform-design.mdThe test-first loop, decomposing large requirements, design principles and the Definition of Done.
docs/engineering-method.mdThe rulebook every human and coding agent follows: conventions, quality bar and processes.
docs/standards.mdThe copy-paste steps to turn the template into a running wd-coe-<project>.
The one-time go-live steps that onboarding depends on: module registry, gates and acceptance test.
docs/foundation-activation.mdWhy the platform is shaped this way, from the two-tenant topology to skills as capabilities.
docs/adr/The business case, objectives, scope, stakeholders, KPIs, risks and roadmap.
docs/brd.mdWhat the platform must satisfy, with acceptance criteria and traceability.
docs/requirements.mdThe method and the platform design as nine interactive visual views.
GitHub Pages · repo access only