Approach
How I Work the Problem
Engineering leadership in the AI era isn't a technical problem. It's an organisational, cultural, and workflow problem that happens to involve a lot of technology.
Foundations First
Test coverage, CI/CD, clear ownership, meaningful backlogs. These aren't glamorous, but organisations that skip them can't absorb AI tooling effectively. Every serious transformation I've led started here.
Two Levels at Once
Being credible with the leadership team on operating model decisions and staying close enough to engineers to know what's actually happening. I operate at both levels at once, and that's what makes transformation stick.
Engineers as the Constraint
Good engineers are scarce and easily disengaged. Tools don't fix that. Culture, autonomy, and meaningful work do. AI adoption fails when it feels imposed. It works when engineers feel like they're gaining capability, not being replaced.
Context by Design, Not by Prompt
Agents don't receive context from runtime prompts. They receive it from the SDLC pipeline: requirements, epics, user stories, architecture specs. The organisation that structures its pipeline to feed agents correctly is the one that gets reliable output. That redesign is a leadership problem, not a tooling one.
Architecture
Intent → Build → Run
At a very high level, the agentic pipeline is a trilogy: three stages, equal parts of the whole, forming one agentic loop. Human-in-the-loop is a design decision at every transition, not a fixed role. It's built in by design, or left out entirely, case by case.
01 · Intent
Requirements & issues
Typically product territory. In this model it's an essential part of the agentic pipeline itself, not an input handed over the wall to engineering, and it covers issues as much as new requirements. Without it, the loop breaks.
02 · Build
Implementation and verification
Where code gets written, tested, and checked against intent. The stage engineers know best, but it only works as well as the intent feeding it.
03 · Run
System monitoring and self-heal
Watching what was built in production, and feeding what it finds back into Intent as new issues, closing the loop. Whether that hand-back needs a human look or runs straight through is a design choice, made case by case.
Agentic SDLC isn't an engineering framework, it's a full end-to-end product lifecycle design. To custom build it, run it, and improve it is where the best engineers still earn their place. Experts are always needed, but the focus may shift from deep specialisation towards value thinking and domain expertise.
Method
Getting There
The workflow becomes your software factory, perhaps even an autonomous one, but there's no shortcut getting there: there's no "Agentic Scrum" playbook. Every organisation needs its own re-design, and because the technology keeps moving, it's not a do-it-once transformation but an evolving one.
Pilots are easy to run and easy to abandon: a recent MIT study (
08/25) found 95% of them fail to reach production. Not because the tools don't work, because nobody redesigned the workflow around them.
1
Acknowledge the baseline — how we work today, technology and people
3
Understand limitations, risks and governance
4
Build the agent foundation — one source of truth for context
5
Design the first agentic workflow — start at Crawl. Define KPIs before you scale it.
6
Walk, then Run — the loop that gets you there: monitor, measure, improve (cycle time, cost, quality, trust)
Run that loop long enough and delivery itself becomes commodity. What stays scarce, and valuable, is human insight: knowing what to build, what to cut, and where trust still has to be earned.
Maturity Model
Where Teams Are Today
Most organisations sit at L1 or L2, ad-hoc AI tool adoption with no systemic redesign. The transformation doesn't happen automatically, it requires deliberate leadership at the critical threshold and beyond.
The gap between L2 and L3 is where most transformations stall. Crossing it requires redesigning workflows, governance, and team structure, not just buying more tools.
Org Model
From Silos to Onion-Layer Org
The silo model was designed for a world where handoffs were unavoidable. In an agentic pipeline, the context loss at every handoff is what breaks delivery. The onion model routes context inward from strategy through to execution, with humans embedded at each layer boundary.
Context flows inward through the pipeline, not from runtime prompts. The org is structured to optimise delivery, not the other way around.
