Session abstract
Most teams today use AI as a copilot: a developer writes code and the assistant suggests the next line. That model increases typing speed but leaves the software lifecycle itself unchanged — the same handoffs, the same review load, the same drift between what was requested and what was built.
This session describes a different arrangement, running in production for three months on a greenfield product in the healthcare domain, built by a team of ten.
Here the agent is not an autocomplete but an actor in the lifecycle. A reviewed ticket becomes a verbatim requirements file in the repository. That requirement is transformed into an engineering specification which lives beside the code and stays synchronised with it. The agent generates the implementation and its tests from that specification, and when something must change, the specification is changed first and the code is regenerated — code is never patched ad hoc. Review runs twice before a human opens the pull request: once locally in a fresh context, once in the pipeline, each against a fixed set of review criteria, with every finding blocking the merge.
The session covers the process end to end, the repository artefacts it depends on, the delivery controls that make it safe, the measured results after three months, and the parts that did not work.
What attendees will learn
What actually changes between copilot-assisted coding and an agentic lifecycle — which phases the agent absorbs, which it cannot, and where the human decision points move to.
Spec-Prompt-Driven Development (SPDD) — treating the specification as a maintained repository artefact kept in sync with the code, rather than a document generated once and discarded. Sync, not handoff.
How to structure a repository so an agent has reliable context — verbatim requirements separated from engineering specs, per-service context files, and review criteria stored as reusable, versioned assets.
A two-stage automated review before human review — a local fresh-context pass and a pipeline pass, both running the same explicit criteria: conformance to the original business requirement, code quality, security, performance, test coverage and documentation accuracy.
Why an agentic SDLC raises the bar on delivery engineering — branch protection, blocking test suites, coverage gates, dependency and static analysis scanning, architecture fitness tests, feature flags and progressive rollout stop being nice-to-haves once an agent is producing volume.
Measured outcomes and honest limits — what improved, what did not, where the process slows a team down, and what still requires human judgement.
